diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml index ec601cfa..2e972bc4 100644 --- a/.github/workflows/publish.yml +++ b/.github/workflows/publish.yml @@ -66,11 +66,7 @@ jobs: env: PERSONAL_ACCESS_TOKEN: ${{ secrets.PERSONAL_ACCESS_TOKEN }} run: | - mkdocs build -f docs/mkdocs.yml - for file in docs/mkdocs_*.yml; do - echo "Building MkDocs site with configuration file: $file" - mkdocs build -f "$file" - done + python docs/build_docs.py git config --global user.name "Glenn Jocher" git config --global user.email "glenn.jocher@ultralytics.com" git clone https://github.com/ultralytics/docs.git docs-repo diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 0e2eb907..633b78f5 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -64,6 +64,7 @@ repos: rev: v2.2.6 hooks: - id: codespell + exclude: 'docs/de|docs/fr|docs/pt|docs/es|docs/mkdocs_de.yml' args: - --ignore-words-list=crate,nd,strack,dota,ane,segway,fo,gool,winn diff --git a/docs/README.md b/docs/README.md index 501fcd45..f3535143 100644 --- a/docs/README.md +++ b/docs/README.md @@ -64,7 +64,8 @@ For multi-language MkDocs sites use the following additional steps: rm -rf site # Loop through all *.yml files in the docs directory - for file in docs/*.yml; do + mkdocs build -f docs/mkdocs.yml + for file in docs/mkdocs_*.yml; do echo "Building MkDocs site with configuration file: $file" mkdocs build -f "$file" done diff --git a/docs/build_docs.py b/docs/build_docs.py new file mode 100644 index 00000000..472c08a3 --- /dev/null +++ b/docs/build_docs.py @@ -0,0 +1,77 @@ +# Ultralytics YOLO 🚀, AGPL-3.0 license +""" +This Python script is designed to automate the building and post-processing of MkDocs documentation, particularly for +projects with multilingual content. It streamlines the workflow for generating localized versions of the documentation +and updating HTML links to ensure they are correctly formatted. + +Key Features: +- Automated building of MkDocs documentation: The script compiles both the main documentation and + any localized versions specified in separate MkDocs configuration files. +- Post-processing of generated HTML files: After the documentation is built, the script updates all + HTML files to remove the '.md' extension from internal links. This ensures that links in the built + HTML documentation correctly point to other HTML pages rather than Markdown files, which is crucial + for proper navigation within the web-based documentation. + +Usage: +- Run the script from the root directory of your MkDocs project. +- Ensure that MkDocs is installed and that all MkDocs configuration files (main and localized versions) + are present in the project directory. +- The script first builds the documentation using MkDocs, then scans the generated HTML files in the 'site' + directory to update the internal links. +- It's ideal for projects where the documentation is written in Markdown and needs to be served as a static website. + +Note: +- This script is built to be run in an environment where Python and MkDocs are installed and properly configured. +""" + +import os +import re +import shutil +from pathlib import Path + +DOCS = Path(__file__).parent.resolve() +SITE = DOCS.parent / 'site' + + +def build_docs(): + """Build docs using mkdocs.""" + if SITE.exists(): + print(f'Removing existing {SITE}') + shutil.rmtree(SITE) + + # Build the main documentation + print(f'Building docs from {DOCS}') + os.system(f'mkdocs build -f {DOCS}/mkdocs.yml') + + # Build other localized documentations + for file in DOCS.glob('mkdocs_*.yml'): + print(f'Building MkDocs site with configuration file: {file}') + os.system(f'mkdocs build -f {file}') + print(f'Site built at {SITE}') + + +def update_html_links(): + """Update href links in HTML files to remove '.md'.""" + html_files = SITE.rglob('*.html') + for html_file in html_files: + with open(html_file, 'r+', encoding='utf-8') as file: + content = file.read() + updated_content = re.sub(r'href="([^"]+)\.md"', r'href="\1"', content) + file.seek(0) + file.write(updated_content) + file.truncate() + + +def main(): + # Build the docs + build_docs() + + # Update .md in href links + update_html_links() + + # Show command to serve built website + print('Serve site at http://localhost:8000 with "python -m http.server --directory site"') + + +if __name__ == '__main__': + main() diff --git a/docs/de/datasets/index.md b/docs/de/datasets/index.md new file mode 100644 index 00000000..ff115c3d --- /dev/null +++ b/docs/de/datasets/index.md @@ -0,0 +1,127 @@ +--- +comments: true +description: Erkunden Sie verschiedene von Ultralytics unterstützte Computer Vision Datensätze für Objekterkennung, Segmentierung, Posenschätzung, Bildklassifizierung und Multi-Objekt-Verfolgung. +keywords: Computer Vision, Datensätze, Ultralytics, YOLO, Objekterkennung, Instanzsegmentierung, Posenschätzung, Bildklassifizierung, Multi-Objekt-Verfolgung +--- + +# Übersicht über Datensätze + +Ultralytics bietet Unterstützung für verschiedene Datensätze an, um Computervisionsaufgaben wie Erkennung, Instanzsegmentierung, Posenschätzung, Klassifizierung und Verfolgung mehrerer Objekte zu erleichtern. Unten finden Sie eine Liste der wichtigsten Ultralytics-Datensätze, gefolgt von einer Zusammenfassung jeder Computervisionsaufgabe und den jeweiligen Datensätzen. + +!!! note + + 🚧 Unsere mehrsprachige Dokumentation befindet sich derzeit im Aufbau und wir arbeiten intensiv an deren Verbesserung. Vielen Dank für Ihre Geduld! 🙏 + +## [Erkennungsdatensätze](../../datasets/detect/index.md) + +Die Objekterkennung mittels Bounding Box ist eine Computervisionstechnik, die das Erkennen und Lokalisieren von Objekten in einem Bild anhand des Zeichnens einer Bounding Box um jedes Objekt beinhaltet. + +- [Argoverse](../../datasets/detect/argoverse.md): Ein Datensatz mit 3D-Tracking- und Bewegungsvorhersagedaten aus städtischen Umgebungen mit umfassenden Annotationen. +- [COCO](../../datasets/detect/coco.md): Ein umfangreicher Datensatz für Objekterkennung, Segmentierung und Beschreibung mit über 200.000 beschrifteten Bildern. +- [COCO8](../../datasets/detect/coco8.md): Enthält die ersten 4 Bilder aus COCO Train und COCO Val, geeignet für schnelle Tests. +- [Global Wheat 2020](../../datasets/detect/globalwheat2020.md): Ein Datensatz mit Bildern von Weizenköpfen aus aller Welt für Objekterkennungs- und Lokalisierungsaufgaben. +- [Objects365](../../datasets/detect/objects365.md): Ein hochwertiger, großer Datensatz für Objekterkennung mit 365 Objektkategorien und über 600.000 annotierten Bildern. +- [OpenImagesV7](../../datasets/detect/open-images-v7.md): Ein umfassender Datensatz von Google mit 1,7 Millionen Trainingsbildern und 42.000 Validierungsbildern. +- [SKU-110K](../../datasets/detect/sku-110k.md): Ein Datensatz mit dichter Objekterkennung in Einzelhandelsumgebungen mit über 11.000 Bildern und 1,7 Millionen Bounding Boxen. +- [VisDrone](../../datasets/detect/visdrone.md): Ein Datensatz mit Objekterkennungs- und Multi-Objekt-Tracking-Daten aus Drohnenaufnahmen mit über 10.000 Bildern und Videosequenzen. +- [VOC](../../datasets/detect/voc.md): Der Pascal Visual Object Classes (VOC) Datensatz für Objekterkennung und Segmentierung mit 20 Objektklassen und über 11.000 Bildern. +- [xView](../../datasets/detect/xview.md): Ein Datensatz für Objekterkennung in Überwachungsbildern mit 60 Objektkategorien und über 1 Million annotierten Objekten. + +## [Datensätze für Instanzsegmentierung](../../datasets/segment/index.md) + +Die Instanzsegmentierung ist eine Computervisionstechnik, die das Identifizieren und Lokalisieren von Objekten in einem Bild auf Pixelebene beinhaltet. + +- [COCO](../../datasets/segment/coco.md): Ein großer Datensatz für Objekterkennung, Segmentierung und Beschreibungsaufgaben mit über 200.000 beschrifteten Bildern. +- [COCO8-seg](../../datasets/segment/coco8-seg.md): Ein kleinerer Datensatz für Instanzsegmentierungsaufgaben, der eine Teilmenge von 8 COCO-Bildern mit Segmentierungsannotationen enthält. + +## [Posenschätzung](../../datasets/pose/index.md) + +Die Posenschätzung ist eine Technik, die verwendet wird, um die Position des Objekts relativ zur Kamera oder zum Weltkoordinatensystem zu bestimmen. + +- [COCO](../../datasets/pose/coco.md): Ein großer Datensatz mit menschlichen Pose-Annotationen für Posenschätzungsaufgaben. +- [COCO8-pose](../../datasets/pose/coco8-pose.md): Ein kleinerer Datensatz für Posenschätzungsaufgaben, der eine Teilmenge von 8 COCO-Bildern mit menschlichen Pose-Annotationen enthält. +- [Tiger-pose](../../datasets/pose/tiger-pose.md): Ein kompakter Datensatz bestehend aus 263 Bildern, die auf Tiger fokussiert sind, mit Annotationen von 12 Schlüsselpunkten pro Tiger für Posenschätzungsaufgaben. + +## [Bildklassifizierung](../../datasets/classify/index.md) + +Die Bildklassifizierung ist eine Computervisionsaufgabe, bei der ein Bild basierend auf seinem visuellen Inhalt in eine oder mehrere vordefinierte Klassen oder Kategorien eingeteilt wird. + +- [Caltech 101](../../datasets/classify/caltech101.md): Enthält Bilder von 101 Objektkategorien für Bildklassifizierungsaufgaben. +- [Caltech 256](../../datasets/classify/caltech256.md): Eine erweiterte Version von Caltech 101 mit 256 Objektkategorien und herausfordernderen Bildern. +- [CIFAR-10](../../datasets/classify/cifar10.md): Ein Datensatz mit 60.000 32x32 Farbbildern in 10 Klassen, mit 6.000 Bildern pro Klasse. +- [CIFAR-100](../../datasets/classify/cifar100.md): Eine erweiterte Version von CIFAR-10 mit 100 Objektkategorien und 600 Bildern pro Klasse. +- [Fashion-MNIST](../../datasets/classify/fashion-mnist.md): Ein Datensatz mit 70.000 Graustufenbildern von 10 Modekategorien für Bildklassifizierungsaufgaben. +- [ImageNet](../../datasets/classify/imagenet.md): Ein großer Datensatz für Objekterkennung und Bildklassifizierung mit über 14 Millionen Bildern und 20.000 Kategorien. +- [ImageNet-10](../../datasets/classify/imagenet10.md): Ein kleinerer Teildatensatz von ImageNet mit 10 Kategorien für schnelleres Experimentieren und Testen. +- [Imagenette](../../datasets/classify/imagenette.md): Ein kleinerer Teildatensatz von ImageNet, der 10 leicht unterscheidbare Klassen für ein schnelleres Training und Testen enthält. +- [Imagewoof](../../datasets/classify/imagewoof.md): Ein herausfordernderer Teildatensatz von ImageNet mit 10 Hundezuchtkategorien für Bildklassifizierungsaufgaben. +- [MNIST](../../datasets/classify/mnist.md): Ein Datensatz mit 70.000 Graustufenbildern von handgeschriebenen Ziffern für Bildklassifizierungsaufgaben. + +## [Orientierte Bounding Boxes (OBB)](../../datasets/obb/index.md) + +Orientierte Bounding Boxes (OBB) ist eine Methode in der Computervision für die Erkennung von geneigten Objekten in Bildern mithilfe von rotierten Bounding Boxen, die oft auf Luft- und Satellitenbilder angewendet wird. + +- [DOTAv2](../../datasets/obb/dota-v2.md): Ein beliebter OBB-Datensatz für Luftbildaufnahmen mit 1,7 Millionen Instanzen und 11.268 Bildern. + +## [Multi-Objekt-Verfolgung](../../datasets/track/index.md) + +Die Verfolgung mehrerer Objekte ist eine Computervisionstechnik, die das Erkennen und Verfolgen mehrerer Objekte über die Zeit in einer Videosequenz beinhaltet. + +- [Argoverse](../../datasets/detect/argoverse.md): Ein Datensatz mit 3D-Tracking- und Bewegungsvorhersagedaten aus städtischen Umgebungen mit umfassenden Annotationen für Multi-Objekt-Verfolgungsaufgaben. +- [VisDrone](../../datasets/detect/visdrone.md): Ein Datensatz mit Daten zur Objekterkennung und Multi-Objekt-Verfolgung aus Drohnenaufnahmen mit über 10.000 Bildern und Videosequenzen. + +## Neue Datensätze beitragen + +Das Bereitstellen eines neuen Datensatzes umfasst mehrere Schritte, um sicherzustellen, dass er gut in die bestehende Infrastruktur integriert werden kann. Unten finden Sie die notwendigen Schritte: + +### Schritte um einen neuen Datensatz beizutragen + +1. **Bilder sammeln**: Sammeln Sie die Bilder, die zum Datensatz gehören. Diese können von verschiedenen Quellen gesammelt werden, wie öffentlichen Datenbanken oder Ihrer eigenen Sammlung. + +2. **Bilder annotieren**: Annotieren Sie diese Bilder mit Bounding Boxen, Segmenten oder Schlüsselpunkten, je nach Aufgabe. + +3. **Annotationen exportieren**: Konvertieren Sie diese Annotationen in das von Ultralytics unterstützte YOLO *.txt-Dateiformat. + +4. **Datensatz organisieren**: Ordnen Sie Ihren Datensatz in die richtige Ordnerstruktur an. Sie sollten übergeordnete Verzeichnisse `train/` und `val/` haben, und innerhalb dieser je ein Unterverzeichnis `images/` und `labels/`. + + ``` + dataset/ + ├── train/ + │ ├── images/ + │ └── labels/ + └── val/ + ├── images/ + └── labels/ + ``` + +5. **Eine `data.yaml`-Datei erstellen**: Erstellen Sie in Ihrem Stammverzeichnis des Datensatzes eine Datei `data.yaml`, die den Datensatz, die Klassen und andere notwendige Informationen beschreibt. + +6. **Bilder optimieren (Optional)**: Wenn Sie die Größe des Datensatzes für eine effizientere Verarbeitung reduzieren möchten, können Sie die Bilder mit dem untenstehenden Code optimieren. Dies ist nicht erforderlich, wird aber für kleinere Datensatzgrößen und schnellere Download-Geschwindigkeiten empfohlen. + +7. **Datensatz zippen**: Komprimieren Sie das gesamte Datensatzverzeichnis in eine Zip-Datei. + +8. **Dokumentation und PR**: Erstellen Sie eine Dokumentationsseite, die Ihren Datensatz beschreibt und wie er in das bestehende Framework passt. Danach reichen Sie einen Pull Request (PR) ein. Weitere Details zur Einreichung eines PR finden Sie in den [Ultralytics Beitragshinweisen](https://docs.ultralytics.com/help/contributing). + +### Beispielcode zum Optimieren und Zippen eines Datensatzes + +!!! example "Optimieren und Zippen eines Datensatzes" + + === "Python" + + ```python + from pathlib import Path + from ultralytics.data.utils import compress_one_image + from ultralytics.utils.downloads import zip_directory + + # Definieren des Verzeichnisses des Datensatzes + path = Path('Pfad/zum/Datensatz') + + # Bilder im Datensatz optimieren (optional) + for f in path.rglob('*.jpg'): + compress_one_image(f) + + # Datensatz in 'Pfad/zum/Datensatz.zip' zippen + zip_directory(path) + ``` + +Indem Sie diesen Schritten folgen, können Sie einen neuen Datensatz beitragen, der gut in die bestehende Struktur von Ultralytics integriert wird. diff --git a/docs/de/index.md b/docs/de/index.md new file mode 100644 index 00000000..cf298d26 --- /dev/null +++ b/docs/de/index.md @@ -0,0 +1,82 @@ +--- +comments: true +description: Entdecken Sie einen vollständigen Leitfaden zu Ultralytics YOLOv8, einem schnellen und präzisen Modell zur Objekterkennung und Bildsegmentierung. Installations-, Vorhersage-, Trainingstutorials und mehr. +keywords: Ultralytics, YOLOv8, Objekterkennung, Bildsegmentierung, maschinelles Lernen, Deep Learning, Computer Vision, YOLOv8 Installation, YOLOv8 Vorhersage, YOLOv8 Training, YOLO-Geschichte, YOLO-Lizenzen +--- + +
+

+ + Ultralytics YOLO Banner +

+ Ultralytics GitHub + + Ultralytics LinkedIn + + Ultralytics Twitter + + Ultralytics YouTube + + Ultralytics TikTok + + Ultralytics Instagram + + Ultralytics Discord +
+
+ Ultralytics CI + Ultralytics Code Coverage + YOLOv8 Zitation + Docker Ziehungen +
+ Auf Gradient ausführen + In Colab öffnen + In Kaggle öffnen +
+ +Wir stellen [Ultralytics](https://ultralytics.com) [YOLOv8](https://github.com/ultralytics/ultralytics) vor, die neueste Version des renommierten Echtzeit-Modells zur Objekterkennung und Bildsegmentierung. YOLOv8 basiert auf den neuesten Erkenntnissen im Bereich Deep Learning und Computer Vision und bietet eine unvergleichliche Leistung hinsichtlich Geschwindigkeit und Genauigkeit. Sein optimiertes Design macht es für verschiedene Anwendungen geeignet und leicht an verschiedene Hardwareplattformen anpassbar, von Edge-Geräten bis hin zu Cloud-APIs. + +Erkunden Sie die YOLOv8-Dokumentation, eine umfassende Ressource, die Ihnen helfen soll, seine Funktionen und Fähigkeiten zu verstehen und zu nutzen. Ob Sie ein erfahrener Machine-Learning-Praktiker sind oder neu in diesem Bereich, dieses Hub zielt darauf ab, das Potenzial von YOLOv8 in Ihren Projekten zu maximieren + +!!! note + + 🚧 Unsere mehrsprachige Dokumentation wird derzeit entwickelt und wir arbeiten intensiv an ihrer Verbesserung. Wir danken für Ihre Geduld! 🙏 + +## Wo Sie beginnen sollten + +- **Installieren** Sie `ultralytics` mit pip und starten Sie in wenigen Minuten   [:material-clock-fast: Loslegen](quickstart.md){ .md-button } +- **Vorhersagen** Sie neue Bilder und Videos mit YOLOv8   [:octicons-image-16: Auf Bilder vorhersagen](modes/predict.md){ .md-button } +- **Trainieren** Sie ein neues YOLOv8-Modell mit Ihrem eigenen benutzerdefinierten Datensatz   [:fontawesome-solid-brain: Ein Modell trainieren](modes/train.md){ .md-button } +- **Erforschen** Sie YOLOv8-Aufgaben wie Segmentieren, Klassifizieren, Posenschätzung und Verfolgen   [:material-magnify-expand: Aufgaben erkunden](tasks/index.md){ .md-button } + +

+
+ +
+ Ansehen: Wie Sie ein YOLOv8-Modell auf Ihrem eigenen Datensatz in Google Colab trainieren. +

+ +## YOLO: Eine kurze Geschichte + +[YOLO](https://arxiv.org/abs/1506.02640) (You Only Look Once), ein beliebtes Modell zur Objekterkennung und Bildsegmentierung, wurde von Joseph Redmon und Ali Farhadi an der Universität von Washington entwickelt. Seit seiner Einführung im Jahr 2015 erfreut es sich aufgrund seiner hohen Geschwindigkeit und Genauigkeit großer Beliebtheit. + +- [YOLOv2](https://arxiv.org/abs/1612.08242), veröffentlicht im Jahr 2016, verbesserte das Originalmodell durch die Einführung von Batch-Normalisierung, Ankerkästen und Dimensionsclustern. +- [YOLOv3](https://pjreddie.com/media/files/papers/YOLOv3.pdf), eingeführt im Jahr 2018, erhöhte die Leistung des Modells weiter mit einem effizienteren Backbone-Netzwerk, mehreren Ankern und räumlichem Pyramid-Pooling. +- [YOLOv4](https://arxiv.org/abs/2004.10934) wurde 2020 veröffentlicht und brachte Neuerungen wie Mosaic-Datenerweiterung, einen neuen ankerfreien Erkennungskopf und eine neue Verlustfunktion. +- [YOLOv5](https://github.com/ultralytics/yolov5) verbesserte die Leistung des Modells weiter und führte neue Funktionen ein, wie Hyperparameter-Optimierung, integriertes Experiment-Tracking und automatischen Export in beliebte Exportformate. +- [YOLOv6](https://github.com/meituan/YOLOv6) wurde 2022 von [Meituan](https://about.meituan.com/) als Open Source zur Verfügung gestellt und wird in vielen autonomen Lieferrobotern des Unternehmens eingesetzt. +- [YOLOv7](https://github.com/WongKinYiu/yolov7) führte zusätzliche Aufgaben ein, wie Posenschätzung auf dem COCO-Keypoints-Datensatz. +- [YOLOv8](https://github.com/ultralytics/ultralytics) ist die neueste Version von YOLO von Ultralytics. Als Spitzenmodell der neuesten Generation baut YOLOv8 auf dem Erfolg vorheriger Versionen auf und führt neue Funktionen und Verbesserungen für erhöhte Leistung, Flexibilität und Effizienz ein. YOLOv8 unterstützt eine vollständige Palette an Vision-KI-Aufgaben, einschließlich [Erkennung](tasks/detect.md), [Segmentierung](tasks/segment.md), [Posenschätzung](tasks/pose.md), [Verfolgung](modes/track.md) und [Klassifizierung](tasks/classify.md). Diese Vielseitigkeit ermöglicht es Benutzern, die Fähigkeiten von YOLOv8 in verschiedenen Anwendungen und Domänen zu nutzen. + +## YOLO-Lizenzen: Wie wird Ultralytics YOLO lizenziert? + +Ultralytics bietet zwei Lizenzoptionen, um unterschiedliche Einsatzszenarien zu berücksichtigen: + +- **AGPL-3.0-Lizenz**: Diese [OSI-geprüfte](https://opensource.org/licenses/) Open-Source-Lizenz ist ideal für Studenten und Enthusiasten und fördert offene Zusammenarbeit und Wissensaustausch. Weitere Details finden Sie in der [LIZENZ](https://github.com/ultralytics/ultralytics/blob/main/LICENSE)-Datei. +- **Enterprise-Lizenz**: Für die kommerzielle Nutzung konzipiert, ermöglicht diese Lizenz die problemlose Integration von Ultralytics-Software und KI-Modellen in kommerzielle Produkte und Dienstleistungen und umgeht die Open-Source-Anforderungen der AGPL-3.0. Wenn Ihr Szenario die Einbettung unserer Lösungen in ein kommerzielles Angebot beinhaltet, kontaktieren Sie uns über [Ultralytics-Lizenzierung](https://ultralytics.com/license). + +Unsere Lizenzstrategie ist darauf ausgerichtet sicherzustellen, dass jegliche Verbesserungen an unseren Open-Source-Projekten der Gemeinschaft zurückgegeben werden. Wir halten die Prinzipien von Open Source in Ehren ❤️ und es ist unser Anliegen, dass unsere Beiträge auf Weisen genutzt und erweitert werden können, die für alle vorteilhaft sind. diff --git a/docs/de/models/index.md b/docs/de/models/index.md new file mode 100644 index 00000000..4fd44ef3 --- /dev/null +++ b/docs/de/models/index.md @@ -0,0 +1,94 @@ +--- +comments: true +description: Entdecken Sie die Vielfalt der von Ultralytics unterstützten Modelle der YOLO-Familie, SAM, MobileSAM, FastSAM, YOLO-NAS und RT-DETR Modelle. Beginnen Sie mit Beispielen für die Verwendung in CLI und Python. +keywords: Ultralytics, Dokumentation, YOLO, SAM, MobileSAM, FastSAM, YOLO-NAS, RT-DETR, Modelle, Architekturen, Python, CLI +--- + +# Von Ultralytics unterstützte Modelle + +Willkommen in der Modell-Dokumentation von Ultralytics! Wir bieten Unterstützung für eine breite Palette von Modellen, die für spezifische Aufgaben wie [Objekterkennung](../tasks/detect.md), [Instanzsegmentierung](../tasks/segment.md), [Bildklassifizierung](../tasks/classify.md), [Poseerkennung](../tasks/pose.md) und [Multi-Objekt-Tracking](../modes/track.md) zugeschnitten sind. Wenn Sie daran interessiert sind, Ihre Modellarchitektur an Ultralytics beizutragen, werfen Sie einen Blick auf unseren [Beitragenden-Leitfaden](../../help/contributing.md). + +!!! Hinweis + + 🚧 Unsere mehrsprachige Dokumentation befindet sich derzeit im Aufbau, und wir arbeiten hart daran, sie zu verbessern. Vielen Dank für Ihre Geduld! 🙏 + +## Vorgestellte Modelle + +Hier sind einige der wesentlichen unterstützten Modelle: + +1. **[YOLOv3](../../models/yolov3.md)**: Die dritte Iteration der YOLO-Modellfamilie, ursprünglich von Joseph Redmon entwickelt und bekannt für ihre effiziente Echtzeit-Objekterkennung. +2. **[YOLOv4](../../models/yolov4.md)**: Eine darknet-native Aktualisierung von YOLOv3, die 2020 von Alexey Bochkovskiy veröffentlicht wurde. +3. **[YOLOv5](../../models/yolov5.md)**: Eine verbesserte Version der YOLO-Architektur von Ultralytics, die im Vergleich zu früheren Versionen bessere Leistungs- und Geschwindigkeitstrade-offs bietet. +4. **[YOLOv6](../../models/yolov6.md)**: Im Jahr 2022 von [Meituan](https://about.meituan.com/) veröffentlicht und in vielen autonomen Zustellrobotern des Unternehmens verwendet. +5. **[YOLOv7](../../models/yolov7.md)**: Im Jahr 2022 von den Autoren von YOLOv4 aktualisierte YOLO-Modelle. +6. **[YOLOv8](../../models/yolov8.md)**: Die neueste Version der YOLO-Familie mit erweiterten Fähigkeiten wie Instanzsegmentierung, Pose-/Schlüsselpunktschätzung und Klassifizierung. +7. **[Segment Anything Model (SAM)](../../models/sam.md)**: Metas Segment Anything Model (SAM). +8. **[Mobile Segment Anything Model (MobileSAM)](../../models/mobile-sam.md)**: MobileSAM für mobile Anwendungen von der Kyung Hee Universität. +9. **[Fast Segment Anything Model (FastSAM)](../../models/fast-sam.md)**: FastSAM von der Bild- und Videoanalysegruppe des Instituts für Automatisierung, Chinesische Akademie der Wissenschaften. +10. **[YOLO-NAS](../../models/yolo-nas.md)**: YOLO Neural Architecture Search (NAS) Modelle. +11. **[Realtime Detection Transformers (RT-DETR)](../../models/rtdetr.md)**: Baidus PaddlePaddle Realtime Detection Transformer (RT-DETR) Modelle. + +

+
+ +
+ Sehen Sie: Ultralytics YOLO-Modelle in nur wenigen Zeilen Code ausführen. +

+ +## Erste Schritte: Anwendungsbeispiele + +!!! Beispiel "" + + === "Python" + + PyTorch vortrainierte `*.pt` Modelle sowie Konfigurations-`*.yaml` Dateien können den Klassen `YOLO()`, `SAM()`, `NAS()` und `RTDETR()` übergeben werden, um in Python eine Modellinstanz zu erstellen: + + ```python + from ultralytics import YOLO + + # Laden eines auf COCO vortrainierten YOLOv8n-Modells + model = YOLO('yolov8n.pt') + + # Modellinformationen anzeigen (optional) + model.info() + + # Das Modell mit dem COCO8-Beispieldatensatz für 100 Epochen trainieren + results = model.train(data='coco8.yaml', epochs=100, imgsz=640) + + # Inferenz mit dem YOLOv8n-Modell am Bild 'bus.jpg' durchführen + results = model('path/to/bus.jpg') + ``` + + === "CLI" + + CLI-Befehle sind verfügbar, um die Modelle direkt auszuführen: + + ```bash + # Laden eines auf COCO vortrainierten YOLOv8n-Modells und Trainieren auf dem COCO8-Beispieldatensatz für 100 Epochen + yolo train model=yolov8n.pt data=coco8.yaml epochs=100 imgsz=640 + + # Laden eines auf COCO vortrainierten YOLOv8n-Modells und Durchführung der Inferenz am Bild 'bus.jpg' + yolo predict model=yolov8n.pt source=path/to/bus.jpg + ``` + +## Neue Modelle beitragen + +Interessiert, Ihr Modell bei Ultralytics beizutragen? Großartig! Wir sind immer offen, unser Modellportfolio zu erweitern. + +1. **Das Repository forken**: Beginnen Sie damit, das [GitHub-Repository von Ultralytics](https://github.com/ultralytics/ultralytics) zu forken. + +2. **Ihren Fork klonen**: Klonen Sie Ihren Fork auf Ihre lokale Maschine und erstellen Sie einen neuen Branch, um daran zu arbeiten. + +3. **Ihr Modell implementieren**: Fügen Sie Ihr Modell gemäß den in unserem [Beitragenden-Leitfaden](../../help/contributing.md) bereitgestellten Codierstandards und Richtlinien hinzu. + +4. **Gründlich testen**: Stellen Sie sicher, dass Sie Ihr Modell sowohl isoliert als auch als Teil der Pipeline rigoros testen. + +5. **Einen Pull Request erstellen**: Wenn Sie mit Ihrem Modell zufrieden sind, erstellen Sie einen Pull Request zum Hauptrepository zur Überprüfung. + +6. **Code-Überprüfung und Merging**: Nach der Überprüfung wird Ihr Modell, wenn es unseren Kriterien entspricht, in das Hauptrepository übernommen. + +Für detaillierte Schritte konsultieren Sie unseren [Beitragenden-Leitfaden](../../help/contributing.md). diff --git a/docs/de/modes/benchmark.md b/docs/de/modes/benchmark.md new file mode 100644 index 00000000..00e4a381 --- /dev/null +++ b/docs/de/modes/benchmark.md @@ -0,0 +1,94 @@ +--- +comments: true +description: Lernen Sie, wie Sie die Geschwindigkeit und Genauigkeit von YOLOv8 über verschiedene Exportformate hinweg profilieren können; erhalten Sie Einblicke in mAP50-95, Genauigkeit_top5 Kennzahlen und mehr. +keywords: Ultralytics, YOLOv8, Benchmarking, Geschwindigkeitsprofilierung, Genauigkeitsprofilierung, mAP50-95, accuracy_top5, ONNX, OpenVINO, TensorRT, YOLO-Exportformate +--- + +# Modell-Benchmarking mit Ultralytics YOLO + +Ultralytics YOLO-Ökosystem und Integrationen + +## Einführung + +Nachdem Ihr Modell trainiert und validiert wurde, ist der nächste logische Schritt, seine Leistung in verschiedenen realen Szenarien zu bewerten. Der Benchmark-Modus in Ultralytics YOLOv8 dient diesem Zweck, indem er einen robusten Rahmen für die Beurteilung von Geschwindigkeit und Genauigkeit Ihres Modells über eine Reihe von Exportformaten hinweg bietet. + +## Warum ist Benchmarking entscheidend? + +- **Informierte Entscheidungen:** Erhalten Sie Einblicke in die Kompromisse zwischen Geschwindigkeit und Genauigkeit. +- **Ressourcenzuweisung:** Verstehen Sie, wie sich verschiedene Exportformate auf unterschiedlicher Hardware verhalten. +- **Optimierung:** Erfahren Sie, welches Exportformat die beste Leistung für Ihren spezifischen Anwendungsfall bietet. +- **Kosteneffizienz:** Nutzen Sie Hardware-Ressourcen basierend auf den Benchmark-Ergebnissen effizienter. + +### Schlüsselmetriken im Benchmark-Modus + +- **mAP50-95:** Für Objekterkennung, Segmentierung und Posenschätzung. +- **accuracy_top5:** Für die Bildklassifizierung. +- **Inferenzzeit:** Zeit, die für jedes Bild in Millisekunden benötigt wird. + +### Unterstützte Exportformate + +- **ONNX:** Für optimale CPU-Leistung +- **TensorRT:** Für maximale GPU-Effizienz +- **OpenVINO:** Für die Optimierung von Intel-Hardware +- **CoreML, TensorFlow SavedModel, und mehr:** Für vielfältige Deployment-Anforderungen. + +!!! tip "Tipp" + + * Exportieren Sie in ONNX oder OpenVINO für bis zu 3x CPU-Beschleunigung. + * Exportieren Sie in TensorRT für bis zu 5x GPU-Beschleunigung. + +## Anwendungsbeispiele + +Führen Sie YOLOv8n-Benchmarks auf allen unterstützten Exportformaten einschließlich ONNX, TensorRT usw. durch. Siehe den Abschnitt Argumente unten für eine vollständige Liste der Exportargumente. + +!!! example "" + + === "Python" + + ```python + from ultralytics.utils.benchmarks import benchmark + + # Benchmark auf GPU + benchmark(model='yolov8n.pt', data='coco8.yaml', imgsz=640, half=False, device=0) + ``` + === "CLI" + + ```bash + yolo benchmark model=yolov8n.pt data='coco8.yaml' imgsz=640 half=False device=0 + ``` + +## Argumente + +Argumente wie `model`, `data`, `imgsz`, `half`, `device` und `verbose` bieten Benutzern die Flexibilität, die Benchmarks auf ihre spezifischen Bedürfnisse abzustimmen und die Leistung verschiedener Exportformate mühelos zu vergleichen. + +| Schlüssel | Wert | Beschreibung | +|-----------|---------|--------------------------------------------------------------------------------------| +| `model` | `None` | Pfad zur Modelldatei, z. B. yolov8n.pt, yolov8n.yaml | +| `data` | `None` | Pfad zur YAML, die das Benchmarking-Dataset referenziert (unter `val`-Kennzeichnung) | +| `imgsz` | `640` | Bildgröße als Skalar oder Liste (h, w), z. B. (640, 480) | +| `half` | `False` | FP16-Quantisierung | +| `int8` | `False` | INT8-Quantisierung | +| `device` | `None` | Gerät zum Ausführen, z. B. CUDA device=0 oder device=0,1,2,3 oder device=cpu | +| `verbose` | `False` | bei Fehlern nicht fortsetzen (bool), oder Wertebereichsschwelle (float) | + +## Exportformate + +Benchmarks werden automatisch auf allen möglichen Exportformaten unten ausgeführt. + +| Format | `format`-Argument | Modell | Metadaten | Argumente | +|--------------------------------------------------------------------|-------------------|---------------------------|-----------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | ✅ | `imgsz`, `half` | + +Vollständige Details zum `export` finden Sie auf der [Export](https://docs.ultralytics.com/modes/export/)-Seite. diff --git a/docs/de/modes/export.md b/docs/de/modes/export.md new file mode 100644 index 00000000..ea9753da --- /dev/null +++ b/docs/de/modes/export.md @@ -0,0 +1,108 @@ +--- +comments: true +description: Schritt-für-Schritt-Anleitung zum Exportieren Ihrer YOLOv8-Modelle in verschiedene Formate wie ONNX, TensorRT, CoreML und mehr für den Einsatz. +keywords: YOLO, YOLOv8, Ultralytics, Modell-Export, ONNX, TensorRT, CoreML, TensorFlow SavedModel, OpenVINO, PyTorch, Modell exportieren +--- + +# Modell-Export mit Ultralytics YOLO + +Ultralytics YOLO Ökosystem und Integrationen + +## Einführung + +Das ultimative Ziel des Trainierens eines Modells besteht darin, es für reale Anwendungen einzusetzen. Der Exportmodus in Ultralytics YOLOv8 bietet eine vielseitige Palette von Optionen für den Export Ihres trainierten Modells in verschiedene Formate, sodass es auf verschiedenen Plattformen und Geräten eingesetzt werden kann. Dieser umfassende Leitfaden soll Sie durch die Nuancen des Modell-Exports führen und zeigen, wie Sie maximale Kompatibilität und Leistung erzielen können. + +

+
+ +
+ Ansehen: Wie man ein benutzerdefiniertes trainiertes Ultralytics YOLOv8-Modell exportiert und Live-Inferenz auf der Webcam ausführt. +

+ +## Warum den Exportmodus von YOLOv8 wählen? + +- **Vielseitigkeit:** Export in verschiedene Formate einschließlich ONNX, TensorRT, CoreML und mehr. +- **Leistung:** Bis zu 5-fache GPU-Beschleunigung mit TensorRT und 3-fache CPU-Beschleunigung mit ONNX oder OpenVINO. +- **Kompatibilität:** Machen Sie Ihr Modell universell einsetzbar in zahlreichen Hardware- und Softwareumgebungen. +- **Benutzerfreundlichkeit:** Einfache CLI- und Python-API für schnellen und unkomplizierten Modell-Export. + +### Schlüsselfunktionen des Exportmodus + +Hier sind einige der herausragenden Funktionen: + +- **Ein-Klick-Export:** Einfache Befehle für den Export in verschiedene Formate. +- **Batch-Export:** Export von Modellen, die Batch-Inferenz unterstützen. +- **Optimiertes Inferenzverhalten:** Exportierte Modelle sind für schnellere Inferenzzeiten optimiert. +- **Tutorial-Videos:** Ausführliche Anleitungen und Tutorials für ein reibungsloses Exporterlebnis. + +!!! tip "Tipp" + + * Exportieren Sie nach ONNX oder OpenVINO für bis zu 3-fache CPU-Beschleunigung. + * Exportieren Sie nach TensorRT für bis zu 5-fache GPU-Beschleunigung. + +## Nutzungsbeispiele + +Exportieren Sie ein YOLOv8n-Modell in ein anderes Format wie ONNX oder TensorRT. Weitere Informationen zu den Exportargumenten finden Sie im Abschnitt „Argumente“ unten. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Laden eines Modells + model = YOLO('yolov8n.pt') # offizielles Modell laden + model = YOLO('path/to/best.pt') # benutzerdefiniertes trainiertes Modell laden + + # Exportieren des Modells + model.export(format='onnx') + ``` + === "CLI" + + ```bash + yolo export model=yolov8n.pt format=onnx # offizielles Modell exportieren + yolo export model=path/to/best.pt format=onnx # benutzerdefiniertes trainiertes Modell exportieren + ``` + +## Argumente + +Exporteinstellungen für YOLO-Modelle beziehen sich auf verschiedene Konfigurationen und Optionen, die verwendet werden, um das Modell zu speichern oder für den Einsatz in anderen Umgebungen oder Plattformen zu exportieren. Diese Einstellungen können die Leistung, Größe und Kompatibilität des Modells mit verschiedenen Systemen beeinflussen. Zu den gängigen Exporteinstellungen von YOLO gehören das Format der exportierten Modelldatei (z. B. ONNX, TensorFlow SavedModel), das Gerät, auf dem das Modell ausgeführt wird (z. B. CPU, GPU) und das Vorhandensein zusätzlicher Funktionen wie Masken oder mehrere Labels pro Box. Andere Faktoren, die den Exportprozess beeinflussen können, sind die spezifische Aufgabe, für die das Modell verwendet wird, und die Anforderungen oder Einschränkungen der Zielumgebung oder -plattform. Es ist wichtig, diese Einstellungen sorgfältig zu berücksichtigen und zu konfigurieren, um sicherzustellen, dass das exportierte Modell für den beabsichtigten Einsatzzweck optimiert ist und in der Zielumgebung effektiv eingesetzt werden kann. + +| Schlüssel | Wert | Beschreibung | +|-------------|-----------------|----------------------------------------------------------| +| `format` | `'torchscript'` | Format für den Export | +| `imgsz` | `640` | Bildgröße als Skalar oder (h, w)-Liste, z.B. (640, 480) | +| `keras` | `False` | Verwendung von Keras für TensorFlow SavedModel-Export | +| `optimize` | `False` | TorchScript: Optimierung für mobile Geräte | +| `half` | `False` | FP16-Quantisierung | +| `int8` | `False` | INT8-Quantisierung | +| `dynamic` | `False` | ONNX/TensorRT: dynamische Achsen | +| `simplify` | `False` | ONNX/TensorRT: Vereinfachung des Modells | +| `opset` | `None` | ONNX: Opset-Version (optional, Standardwert ist neueste) | +| `workspace` | `4` | TensorRT: Arbeitsbereichgröße (GB) | +| `nms` | `False` | CoreML: Hinzufügen von NMS | + +## Exportformate + +Verfügbare YOLOv8-Exportformate finden Sie in der Tabelle unten. Sie können in jedes Format exportieren, indem Sie das `format`-Argument verwenden, z. B. `format='onnx'` oder `format='engine'`. + +| Format | `format`-Argument | Modell | Metadaten | Argumente | +|--------------------------------------------------------------------|-------------------|---------------------------|-----------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | ✅ | `imgsz`, `half` | diff --git a/docs/de/modes/index.md b/docs/de/modes/index.md new file mode 100644 index 00000000..6b3decea --- /dev/null +++ b/docs/de/modes/index.md @@ -0,0 +1,74 @@ +--- +comments: true +description: Vom Training bis zum Tracking - Nutzen Sie YOLOv8 von Ultralytics optimal. Erhalten Sie Einblicke und Beispiele für jeden unterstützten Modus, einschließlich Validierung, Export und Benchmarking. +keywords: Ultralytics, YOLOv8, Maschinelles Lernen, Objekterkennung, Training, Validierung, Vorhersage, Export, Tracking, Benchmarking +--- + +# Ultralytics YOLOv8 Modi + +Ultralytics YOLO-Ökosystem und Integrationen + +## Einführung + +Ultralytics YOLOv8 ist nicht nur ein weiteres Objekterkennungsmodell; es ist ein vielseitiges Framework, das den gesamten Lebenszyklus von Machine-Learning-Modellen abdeckt - von der Dateneingabe und dem Modelltraining über die Validierung und Bereitstellung bis hin zum Tracking in der realen Welt. Jeder Modus dient einem bestimmten Zweck und ist darauf ausgelegt, Ihnen die Flexibilität und Effizienz zu bieten, die für verschiedene Aufgaben und Anwendungsfälle erforderlich ist. + +

+
+ +
+ Anschauen: Ultralytics Modi Tutorial: Trainieren, Validieren, Vorhersagen, Exportieren & Benchmarking. +

+ +### Modi im Überblick + +Das Verständnis der verschiedenen **Modi**, die Ultralytics YOLOv8 unterstützt, ist entscheidend, um das Beste aus Ihren Modellen herauszuholen: + +- **Train**-Modus: Verfeinern Sie Ihr Modell mit angepassten oder vorgeladenen Datensätzen. +- **Val**-Modus: Eine Nachtrainingsprüfung zur Validierung der Modellleistung. +- **Predict**-Modus: Entfesseln Sie die Vorhersagekraft Ihres Modells mit realen Daten. +- **Export**-Modus: Machen Sie Ihr Modell in verschiedenen Formaten einsatzbereit. +- **Track**-Modus: Erweitern Sie Ihr Objekterkennungsmodell um Echtzeit-Tracking-Anwendungen. +- **Benchmark**-Modus: Analysieren Sie die Geschwindigkeit und Genauigkeit Ihres Modells in verschiedenen Einsatzumgebungen. + +Dieser umfassende Leitfaden soll Ihnen einen Überblick und praktische Einblicke in jeden Modus geben, um Ihnen zu helfen, das volle Potenzial von YOLOv8 zu nutzen. + +## [Trainieren](train.md) + +Der Trainingsmodus wird verwendet, um ein YOLOv8-Modell mit einem angepassten Datensatz zu trainieren. In diesem Modus wird das Modell mit dem angegebenen Datensatz und den Hyperparametern trainiert. Der Trainingsprozess beinhaltet die Optimierung der Modellparameter, damit es die Klassen und Standorte von Objekten in einem Bild genau vorhersagen kann. + +[Trainingsbeispiele](train.md){ .md-button .md-button--primary} + +## [Validieren](val.md) + +Der Validierungsmodus wird genutzt, um ein YOLOv8-Modell nach dem Training zu bewerten. In diesem Modus wird das Modell auf einem Validierungsset getestet, um seine Genauigkeit und Generalisierungsleistung zu messen. Dieser Modus kann verwendet werden, um die Hyperparameter des Modells für eine bessere Leistung zu optimieren. + +[Validierungsbeispiele](val.md){ .md-button .md-button--primary} + +## [Vorhersagen](predict.md) + +Der Vorhersagemodus wird verwendet, um mit einem trainierten YOLOv8-Modell Vorhersagen für neue Bilder oder Videos zu treffen. In diesem Modus wird das Modell aus einer Checkpoint-Datei geladen, und der Benutzer kann Bilder oder Videos zur Inferenz bereitstellen. Das Modell sagt die Klassen und Standorte von Objekten in den Eingabebildern oder -videos voraus. + +[Vorhersagebeispiele](predict.md){ .md-button .md-button--primary} + +## [Exportieren](export.md) + +Der Exportmodus wird verwendet, um ein YOLOv8-Modell in ein Format zu exportieren, das für die Bereitstellung verwendet werden kann. In diesem Modus wird das Modell in ein Format konvertiert, das von anderen Softwareanwendungen oder Hardwaregeräten verwendet werden kann. Dieser Modus ist nützlich, wenn das Modell in Produktionsumgebungen eingesetzt wird. + +[Exportbeispiele](export.md){ .md-button .md-button--primary} + +## [Verfolgen](track.md) + +Der Trackingmodus wird zur Echtzeitverfolgung von Objekten mit einem YOLOv8-Modell verwendet. In diesem Modus wird das Modell aus einer Checkpoint-Datei geladen, und der Benutzer kann einen Live-Videostream für das Echtzeitobjekttracking bereitstellen. Dieser Modus ist nützlich für Anwendungen wie Überwachungssysteme oder selbstfahrende Autos. + +[Trackingbeispiele](track.md){ .md-button .md-button--primary} + +## [Benchmarking](benchmark.md) + +Der Benchmark-Modus wird verwendet, um die Geschwindigkeit und Genauigkeit verschiedener Exportformate für YOLOv8 zu profilieren. Die Benchmarks liefern Informationen über die Größe des exportierten Formats, seine `mAP50-95`-Metriken (für Objekterkennung, Segmentierung und Pose) +oder `accuracy_top5`-Metriken (für Klassifizierung) und die Inferenzzeit in Millisekunden pro Bild für verschiedene Exportformate wie ONNX, OpenVINO, TensorRT und andere. Diese Informationen können den Benutzern dabei helfen, das optimale Exportformat für ihren spezifischen Anwendungsfall basierend auf ihren Anforderungen an Geschwindigkeit und Genauigkeit auszuwählen. + +[Benchmarkbeispiele](benchmark.md){ .md-button .md-button--primary} diff --git a/docs/de/modes/predict.md b/docs/de/modes/predict.md new file mode 100644 index 00000000..177c8df3 --- /dev/null +++ b/docs/de/modes/predict.md @@ -0,0 +1,226 @@ +--- +comments: true +description: Erkunden Sie, wie der YOLOv8-Prognosemodus für verschiedene Aufgaben verwendet werden kann. Erfahren Sie mehr über verschiedene Inferenzquellen wie Bilder, Videos und Datenformate. +keywords: Ultralytics, YOLOv8, Vorhersagemodus, Inferenzquellen, Vorhersageaufgaben, Streaming-Modus, Bildverarbeitung, Videoverarbeitung, maschinelles Lernen, KI +--- + +# Modellvorhersage mit Ultralytics YOLO + +Ultralytics YOLO Ökosystem und Integrationen + +## Einführung + +Im Bereich des maschinellen Lernens und der Computer Vision wird der Prozess des Verstehens visueller Daten als 'Inferenz' oder 'Vorhersage' bezeichnet. Ultralytics YOLOv8 bietet eine leistungsstarke Funktion, die als **Prognosemodus** bekannt ist und für eine hochleistungsfähige, echtzeitfähige Inferenz auf einer breiten Palette von Datenquellen zugeschnitten ist. + +

+
+ +
+ Anschauen: Wie man die Ausgaben vom Ultralytics YOLOv8 Modell für individuelle Projekte extrahiert. +

+ +## Anwendungen in der realen Welt + +| Herstellung | Sport | Sicherheit | +|:---------------------------------------------------------------------------------------------------------------------------------------:|:-----------------------------------------------------------------------------------------------------------------------------------:|:---------------------------------------------------------------------------------------------------------------------------------------:| +| ![Ersatzteilerkennung für Fahrzeuge](https://github.com/RizwanMunawar/ultralytics/assets/62513924/a0f802a8-0776-44cf-8f17-93974a4a28a1) | ![Erkennung von Fußballspielern](https://github.com/RizwanMunawar/ultralytics/assets/62513924/7d320e1f-fc57-4d7f-a691-78ee579c3442) | ![Erkennung von stürzenden Personen](https://github.com/RizwanMunawar/ultralytics/assets/62513924/86437c4a-3227-4eee-90ef-9efb697bdb43) | +| Erkennung von Fahrzeugersatzteilen | Erkennung von Fußballspielern | Erkennung von stürzenden Personen | + +## Warum Ultralytics YOLO für Inferenz nutzen? + +Hier sind Gründe, warum Sie den Prognosemodus von YOLOv8 für Ihre verschiedenen Inferenzanforderungen in Betracht ziehen sollten: + +- **Vielseitigkeit:** Fähig, Inferenzen auf Bilder, Videos und sogar Live-Streams zu machen. +- **Leistung:** Entwickelt für Echtzeit-Hochgeschwindigkeitsverarbeitung ohne Genauigkeitsverlust. +- **Einfache Bedienung:** Intuitive Python- und CLI-Schnittstellen für schnelle Einsatzbereitschaft und Tests. +- **Hohe Anpassbarkeit:** Verschiedene Einstellungen und Parameter, um das Verhalten der Modellinferenz entsprechend Ihren spezifischen Anforderungen zu optimieren. + +### Schlüsselfunktionen des Prognosemodus + +Der Prognosemodus von YOLOv8 ist robust und vielseitig konzipiert und verfügt über: + +- **Kompatibilität mit mehreren Datenquellen:** Ganz gleich, ob Ihre Daten in Form von Einzelbildern, einer Bildersammlung, Videodateien oder Echtzeit-Videostreams vorliegen, der Prognosemodus deckt alles ab. +- **Streaming-Modus:** Nutzen Sie die Streaming-Funktion, um einen speichereffizienten Generator von `Results`-Objekten zu erzeugen. Aktivieren Sie dies, indem Sie `stream=True` in der Aufrufmethode des Predictors einstellen. +- **Batchverarbeitung:** Die Möglichkeit, mehrere Bilder oder Videoframes in einem einzigen Batch zu verarbeiten, wodurch die Inferenzzeit weiter verkürzt wird. +- **Integrationsfreundlich:** Dank der flexiblen API leicht in bestehende Datenpipelines und andere Softwarekomponenten zu integrieren. + +Ultralytics YOLO-Modelle geben entweder eine Python-Liste von `Results`-Objekten zurück, oder einen speichereffizienten Python-Generator von `Results`-Objekten, wenn `stream=True` beim Inferenzvorgang an das Modell übergeben wird: + +!!! Beispiel "Predict" + + === "Gibt eine Liste mit `stream=False` zurück" + ```python + from ultralytics import YOLO + + # Ein Modell laden + model = YOLO('yolov8n.pt') # vortrainiertes YOLOv8n Modell + + # Batch-Inferenz auf einer Liste von Bildern ausführen + results = model(['im1.jpg', 'im2.jpg']) # gibt eine Liste von Results-Objekten zurück + + # Ergebnisliste verarbeiten + for result in results: + boxes = result.boxes # Boxes-Objekt für Bbox-Ausgaben + masks = result.masks # Masks-Objekt für Segmentierungsmasken-Ausgaben + keypoints = result.keypoints # Keypoints-Objekt für Pose-Ausgaben + probs = result.probs # Probs-Objekt für Klassifizierungs-Ausgaben + ``` + + === "Gibt einen Generator mit `stream=True` zurück" + ```python + from ultralytics import YOLO + + # Ein Modell laden + model = YOLO('yolov8n.pt') # vortrainiertes YOLOv8n Modell + + # Batch-Inferenz auf einer Liste von Bildern ausführen + results = model(['im1.jpg', 'im2.jpg'], stream=True) # gibt einen Generator von Results-Objekten zurück + + # Generator von Ergebnissen verarbeiten + for result in results: + boxes = result.boxes # Boxes-Objekt für Bbox-Ausgaben + masks = result.masks # Masks-Objekt für Segmentierungsmasken-Ausgaben + keypoints = result.keypoints # Keypoints-Objekt für Pose-Ausgaben + probs = result.probs # Probs-Objekt für Klassifizierungs-Ausgaben + ``` + +## Inferenzquellen + +YOLOv8 kann verschiedene Arten von Eingabequellen für die Inferenz verarbeiten, wie in der folgenden Tabelle gezeigt. Die Quellen umfassen statische Bilder, Videostreams und verschiedene Datenformate. Die Tabelle gibt ebenfalls an, ob jede Quelle im Streaming-Modus mit dem Argument `stream=True` ✅ verwendet werden kann. Der Streaming-Modus ist vorteilhaft für die Verarbeitung von Videos oder Live-Streams, da er einen Generator von Ergebnissen statt das Laden aller Frames in den Speicher erzeugt. + +!!! Tipp "Tipp" + + Verwenden Sie `stream=True` für die Verarbeitung langer Videos oder großer Datensätze, um den Speicher effizient zu verwalten. Bei `stream=False` werden die Ergebnisse für alle Frames oder Datenpunkte im Speicher gehalten, was bei großen Eingaben schnell zu Speicherüberläufen führen kann. Im Gegensatz dazu verwendet `stream=True` einen Generator, der nur die Ergebnisse des aktuellen Frames oder Datenpunkts im Speicher behält, was den Speicherverbrauch erheblich reduziert und Speicherüberlaufprobleme verhindert. + +| Quelle | Argument | Typ | Hinweise | +|--------------------|--------------------------------------------|-------------------|------------------------------------------------------------------------------------------------| +| Bild | `'image.jpg'` | `str` oder `Path` | Einzelbilddatei. | +| URL | `'https://ultralytics.com/images/bus.jpg'` | `str` | URL zu einem Bild. | +| Bildschirmaufnahme | `'screen'` | `str` | Eine Bildschirmaufnahme erstellen. | +| PIL | `Image.open('im.jpg')` | `PIL.Image` | HWC-Format mit RGB-Kanälen. | +| OpenCV | `cv2.imread('im.jpg')` | `np.ndarray` | HWC-Format mit BGR-Kanälen `uint8 (0-255)`. | +| numpy | `np.zeros((640,1280,3))` | `np.ndarray` | HWC-Format mit BGR-Kanälen `uint8 (0-255)`. | +| torch | `torch.zeros(16,3,320,640)` | `torch.Tensor` | BCHW-Format mit RGB-Kanälen `float32 (0.0-1.0)`. | +| CSV | `'sources.csv'` | `str` oder `Path` | CSV-Datei mit Pfaden zu Bildern, Videos oder Verzeichnissen. | +| video ✅ | `'video.mp4'` | `str` oder `Path` | Videodatei in Formaten wie MP4, AVI, usw. | +| Verzeichnis ✅ | `'path/'` | `str` oder `Path` | Pfad zu einem Verzeichnis mit Bildern oder Videos. | +| glob ✅ | `'path/*.jpg'` | `str` | Glob-Muster, um mehrere Dateien zu finden. Verwenden Sie das `*` Zeichen als Platzhalter. | +| YouTube ✅ | `'https://youtu.be/LNwODJXcvt4'` | `str` | URL zu einem YouTube-Video. | +| stream ✅ | `'rtsp://example.com/media.mp4'` | `str` | URL für Streaming-Protokolle wie RTSP, RTMP, TCP oder eine IP-Adresse. | +| Multi-Stream ✅ | `'list.streams'` | `str` oder `Path` | `*.streams` Textdatei mit einer Stream-URL pro Zeile, z.B. 8 Streams laufen bei Batch-Größe 8. | + +Untenstehend finden Sie Codebeispiele für die Verwendung jedes Quelltyps: + +!!! Beispiel "Vorhersagequellen" + + === "Bild" + Führen Sie die Inferenz auf einer Bilddatei aus. + ```python + from ultralytics import YOLO + + # Ein vortrainiertes YOLOv8n Modell laden + model = YOLO('yolov8n.pt') + + # Pfad zur Bilddatei definieren + quell = 'Pfad/zum/Bild.jpg' + + # Inferenz auf der Quelle ausführen + ergebnisse = model(quell) # Liste von Results-Objekten + ``` + + === "Bildschirmaufnahme" + Führen Sie die Inferenz auf dem aktuellen Bildschirminhalt als Screenshot aus. + ```python + from ultralytics import YOLO + + # Ein vortrainiertes YOLOv8n Modell laden + model = YOLO('yolov8n.pt') + + # Aktuellen Screenshot als Quelle definieren + quell = 'Bildschirm' + + # Inferenz auf der Quelle ausführen + ergebnisse = model(quell) # Liste von Results-Objekten + ``` + + === "URL" + Führen Sie die Inferenz auf einem Bild oder Video aus, das über eine URL remote gehostet wird. + ```python + from ultralytics import YOLO + + # Ein vortrainiertes YOLOv8n Modell laden + model = YOLO('yolov8n.pt') + + # Remote-Bild- oder Video-URL definieren + quell = 'https://ultralytics.com/images/bus.jpg' + + # Inferenz auf der Quelle ausführen + ergebnisse = model(quell) # Liste von Results-Objekten + ``` + + === "PIL" + Führen Sie die Inferenz auf einem Bild aus, das mit der Python Imaging Library (PIL) geöffnet wurde. + ```python + from PIL import Image + from ultralytics import YOLO + + # Ein vortrainiertes YOLOv8n Modell laden + model = YOLO('yolov8n.pt') + + # Ein Bild mit PIL öffnen + quell = Image.open('Pfad/zum/Bild.jpg') + + # Inferenz auf der Quelle ausführen + ergebnisse = model(quell) # Liste von Results-Objekten + ``` + + === "OpenCV" + Führen Sie die Inferenz auf einem Bild aus, das mit OpenCV gelesen wurde. + ```python + import cv2 + from ultralytics import YOLO + + # Ein vortrainiertes YOLOv8n Modell laden + model = YOLO('yolov8n.pt') + + # Ein Bild mit OpenCV lesen + quell = cv2.imread('Pfad/zum/Bild.jpg') + + # Inferenz auf der Quelle ausführen + ergebnisse = model(quell) # Liste von Results-Objekten + ``` + + === "numpy" + Führen Sie die Inferenz auf einem Bild aus, das als numpy-Array dargestellt wird. + ```python + import numpy as np + from ultralytics import YOLO + + # Ein vortrainiertes YOLOv8n Modell laden + model = YOLO('yolov8n.pt') + + # Ein zufälliges numpy-Array der HWC-Form (640, 640, 3) mit Werten im Bereich [0, 255] und Typ uint8 erstellen + quell = np.random.randint(low=0, high=255, size=(640, 640, 3), dtype='uint8') + + # Inferenz auf der Quelle ausführen + ergebnisse = model(quell) # Liste von Results-Objekten + ``` + + === "torch" + Führen Sie die Inferenz auf einem Bild aus, das als PyTorch-Tensor dargestellt wird. + ```python + import torch + from ultralytics import YOLO + + # Ein vortrainiertes YOLOv8n Modell laden + model = YOLO('yolov8n.pt') + + # Ein zufälliger torch-Tensor der BCHW-Form (1, 3, 640, 640) mit Werten im Bereich [0, 1] und Typ float32 erstellen + quell = torch.rand(1, 3, 640, 640, dtype=torch.float32) + + # Inferenz auf der Quelle ausführen + ergebnisse = model(quell) # Liste von Results-Objekten diff --git a/docs/de/modes/track.md b/docs/de/modes/track.md new file mode 100644 index 00000000..35040b04 --- /dev/null +++ b/docs/de/modes/track.md @@ -0,0 +1,200 @@ +--- +comments: true +description: Erfahren Sie, wie Sie Ultralytics YOLO für Objektverfolgung in Videostreams verwenden. Anleitungen zum Einsatz verschiedener Tracker und zur Anpassung von Tracker-Konfigurationen. +keywords: Ultralytics, YOLO, Objektverfolgung, Videostreams, BoT-SORT, ByteTrack, Python-Anleitung, CLI-Anleitung +--- + +# Multi-Objektverfolgung mit Ultralytics YOLO + +Beispiele für Multi-Objektverfolgung + +Objektverfolgung im Bereich der Videoanalytik ist eine essentielle Aufgabe, die nicht nur den Standort und die Klasse von Objekten innerhalb des Frames identifiziert, sondern auch eine eindeutige ID für jedes erkannte Objekt, während das Video fortschreitet, erhält. Die Anwendungsmöglichkeiten sind grenzenlos – von Überwachung und Sicherheit bis hin zur Echtzeitsportanalytik. + +## Warum Ultralytics YOLO für Objektverfolgung wählen? + +Die Ausgabe von Ultralytics Trackern ist konsistent mit der standardmäßigen Objekterkennung, bietet aber zusätzlich Objekt-IDs. Dies erleichtert das Verfolgen von Objekten in Videostreams und das Durchführen nachfolgender Analysen. Hier sind einige Gründe, warum Sie Ultralytics YOLO für Ihre Objektverfolgungsaufgaben in Betracht ziehen sollten: + +- **Effizienz:** Verarbeitung von Videostreams in Echtzeit ohne Einbußen bei der Genauigkeit. +- **Flexibilität:** Unterstützt mehrere Tracking-Algorithmen und -Konfigurationen. +- **Benutzerfreundlichkeit:** Einfache Python-API und CLI-Optionen für schnelle Integration und Bereitstellung. +- **Anpassbarkeit:** Einfache Verwendung mit individuell trainierten YOLO-Modellen, ermöglicht Integration in branchenspezifische Anwendungen. + +

+
+ +
+ Ansehen: Objekterkennung und -verfolgung mit Ultralytics YOLOv8. +

+ +## Anwendungen in der realen Welt + +| Transportwesen | Einzelhandel | Aquakultur | +|:------------------------------------------------------------------------------------------------------------------------:|:------------------------------------------------------------------------------------------------------------------------:|:---------------------------------------------------------------------------------------------------------------------:| +| ![Fahrzeugverfolgung](https://github.com/RizwanMunawar/ultralytics/assets/62513924/ee6e6038-383b-4f21-ac29-b2a1c7d386ab) | ![Personenverfolgung](https://github.com/RizwanMunawar/ultralytics/assets/62513924/93bb4ee2-77a0-4e4e-8eb6-eb8f527f0527) | ![Fischverfolgung](https://github.com/RizwanMunawar/ultralytics/assets/62513924/a5146d0f-bfa8-4e0a-b7df-3c1446cd8142) | +| Fahrzeugverfolgung | Personenverfolgung | Fischverfolgung | + +## Eigenschaften auf einen Blick + +Ultralytics YOLO erweitert seine Objekterkennungsfunktionen, um eine robuste und vielseitige Objektverfolgung bereitzustellen: + +- **Echtzeitverfolgung:** Nahtloses Verfolgen von Objekten in Videos mit hoher Bildfrequenz. +- **Unterstützung mehrerer Tracker:** Auswahl aus einer Vielzahl etablierter Tracking-Algorithmen. +- **Anpassbare Tracker-Konfigurationen:** Anpassen des Tracking-Algorithmus an spezifische Anforderungen durch Einstellung verschiedener Parameter. + +## Verfügbare Tracker + +Ultralytics YOLO unterstützt die folgenden Tracking-Algorithmen. Sie können aktiviert werden, indem Sie die entsprechende YAML-Konfigurationsdatei wie `tracker=tracker_type.yaml` übergeben: + +* [BoT-SORT](https://github.com/NirAharon/BoT-SORT) - Verwenden Sie `botsort.yaml`, um diesen Tracker zu aktivieren. +* [ByteTrack](https://github.com/ifzhang/ByteTrack) - Verwenden Sie `bytetrack.yaml`, um diesen Tracker zu aktivieren. + +Der Standardtracker ist BoT-SORT. + +## Verfolgung + +Um den Tracker auf Videostreams auszuführen, verwenden Sie ein trainiertes Erkennungs-, Segmentierungs- oder Posierungsmodell wie YOLOv8n, YOLOv8n-seg und YOLOv8n-pose. + +!!! beispiel "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Laden Sie ein offizielles oder individuelles Modell + model = YOLO('yolov8n.pt') # Laden Sie ein offizielles Erkennungsmodell + model = YOLO('yolov8n-seg.pt') # Laden Sie ein offizielles Segmentierungsmodell + model = YOLO('yolov8n-pose.pt') # Laden Sie ein offizielles Posierungsmodell + model = YOLO('path/to/best.pt') # Laden Sie ein individuell trainiertes Modell + + # Führen Sie die Verfolgung mit dem Modell durch + results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True) # Verfolgung mit Standardtracker + results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml") # Verfolgung mit ByteTrack-Tracker + ``` + + === "CLI" + + ```bash + # Führen Sie die Verfolgung mit verschiedenen Modellen über die Befehlszeilenschnittstelle durch + yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" # Offizielles Erkennungsmodell + yolo track model=yolov8n-seg.pt source="https://youtu.be/LNwODJXcvt4" # Offizielles Segmentierungsmodell + yolo track model=yolov8n-pose.pt source="https://youtu.be/LNwODJXcvt4" # Offizielles Posierungsmodell + yolo track model=path/to/best.pt source="https://youtu.be/LNwODJXcvt4" # Individuell trainiertes Modell + + # Verfolgung mit ByteTrack-Tracker + yolo track model=path/to/best.pt tracker="bytetrack.yaml" + ``` + +Wie in der obigen Nutzung zu sehen ist, ist die Verfolgung für alle Detect-, Segment- und Pose-Modelle verfügbar, die auf Videos oder Streaming-Quellen ausgeführt werden. + +## Konfiguration + +### Tracking-Argumente + +Die Tracking-Konfiguration teilt Eigenschaften mit dem Predict-Modus, wie `conf`, `iou` und `show`. Für weitere Konfigurationen siehe die Seite des [Predict](https://docs.ultralytics.com/modes/predict/)-Modells. + +!!! beispiel "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Konfigurieren Sie die Tracking-Parameter und führen Sie den Tracker aus + model = YOLO('yolov8n.pt') + results = model.track(source="https://youtu.be/LNwODJXcvt4", conf=0.3, iou=0.5, show=True) + ``` + + === "CLI" + + ```bash + # Konfigurieren Sie die Tracking-Parameter und führen Sie den Tracker über die Befehlszeilenschnittstelle aus + yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" conf=0.3, iou=0.5 show + ``` + +### Tracker-Auswahl + +Ultralytics ermöglicht es Ihnen auch, eine modifizierte Tracker-Konfigurationsdatei zu verwenden. Hierfür kopieren Sie einfach eine Tracker-Konfigurationsdatei (zum Beispiel `custom_tracker.yaml`) von [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers) und ändern jede Konfiguration (außer dem `tracker_type`), wie es Ihren Bedürfnissen entspricht. + +!!! beispiel "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Laden Sie das Modell und führen Sie den Tracker mit einer individuellen Konfigurationsdatei aus + model = YOLO('yolov8n.pt') + results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker='custom_tracker.yaml') + ``` + + === "CLI" + + ```bash + # Laden Sie das Modell und führen Sie den Tracker mit einer individuellen Konfigurationsdatei über die Befehlszeilenschnittstelle aus + yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" tracker='custom_tracker.yaml' + ``` + +Für eine umfassende Liste der Tracking-Argumente siehe die Seite [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers). + +## Python-Beispiele + +### Persistierende Tracks-Schleife + +Hier ist ein Python-Skript, das OpenCV (`cv2`) und YOLOv8 verwendet, um Objektverfolgung in Videoframes durchzuführen. Dieses Skript setzt voraus, dass Sie die notwendigen Pakete (`opencv-python` und `ultralytics`) bereits installiert haben. Das Argument `persist=True` teilt dem Tracker mit, dass das aktuelle Bild oder Frame das nächste in einer Sequenz ist und Tracks aus dem vorherigen Bild im aktuellen Bild erwartet werden. + +!!! beispiel "Streaming-For-Schleife mit Tracking" + + ```python + import cv2 + from ultralytics import YOLO + + # Laden Sie das YOLOv8-Modell + model = YOLO('yolov8n.pt') + + # Öffnen Sie die Videodatei + video_path = "path/to/video.mp4" + cap = cv2.VideoCapture(video_path) + + # Schleife durch die Videoframes + while cap.isOpened(): + # Einen Frame aus dem Video lesen + success, frame = cap.read() + + if success: + # Führen Sie YOLOv8-Tracking im Frame aus, wobei Tracks zwischen Frames beibehalten werden + results = model.track(frame, persist=True) + + # Visualisieren Sie die Ergebnisse im Frame + annotated_frame = results[0].plot() + + # Zeigen Sie den kommentierten Frame an + cv2.imshow("YOLOv8-Tracking", annotated_frame) + + # Beenden Sie die Schleife, wenn 'q' gedrückt wird + if cv2.waitKey(1) & 0xFF == ord("q"): + break + else: + # Beenden Sie die Schleife, wenn das Ende des Videos erreicht ist + break + + # Geben Sie das Videoaufnahmeobjekt frei und schließen Sie das Anzeigefenster + cap.release() + cv2.destroyAllWindows() + ``` + +Bitte beachten Sie die Änderung von `model(frame)` zu `model.track(frame)`, welche die Objektverfolgung anstelle der einfachen Erkennung aktiviert. Dieses modifizierte Skript führt den Tracker auf jedem Frame des Videos aus, visualisiert die Ergebnisse und zeigt sie in einem Fenster an. Die Schleife kann durch Drücken von 'q' beendet werden. + +## Neue Tracker beisteuern + +Sind Sie versiert in der Multi-Objektverfolgung und haben erfolgreich einen Tracking-Algorithmus mit Ultralytics YOLO implementiert oder angepasst? Wir laden Sie ein, zu unserem Trackers-Bereich in [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers) beizutragen! Ihre realen Anwendungen und Lösungen könnten für Benutzer, die an Tracking-Aufgaben arbeiten, von unschätzbarem Wert sein. + +Indem Sie zu diesem Bereich beitragen, helfen Sie, das Spektrum verfügbarer Tracking-Lösungen innerhalb des Ultralytics YOLO-Frameworks zu erweitern und fügen eine weitere Funktionsschicht für die Gemeinschaft hinzu. + +Um Ihren Beitrag einzuleiten, sehen Sie bitte in unserem [Contributing Guide](https://docs.ultralytics.com/help/contributing) für umfassende Anweisungen zur Einreichung eines Pull Requests (PR) 🛠️. Wir sind gespannt darauf, was Sie beitragen! + +Gemeinsam verbessern wir die Tracking-Fähigkeiten des Ultralytics YOLO-Ökosystems 🙏! diff --git a/docs/de/modes/train.md b/docs/de/modes/train.md new file mode 100644 index 00000000..420080f6 --- /dev/null +++ b/docs/de/modes/train.md @@ -0,0 +1,206 @@ +--- +comments: true +description: Schritt-für-Schritt-Leitfaden zum Trainieren von YOLOv8-Modellen mit Ultralytics YOLO, einschließlich Beispielen für Single-GPU- und Multi-GPU-Training +keywords: Ultralytics, YOLOv8, YOLO, Objekterkennung, Trainingsmodus, benutzerdefinierter Datensatz, GPU-Training, Multi-GPU, Hyperparameter, CLI-Beispiele, Python-Beispiele +--- + +# Modelltraining mit Ultralytics YOLO + +Ultralytics YOLO Ökosystem und Integrationen + +## Einleitung + +Das Training eines Deep-Learning-Modells beinhaltet das Einspeisen von Daten und die Anpassung seiner Parameter, so dass es genaue Vorhersagen treffen kann. Der Trainingsmodus in Ultralytics YOLOv8 ist für das effektive und effiziente Training von Objekterkennungsmodellen konzipiert und nutzt dabei die Fähigkeiten moderner Hardware voll aus. Dieser Leitfaden zielt darauf ab, alle Details zu vermitteln, die Sie benötigen, um mit dem Training Ihrer eigenen Modelle unter Verwendung des robusten Funktionssatzes von YOLOv8 zu beginnen. + +

+
+ +
+ Video anschauen: Wie man ein YOLOv8-Modell auf Ihrem benutzerdefinierten Datensatz in Google Colab trainiert. +

+ +## Warum Ultralytics YOLO für das Training wählen? + +Hier einige überzeugende Gründe, sich für den Trainingsmodus von YOLOv8 zu entscheiden: + +- **Effizienz:** Machen Sie das Beste aus Ihrer Hardware, egal ob Sie auf einem Single-GPU-Setup sind oder über mehrere GPUs skalieren. +- **Vielseitigkeit:** Training auf benutzerdefinierten Datensätzen zusätzlich zu den bereits verfügbaren Datensätzen wie COCO, VOC und ImageNet. +- **Benutzerfreundlich:** Einfache, aber leistungsstarke CLI- und Python-Schnittstellen für ein unkompliziertes Trainingserlebnis. +- **Flexibilität der Hyperparameter:** Eine breite Palette von anpassbaren Hyperparametern, um die Modellleistung zu optimieren. + +### Schlüsselfunktionen des Trainingsmodus + +Die folgenden sind einige bemerkenswerte Funktionen von YOLOv8s Trainingsmodus: + +- **Automatischer Datensatz-Download:** Standarddatensätze wie COCO, VOC und ImageNet werden bei der ersten Verwendung automatisch heruntergeladen. +- **Multi-GPU-Unterstützung:** Skalieren Sie Ihr Training nahtlos über mehrere GPUs, um den Prozess zu beschleunigen. +- **Konfiguration der Hyperparameter:** Die Möglichkeit zur Modifikation der Hyperparameter über YAML-Konfigurationsdateien oder CLI-Argumente. +- **Visualisierung und Überwachung:** Echtzeit-Tracking von Trainingsmetriken und Visualisierung des Lernprozesses für bessere Einsichten. + +!!! Tipp "Tipp" + + * YOLOv8-Datensätze wie COCO, VOC, ImageNet und viele andere werden automatisch bei der ersten Verwendung heruntergeladen, d.h. `yolo train data=coco.yaml` + +## Nutzungsbeispiele + +Trainieren Sie YOLOv8n auf dem COCO128-Datensatz für 100 Epochen bei einer Bildgröße von 640. Das Trainingsgerät kann mit dem Argument `device` spezifiziert werden. Wenn kein Argument übergeben wird, wird GPU `device=0` verwendet, wenn verfügbar, sonst wird `device=cpu` verwendet. Siehe den Abschnitt Argumente unten für eine vollständige Liste der Trainingsargumente. + +!!! Beispiel "Beispiel für Single-GPU- und CPU-Training" + + Das Gerät wird automatisch ermittelt. Wenn eine GPU verfügbar ist, dann wird diese verwendet, sonst beginnt das Training auf der CPU. + + === "Python" + + ```python + from ultralytics import YOLO + + # Laden Sie ein Modell + model = YOLO('yolov8n.yaml') # bauen Sie ein neues Modell aus YAML + model = YOLO('yolov8n.pt') # laden Sie ein vortrainiertes Modell (empfohlen für das Training) + model = YOLO('yolov8n.yaml').load('yolov8n.pt') # bauen Sie aus YAML und übertragen Sie Gewichte + + # Trainieren Sie das Modell + results = model.train(data='coco128.yaml', epochs=100, imgsz=640) + ``` + + === "CLI" + + ```bash + # Bauen Sie ein neues Modell aus YAML und beginnen Sie das Training von Grund auf + yolo detect train data=coco128.yaml model=yolov8n.yaml epochs=100 imgsz=640 + + # Beginnen Sie das Training von einem vortrainierten *.pt Modell + yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 + + # Bauen Sie ein neues Modell aus YAML, übertragen Sie vortrainierte Gewichte darauf und beginnen Sie das Training + yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640 + ``` + +### Multi-GPU-Training + +Multi-GPU-Training ermöglicht eine effizientere Nutzung von verfügbaren Hardware-Ressourcen, indem die Trainingslast über mehrere GPUs verteilt wird. Diese Funktion ist über sowohl die Python-API als auch die Befehlszeilenschnittstelle verfügbar. Um das Multi-GPU-Training zu aktivieren, geben Sie die GPU-Geräte-IDs an, die Sie verwenden möchten. + +!!! Beispiel "Beispiel für Multi-GPU-Training" + + Um mit 2 GPUs zu trainieren, verwenden Sie die folgenden Befehle für CUDA-Geräte 0 und 1. Erweitern Sie dies bei Bedarf auf zusätzliche GPUs. + + === "Python" + + ```python + from ultralytics import YOLO + + # Laden Sie ein Modell + model = YOLO('yolov8n.pt') # laden Sie ein vortrainiertes Modell (empfohlen für das Training) + + # Trainieren Sie das Modell mit 2 GPUs + results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device=[0, 1]) + ``` + + === "CLI" + + ```bash + # Beginnen Sie das Training von einem vortrainierten *.pt Modell unter Verwendung der GPUs 0 und 1 + yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=0,1 + ``` + +### Apple M1- und M2-MPS-Training + +Mit der Unterstützung für Apple M1- und M2-Chips, die in den Ultralytics YOLO-Modellen integriert ist, ist es jetzt möglich, Ihre Modelle auf Geräten zu trainieren, die das leistungsstarke Metal Performance Shaders (MPS)-Framework nutzen. MPS bietet eine leistungsstarke Methode zur Ausführung von Berechnungs- und Bildverarbeitungsaufgaben auf Apples benutzerdefinierten Siliziumchips. + +Um das Training auf Apple M1- und M2-Chips zu ermöglichen, sollten Sie 'mps' als Ihr Gerät angeben, wenn Sie den Trainingsprozess starten. Unten ist ein Beispiel, wie Sie dies in Python und über die Befehlszeile tun könnten: + +!!! Beispiel "MPS-Training Beispiel" + + === "Python" + + ```python + from ultralytics import YOLO + + # Laden Sie ein Modell + model = YOLO('yolov8n.pt') # laden Sie ein vortrainiertes Modell (empfohlen für das Training) + + # Trainieren Sie das Modell mit 2 GPUs + results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device='mps') + ``` + + === "CLI" + + ```bash + # Beginnen Sie das Training von einem vortrainierten *.pt Modell unter Verwendung der GPUs 0 und 1 + yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=mps + ``` + +Indem sie die Rechenleistung der M1/M2-Chips nutzen, ermöglicht dies eine effizientere Verarbeitung der Trainingsaufgaben. Für detailliertere Anleitungen und fortgeschrittene Konfigurationsoptionen beziehen Sie sich bitte auf die [PyTorch MPS-Dokumentation](https://pytorch.org/docs/stable/notes/mps.html). + +## Protokollierung + +Beim Training eines YOLOv8-Modells kann es wertvoll sein, die Leistung des Modells im Laufe der Zeit zu verfolgen. Hier kommt die Protokollierung ins Spiel. Ultralytics' YOLO unterstützt drei Typen von Loggern - Comet, ClearML und TensorBoard. + +Um einen Logger zu verwenden, wählen Sie ihn aus dem Dropdown-Menü im obigen Codeausschnitt aus und führen ihn aus. Der ausgewählte Logger wird installiert und initialisiert. + +### Comet + +[Comet](https://www.comet.ml/site/) ist eine Plattform, die Datenwissenschaftlern und Entwicklern erlaubt, Experimente und Modelle zu verfolgen, zu vergleichen, zu erklären und zu optimieren. Es bietet Funktionen wie Echtzeitmetriken, Code-Diffs und das Verfolgen von Hyperparametern. + +Um Comet zu verwenden: + +!!! Beispiel "" + + === "Python" + ```python + # pip installieren comet_ml + import comet_ml + + comet_ml.init() + ``` + +Vergessen Sie nicht, sich auf der Comet-Website anzumelden und Ihren API-Schlüssel zu erhalten. Sie müssen diesen zu Ihren Umgebungsvariablen oder Ihrem Skript hinzufügen, um Ihre Experimente zu protokollieren. + +### ClearML + +[ClearML](https://www.clear.ml/) ist eine Open-Source-Plattform, die das Verfolgen von Experimenten automatisiert und hilft, Ressourcen effizient zu teilen. Sie ist darauf ausgelegt, Teams bei der Verwaltung, Ausführung und Reproduktion ihrer ML-Arbeiten effizienter zu unterstützen. + +Um ClearML zu verwenden: + +!!! Beispiel "" + + === "Python" + ```python + # pip installieren clearml + import clearml + + clearml.browser_login() + ``` + +Nach dem Ausführen dieses Skripts müssen Sie sich auf dem Browser bei Ihrem ClearML-Konto anmelden und Ihre Sitzung authentifizieren. + +### TensorBoard + +[TensorBoard](https://www.tensorflow.org/tensorboard) ist ein Visualisierungstoolset für TensorFlow. Es ermöglicht Ihnen, Ihren TensorFlow-Graphen zu visualisieren, quantitative Metriken über die Ausführung Ihres Graphen zu plotten und zusätzliche Daten wie Bilder zu zeigen, die durch ihn hindurchgehen. + +Um TensorBoard in [Google Colab](https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb) zu verwenden: + +!!! Beispiel "" + + === "CLI" + ```bash + load_ext tensorboard + tensorboard --logdir ultralytics/runs # ersetzen Sie mit Ihrem 'runs' Verzeichnis + ``` + +Um TensorBoard lokal auszuführen, führen Sie den folgenden Befehl aus und betrachten Sie die Ergebnisse unter http://localhost:6006/. + +!!! Beispiel "" + + === "CLI" + ```bash + tensorboard --logdir ultralytics/runs # ersetzen Sie mit Ihrem 'runs' Verzeichnis + ``` + +Dies lädt TensorBoard und weist es an, das Verzeichnis zu verwenden, in dem Ihre Trainingsprotokolle gespeichert sind. + +Nachdem Sie Ihren Logger eingerichtet haben, können Sie mit Ihrem Modelltraining fortfahren. Alle Trainingsmetriken werden automatisch in Ihrer gewählten Plattform protokolliert, und Sie können auf diese Protokolle zugreifen, um die Leistung Ihres Modells im Laufe der Zeit zu überwachen, verschiedene Modelle zu vergleichen und Bereiche für Verbesserungen zu identifizieren. diff --git a/docs/de/modes/val.md b/docs/de/modes/val.md new file mode 100644 index 00000000..9cd235d4 --- /dev/null +++ b/docs/de/modes/val.md @@ -0,0 +1,86 @@ +--- +comments: true +description: Anleitung zur Validierung von YOLOv8-Modellen. Erfahren Sie, wie Sie die Leistung Ihrer YOLO-Modelle mit Validierungseinstellungen und Metriken in Python und CLI-Beispielen bewerten können. +keywords: Ultralytics, YOLO-Dokumente, YOLOv8, Validierung, Modellbewertung, Hyperparameter, Genauigkeit, Metriken, Python, CLI +--- + +# Modellvalidierung mit Ultralytics YOLO + +Ultralytics YOLO-Ökosystem und Integrationen + +## Einführung + +Die Validierung ist ein kritischer Schritt im Machine-Learning-Prozess, der es Ihnen ermöglicht, die Qualität Ihrer trainierten Modelle zu bewerten. Der Val-Modus in Ultralytics YOLOv8 bietet eine robuste Suite von Tools und Metriken zur Bewertung der Leistung Ihrer Objekterkennungsmodelle. Dieser Leitfaden dient als umfassende Ressource, um zu verstehen, wie Sie den Val-Modus effektiv nutzen können, um sicherzustellen, dass Ihre Modelle sowohl genau als auch zuverlässig sind. + +## Warum mit Ultralytics YOLO validieren? + +Hier sind die Vorteile der Verwendung des Val-Modus von YOLOv8: + +- **Präzision:** Erhalten Sie genaue Metriken wie mAP50, mAP75 und mAP50-95, um Ihr Modell umfassend zu bewerten. +- **Bequemlichkeit:** Nutzen Sie integrierte Funktionen, die Trainingseinstellungen speichern und so den Validierungsprozess vereinfachen. +- **Flexibilität:** Validieren Sie Ihr Modell mit den gleichen oder verschiedenen Datensätzen und Bildgrößen. +- **Hyperparameter-Tuning:** Verwenden Sie Validierungsmetriken, um Ihr Modell für eine bessere Leistung zu optimieren. + +### Schlüsselfunktionen des Val-Modus + +Dies sind die bemerkenswerten Funktionen, die der Val-Modus von YOLOv8 bietet: + +- **Automatisierte Einstellungen:** Modelle erinnern sich an ihre Trainingskonfigurationen für eine unkomplizierte Validierung. +- **Unterstützung mehrerer Metriken:** Bewerten Sie Ihr Modell anhand einer Reihe von Genauigkeitsmetriken. +- **CLI- und Python-API:** Wählen Sie zwischen Befehlszeilenschnittstelle oder Python-API basierend auf Ihrer Präferenz für die Validierung. +- **Datenkompatibilität:** Funktioniert nahtlos mit Datensätzen, die während der Trainingsphase sowie mit benutzerdefinierten Datensätzen verwendet wurden. + +!!! tip "Tipp" + + * YOLOv8-Modelle speichern automatisch ihre Trainingseinstellungen, sodass Sie ein Modell mit der gleichen Bildgröße und dem ursprünglichen Datensatz leicht validieren können, indem Sie einfach `yolo val model=yolov8n.pt` oder `model('yolov8n.pt').val()` ausführen + +## Beispielverwendung + +Validieren Sie die Genauigkeit des trainierten YOLOv8n-Modells auf dem COCO128-Datensatz. Es muss kein Argument übergeben werden, da das `model` seine Trainings-`data` und Argumente als Modellattribute speichert. Siehe Abschnitt „Argumente“ unten für eine vollständige Liste der Exportargumente. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Modell laden + model = YOLO('yolov8n.pt') # ein offizielles Modell laden + model = YOLO('path/to/best.pt') # ein benutzerdefiniertes Modell laden + + # Modell validieren + metrics = model.val() # keine Argumente benötigt, Datensatz und Einstellungen gespeichert + metrics.box.map # map50-95 + metrics.box.map50 # map50 + metrics.box.map75 # map75 + metrics.box.maps # eine Liste enthält map50-95 jeder Kategorie + ``` + === "CLI" + + ```bash + yolo detect val model=yolov8n.pt # offizielles Modell validieren + yolo detect val model=path/to/best.pt # benutzerdefiniertes Modell validieren + ``` + +## Argumente + +Validierungseinstellungen für YOLO-Modelle beziehen sich auf verschiedene Hyperparameter und Konfigurationen, die verwendet werden, um die Leistung des Modells an einem Validierungsdatensatz zu bewerten. Diese Einstellungen können die Leistung, Geschwindigkeit und Genauigkeit des Modells beeinflussen. Einige gängige YOLO-Validierungseinstellungen umfassen die Batch-Größe, die Häufigkeit der Validierung während des Trainings und die Metriken zur Bewertung der Modellleistung. Andere Faktoren, die den Validierungsprozess beeinflussen können, sind die Größe und Zusammensetzung des Validierungsdatensatzes und die spezifische Aufgabe, für die das Modell verwendet wird. Es ist wichtig, diese Einstellungen sorgfältig abzustimmen und zu experimentieren, um sicherzustellen, dass das Modell auf dem Validierungsdatensatz gut funktioniert sowie Überanpassung zu erkennen und zu verhindern. + +| Key | Value | Beschreibung | +|---------------|---------|---------------------------------------------------------------------------------| +| `data` | `None` | Pfad zur Datendatei, z.B. coco128.yaml | +| `imgsz` | `640` | Größe der Eingabebilder als ganzzahlige Zahl | +| `batch` | `16` | Anzahl der Bilder pro Batch (-1 für AutoBatch) | +| `save_json` | `False` | Ergebnisse in JSON-Datei speichern | +| `save_hybrid` | `False` | hybride Version der Labels speichern (Labels + zusätzliche Vorhersagen) | +| `conf` | `0.001` | Objekterkennungsschwelle für Zuversichtlichkeit | +| `iou` | `0.6` | Schwellenwert für IoU (Intersection over Union) für NMS | +| `max_det` | `300` | maximale Anzahl an Vorhersagen pro Bild | +| `half` | `True` | Halbpräzision verwenden (FP16) | +| `device` | `None` | Gerät zur Ausführung, z.B. CUDA device=0/1/2/3 oder device=cpu | +| `dnn` | `False` | OpenCV DNN für ONNX-Inf erenz nutzen | +| `plots` | `False` | Diagramme während des Trainings anzeigen | +| `rect` | `False` | rechteckige Validierung mit jeder Batch-Charge für minimale Polsterung | +| `split` | `val` | Zu verwendende Daten-Teilmenge für Validierung, z.B. 'val', 'test' oder 'train' | +| diff --git a/docs/de/quickstart.md b/docs/de/quickstart.md new file mode 100644 index 00000000..e52e4aea --- /dev/null +++ b/docs/de/quickstart.md @@ -0,0 +1,187 @@ +--- +comments: true +description: Entdecken Sie verschiedene Methoden zur Installation von Ultralytics mit Pip, Conda, Git und Docker. Erfahren Sie, wie Sie Ultralytics über die Befehlszeilenschnittstelle oder innerhalb Ihrer Python-Projekte verwenden können. +keywords: Ultralytics-Installation, pip installieren Ultralytics, Docker installieren Ultralytics, Ultralytics-Befehlszeilenschnittstelle, Ultralytics Python-Schnittstelle +--- + +## Ultralytics installieren + +Ultralytics bietet verschiedene Installationsmethoden, darunter Pip, Conda und Docker. Installiere YOLOv8 über das `ultralytics` Pip-Paket für die neueste stabile Veröffentlichung oder indem du das [Ultralytics GitHub-Repository](https://github.com/ultralytics/ultralytics) klonst für die aktuellste Version. Docker kann verwendet werden, um das Paket in einem isolierten Container auszuführen, ohne eine lokale Installation vornehmen zu müssen. + +!!! Beispiel "Installieren" + + === "Pip-Installation (empfohlen)" + Installieren Sie das `ultralytics` Paket mit Pip oder aktualisieren Sie eine bestehende Installation, indem Sie `pip install -U ultralytics` ausführen. Besuchen Sie den Python Package Index (PyPI) für weitere Details zum `ultralytics` Paket: [https://pypi.org/project/ultralytics/](https://pypi.org/project/ultralytics/). + + [![PyPI-Version](https://badge.fury.io/py/ultralytics.svg)](https://badge.fury.io/py/ultralytics) [![Downloads](https://static.pepy.tech/badge/ultralytics)](https://pepy.tech/project/ultralytics) + + ```bash + # Installiere das ultralytics Paket von PyPI + pip install ultralytics + ``` + + Sie können auch das `ultralytics` Paket direkt vom GitHub [Repository](https://github.com/ultralytics/ultralytics) installieren. Dies könnte nützlich sein, wenn Sie die neueste Entwicklerversion möchten. Stellen Sie sicher, dass das Git-Kommandozeilen-Tool auf Ihrem System installiert ist. Der Befehl `@main` installiert den `main` Branch und kann zu einem anderen Branch geändert werden, z. B. `@my-branch`, oder ganz entfernt werden, um auf den `main` Branch standardmäßig zurückzugreifen. + + ```bash + # Installiere das ultralytics Paket von GitHub + pip install git+https://github.com/ultralytics/ultralytics.git@main + ``` + + + === "Conda-Installation" + Conda ist ein alternativer Paketmanager zu Pip, der ebenfalls für die Installation verwendet werden kann. Besuche Anaconda für weitere Details unter [https://anaconda.org/conda-forge/ultralytics](https://anaconda.org/conda-forge/ultralytics). Ultralytics Feedstock Repository für die Aktualisierung des Conda-Pakets befindet sich unter [https://github.com/conda-forge/ultralytics-feedstock/](https://github.com/conda-forge/ultralytics-feedstock/). + + + [![Conda Rezept](https://img.shields.io/badge/recipe-ultralytics-green.svg)](https://anaconda.org/conda-forge/ultralytics) [![Conda Downloads](https://img.shields.io/conda/dn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics) [![Conda Version](https://img.shields.io/conda/vn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics) [![Conda Plattformen](https://img.shields.io/conda/pn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics) + + ```bash + # Installiere das ultralytics Paket mit 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 zu installieren, um dem Conda-Paketmanager zu ermöglichen, Konflikte zu lösen, oder `pytorch-cuda` als letztes zu installieren, damit es das CPU-spezifische `pytorch` Paket bei Bedarf überschreiben kann. + ```bash + # Installiere alle Pakete zusammen mit 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 ebenfalls von [DockerHub](https://hub.docker.com/r/ultralytics/ultralytics) verfügbar. Diese Bilder basieren auf [Miniconda3](https://docs.conda.io/projects/miniconda/en/latest/) und bieten eine einfache Möglichkeit, `ultralytics` in einer Conda-Umgebung zu nutzen. + + ```bash + # Setze Image-Name als Variable + t=ultralytics/ultralytics:latest-conda + + # Ziehe das neuste ultralytics Image von Docker Hub + sudo docker pull $t + + # Führe das ultralytics Image in einem Container mit GPU-Unterstützung aus + sudo docker run -it --ipc=host --gpus all $t # alle GPUs + sudo docker run -it --ipc=host --gpus '"device=2,3"' $t # spezifische GPUs angeben + ``` + + === "Git klonen" + Klonen Sie das `ultralytics` Repository, wenn Sie einen Beitrag zur Entwicklung leisten möchten oder mit dem neuesten Quellcode experimentieren wollen. Nach dem Klonen navigieren Sie in das Verzeichnis und installieren das Paket im editierbaren Modus `-e` mit Pip. + ```bash + # Klonen Sie das ultralytics Repository + git clone https://github.com/ultralytics/ultralytics + + # Navigiere zum geklonten Verzeichnis + cd ultralytics + + # Installiere das Paket im editierbaren Modus für die Entwicklung + pip install -e . + ``` + +Siehe die `ultralytics` [requirements.txt](https://github.com/ultralytics/ultralytics/blob/main/requirements.txt) Datei für eine Liste der Abhängigkeiten. Beachten Sie, dass alle oben genannten Beispiele alle erforderlichen Abhängigkeiten installieren. + +!!! Tipp "Tipp" + + PyTorch-Anforderungen variieren je nach Betriebssystem und CUDA-Anforderungen, daher wird empfohlen, PyTorch zuerst gemäß den Anweisungen unter [https://pytorch.org/get-started/locally](https://pytorch.org/get-started/locally) zu installieren. + + + PyTorch Installationsanweisungen + + +## Ultralytics mit CLI verwenden + +Die Befehlszeilenschnittstelle (CLI) von Ultralytics ermöglicht einfache Einzeilige Befehle ohne die Notwendigkeit einer Python-Umgebung. CLI erfordert keine Anpassung oder Python-Code. Sie können alle Aufgaben einfach vom Terminal aus mit dem `yolo` Befehl ausführen. Schauen Sie sich den [CLI-Leitfaden](../usage/cli.md) an, um mehr über die Verwendung von YOLOv8 über die Befehlszeile zu erfahren. + +!!! Beispiel + + === "Syntax" + + Ultralytics `yolo` Befehle verwenden die folgende Syntax: + ```bash + yolo TASK MODE ARGS + + Wo TASK (optional) einer von [detect, segment, classify] ist + MODE (erforderlich) einer von [train, val, predict, export, track] ist + ARGS (optional) eine beliebige Anzahl von benutzerdefinierten 'arg=value' Paaren wie 'imgsz=320', die Vorgaben überschreiben. + ``` + Sehen Sie alle ARGS im vollständigen [Konfigurationsleitfaden](../usage/cfg.md) oder mit `yolo cfg` + + === "Trainieren" + + Trainieren Sie ein Erkennungsmodell für 10 Epochen mit einer Anfangslernerate von 0.01 + ```bash + yolo train data=coco128.yaml model=yolov8n.pt epochs=10 lr0=0.01 + ``` + + === "Vorhersagen" + + Vorhersagen eines YouTube-Videos mit einem vortrainierten Segmentierungsmodell bei einer Bildgröße von 320: + ```bash + yolo predict model=yolov8n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320 + ``` + + === "Val" + + Val ein vortrainiertes Erkennungsmodell bei Batch-Größe 1 und Bildgröße 640: + ```bash + yolo val model=yolov8n.pt data=coco128.yaml batch=1 imgsz=640 + ``` + + === "Exportieren" + + Exportieren Sie ein YOLOv8n-Klassifikationsmodell im ONNX-Format bei einer Bildgröße von 224 mal 128 (kein TASK erforderlich) + ```bash + yolo export model=yolov8n-cls.pt format=onnx imgsz=224,128 + ``` + + === "Speziell" + + Führen Sie spezielle Befehle aus, um Version, Einstellungen zu sehen, Checks auszuführen und mehr: + ```bash + yolo help + yolo checks + yolo version + yolo settings + yolo copy-cfg + yolo cfg + ``` + +!!! Warnung "Warnung" + + Argumente müssen als `arg=val` Paare übergeben werden, getrennt durch ein Gleichheitszeichen `=` und durch Leerzeichen ` ` zwischen den Paaren. Verwenden Sie keine `--` Argumentpräfixe oder Kommata `,` zwischen den Argumenten. + + - `yolo predict model=yolov8n.pt imgsz=640 conf=0.25`   ✅ + - `yolo predict model yolov8n.pt imgsz 640 conf 0.25`   ❌ + - `yolo predict --model yolov8n.pt --imgsz 640 --conf 0.25`   ❌ + +[CLI-Leitfaden](../usage/cli.md){ .md-button .md-button--primary} + +## Ultralytics mit Python verwenden + +Die Python-Schnittstelle von YOLOv8 ermöglicht eine nahtlose Integration in Ihre Python-Projekte und erleichtert das Laden, Ausführen und Verarbeiten der Modellausgabe. Konzipiert für Einfachheit und Benutzerfreundlichkeit, ermöglicht die Python-Schnittstelle Benutzern, Objekterkennung, Segmentierung und Klassifizierung schnell in ihren Projekten zu implementieren. Dies macht die Python-Schnittstelle von YOLOv8 zu einem unschätzbaren Werkzeug für jeden, der diese Funktionalitäten in seine Python-Projekte integrieren möchte. + +Benutzer können beispielsweise ein Modell laden, es trainieren, seine Leistung an einem Validierungsset auswerten und sogar in das ONNX-Format exportieren, und das alles mit nur wenigen Codezeilen. Schauen Sie sich den [Python-Leitfaden](../usage/python.md) an, um mehr über die Verwendung von YOLOv8 in Ihren_python_pro_jek_ten zu erfahren. + +!!! Beispiel + + ```python + from ultralytics import YOLO + + # Erstellen Sie ein neues YOLO Modell von Grund auf + model = YOLO('yolov8n.yaml') + + # Laden Sie ein vortrainiertes YOLO Modell (empfohlen für das Training) + model = YOLO('yolov8n.pt') + + # Trainieren Sie das Modell mit dem Datensatz 'coco128.yaml' für 3 Epochen + results = model.train(data='coco128.yaml', epochs=3) + + # Bewerten Sie die Leistung des Modells am Validierungssatz + results = model.val() + + # Führen Sie eine Objekterkennung an einem Bild mit dem Modell durch + results = model('https://ultralytics.com/images/bus.jpg') + + # Exportieren Sie das Modell ins ONNX-Format + success = model.export(format='onnx') + ``` + +[Python-Leitfaden](../usage/python.md){.md-button .md-button--primary} diff --git a/docs/de/tasks/classify.md b/docs/de/tasks/classify.md new file mode 100644 index 00000000..8ea42be4 --- /dev/null +++ b/docs/de/tasks/classify.md @@ -0,0 +1,172 @@ +--- +comments: true +description: Erfahren Sie mehr über YOLOv8 Classify-Modelle zur Bildklassifizierung. Erhalten Sie detaillierte Informationen über die Liste vortrainierter Modelle und wie man Modelle trainiert, validiert, vorhersagt und exportiert. +keywords: Ultralytics, YOLOv8, Bildklassifizierung, Vortrainierte Modelle, YOLOv8n-cls, Training, Validierung, Vorhersage, Modellexport +--- + +# Bildklassifizierung + +Beispiele für Bildklassifizierung + +Bildklassifizierung ist die einfachste der drei Aufgaben und besteht darin, ein ganzes Bild in eine von einem Satz vordefinierter Klassen zu klassifizieren. + +Die Ausgabe eines Bildklassifizierers ist ein einzelnes Klassenlabel und eine Vertrauenspunktzahl. Bildklassifizierung ist nützlich, wenn Sie nur wissen müssen, zu welcher Klasse ein Bild gehört, und nicht wissen müssen, wo sich Objekte dieser Klasse befinden oder wie ihre genaue Form ist. + +!!! tip "Tipp" + + YOLOv8 Classify-Modelle verwenden den Suffix `-cls`, z.B. `yolov8n-cls.pt` und sind auf [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml) vortrainiert. + +## [Modelle](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8) + +Hier werden vortrainierte YOLOv8 Classify-Modelle gezeigt. Detect-, Segment- und Pose-Modelle sind auf dem [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml)-Datensatz vortrainiert, während Classify-Modelle auf dem [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml)-Datensatz vortrainiert sind. + +[Modelle](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) werden automatisch vom neuesten Ultralytics-[Release](https://github.com/ultralytics/assets/releases) beim ersten Gebrauch heruntergeladen. + +| Modell | Größe
(Pixel) | Genauigkeit
top1 | Genauigkeit
top5 | Geschwindigkeit
CPU ONNX
(ms) | Geschwindigkeit
A100 TensorRT
(ms) | Parameter
(M) | FLOPs
(B) bei 640 | +|----------------------------------------------------------------------------------------------|-----------------------|--------------------------|--------------------------|------------------------------------------|-----------------------------------------------|-----------------------|---------------------------| +| [YOLOv8n-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-cls.pt) | 224 | 66.6 | 87.0 | 12.9 | 0.31 | 2.7 | 4.3 | +| [YOLOv8s-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-cls.pt) | 224 | 72.3 | 91.1 | 23.4 | 0.35 | 6.4 | 13.5 | +| [YOLOv8m-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-cls.pt) | 224 | 76.4 | 93.2 | 85.4 | 0.62 | 17.0 | 42.7 | +| [YOLOv8l-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-cls.pt) | 224 | 78.0 | 94.1 | 163.0 | 0.87 | 37.5 | 99.7 | +| [YOLOv8x-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-cls.pt) | 224 | 78.4 | 94.3 | 232.0 | 1.01 | 57.4 | 154.8 | + +- **Genauigkeit**-Werte sind Modellgenauigkeiten auf dem [ImageNet](https://www.image-net.org/)-Datensatz Validierungsset. +
Zur Reproduktion `yolo val classify data=pfad/zu/ImageNet device=0 verwenden` +- **Geschwindigkeit** Durchschnitt über ImageNet-Validierungsbilder mit einer [Amazon EC2 P4d](https://aws.amazon.com/de/ec2/instance-types/p4/)-Instanz. +
Zur Reproduktion `yolo val classify data=pfad/zu/ImageNet batch=1 device=0|cpu verwenden` + +## Trainieren + +Trainieren Sie das YOLOv8n-cls-Modell auf dem MNIST160-Datensatz für 100 Epochen bei Bildgröße 64. Eine vollständige Liste der verfügbaren Argumente finden Sie auf der Seite [Konfiguration](../../usage/cfg.md). + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Ein Modell laden + model = YOLO('yolov8n-cls.yaml') # ein neues Modell aus YAML erstellen + model = YOLO('yolov8n-cls.pt') # ein vortrainiertes Modell laden (empfohlen für das Training) + model = YOLO('yolov8n-cls.yaml').load('yolov8n-cls.pt') # aus YAML erstellen und Gewichte übertragen + + # Das Modell trainieren + results = model.train(data='mnist160', epochs=100, imgsz=64) + ``` + + === "CLI" + + ```bash + # Ein neues Modell aus YAML erstellen und das Training von Grund auf starten + yolo classify train data=mnist160 model=yolov8n-cls.yaml epochs=100 imgsz=64 + + # Das Training von einem vortrainierten *.pt Modell starten + yolo classify train data=mnist160 model=yolov8n-cls.pt epochs=100 imgsz=64 + + # Ein neues Modell aus YAML erstellen, vortrainierte Gewichte übertragen und das Training starten + yolo classify train data=mnist160 model=yolov8n-cls.yaml pretrained=yolov8n-cls.pt epochs=100 imgsz=64 + ``` + +### Datenformat + +Das Datenformat für YOLO-Klassifizierungsdatensätze finden Sie im Detail im [Datenleitfaden](../../datasets/classify/index.md). + +## Validieren + +Validieren Sie die Genauigkeit des trainierten YOLOv8n-cls-Modells auf dem MNIST160-Datensatz. Kein Argument muss übergeben werden, da das `modell` seine Trainings`daten` und Argumente als Modellattribute behält. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Ein Modell laden + model = YOLO('yolov8n-cls.pt') # ein offizielles Modell laden + model = YOLO('pfad/zu/best.pt') # ein benutzerdefiniertes Modell laden + + # Das Modell validieren + metrics = model.val() # keine Argumente benötigt, Datensatz und Einstellungen gespeichert + metrics.top1 # top1 Genauigkeit + metrics.top5 # top5 Genauigkeit + ``` + === "CLI" + + ```bash + yolo classify val model=yolov8n-cls.pt # ein offizielles Modell validieren + yolo classify val model=pfad/zu/best.pt # ein benutzerdefiniertes Modell validieren + ``` + +## Vorhersagen + +Verwenden Sie ein trainiertes YOLOv8n-cls-Modell, um Vorhersagen auf Bildern durchzuführen. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Ein Modell laden + model = YOLO('yolov8n-cls.pt') # ein offizielles Modell laden + model = YOLO('pfad/zu/best.pt') # ein benutzerdefiniertes Modell laden + + # Mit dem Modell vorhersagen + results = model('https://ultralytics.com/images/bus.jpg') # Vorhersage auf einem Bild + ``` + === "CLI" + + ```bash + yolo classify predict model=yolov8n-cls.pt source='https://ultralytics.com/images/bus.jpg' # mit offiziellem Modell vorhersagen + yolo classify predict model=pfad/zu/best.pt source='https://ultralytics.com/images/bus.jpg' # mit benutzerdefiniertem Modell vorhersagen + ``` + +Vollständige Details zum `predict`-Modus finden Sie auf der Seite [Vorhersage](https://docs.ultralytics.com/modes/predict/). + +## Exportieren + +Exportieren Sie ein YOLOv8n-cls-Modell in ein anderes Format wie ONNX, CoreML usw. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Ein Modell laden + model = YOLO('yolov8n-cls.pt') # ein offizielles Modell laden + model = YOLO('pfad/zu/best.pt') # ein benutzerdefiniertes trainiertes Modell laden + + # Das Modell exportieren + model.export(format='onnx') + ``` + === "CLI" + + ```bash + yolo export model=yolov8n-cls.pt format=onnx # offizielles Modell exportieren + yolo export model=pfad/zu/best.pt format=onnx # benutzerdefiniertes trainiertes Modell exportieren + ``` + +Verfügbare YOLOv8-cls Exportformate stehen in der folgenden Tabelle. Sie können direkt auf exportierten Modellen vorhersagen oder validieren, d.h. `yolo predict model=yolov8n-cls.onnx`. Nutzungsexempel werden für Ihr Modell nach Abschluss des Exports angezeigt. + +| Format | `format`-Argument | Modell | Metadaten | Argumente | +|--------------------------------------------------------------------|-------------------|-------------------------------|-----------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n-cls.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-cls.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-cls.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-cls_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-cls.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-cls.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-cls_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-cls.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-cls.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-cls_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-cls_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-cls_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-cls_ncnn_model/` | ✅ | `imgsz`, `half` | + +Vollständige Details zum `export` finden Sie auf der Seite [Export](https://docs.ultralytics.com/modes/export/). diff --git a/docs/de/tasks/detect.md b/docs/de/tasks/detect.md new file mode 100644 index 00000000..e5b8094b --- /dev/null +++ b/docs/de/tasks/detect.md @@ -0,0 +1,184 @@ +--- +comments: true +description: Offizielle Dokumentation für YOLOv8 von Ultralytics. Erfahren Sie, wie Sie Modelle trainieren, validieren, vorhersagen und in verschiedenen Formaten exportieren. Einschließlich detaillierter Leistungsstatistiken. +keywords: YOLOv8, Ultralytics, Objekterkennung, vortrainierte Modelle, Training, Validierung, Vorhersage, Modell-Export, COCO, ImageNet, PyTorch, ONNX, CoreML +--- + +# Objekterkennung + +Beispiele für Objekterkennung + +Objekterkennung ist eine Aufgabe, die das Identifizieren der Position und Klasse von Objekten in einem Bild oder Videostream umfasst. + +Die Ausgabe eines Objekterkenners ist eine Menge von Begrenzungsrahmen, die die Objekte im Bild umschließen, zusammen mit Klassenbezeichnungen und Vertrauenswerten für jedes Feld. Objekterkennung ist eine gute Wahl, wenn Sie Objekte von Interesse in einer Szene identifizieren müssen, aber nicht genau wissen müssen, wo das Objekt ist oder wie seine genaue Form ist. + +

+
+ +
+ Sehen Sie: Objekterkennung mit vortrainiertem Ultralytics YOLOv8 Modell. +

+ +!!! tip "Tipp" + + YOLOv8 Detect Modelle sind die Standard YOLOv8 Modelle, zum Beispiel `yolov8n.pt`, und sind vortrainiert auf dem [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml)-Datensatz. + +## [Modelle](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8) + +Hier werden die vortrainierten YOLOv8 Detect Modelle gezeigt. Detect, Segment und Pose Modelle sind vortrainiert auf dem [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml)-Datensatz, während die Classify Modelle vortrainiert sind auf dem [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml)-Datensatz. + +[Modelle](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) werden automatisch von der neuesten Ultralytics [Veröffentlichung](https://github.com/ultralytics/assets/releases) bei Erstbenutzung heruntergeladen. + +| Modell | Größe
(Pixel) | mAPval
50-95 | Geschwindigkeit
CPU ONNX
(ms) | Geschwindigkeit
A100 TensorRT
(ms) | params
(M) | FLOPs
(B) | +|--------------------------------------------------------------------------------------|-----------------------|----------------------|------------------------------------------|-----------------------------------------------|--------------------|-------------------| +| [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n.pt) | 640 | 37.3 | 80.4 | 0.99 | 3.2 | 8.7 | +| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s.pt) | 640 | 44.9 | 128.4 | 1.20 | 11.2 | 28.6 | +| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m.pt) | 640 | 50.2 | 234.7 | 1.83 | 25.9 | 78.9 | +| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l.pt) | 640 | 52.9 | 375.2 | 2.39 | 43.7 | 165.2 | +| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x.pt) | 640 | 53.9 | 479.1 | 3.53 | 68.2 | 257.8 | + +- **mAPval** Werte sind für Single-Modell Single-Scale auf dem [COCO val2017](http://cocodataset.org) Datensatz. +
Reproduzieren mit `yolo val detect data=coco.yaml device=0` +- **Geschwindigkeit** gemittelt über COCO Val Bilder mit einer [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/)-Instanz. +
Reproduzieren mit `yolo val detect data=coco128.yaml batch=1 device=0|cpu` + +## Training + +YOLOv8n auf dem COCO128-Datensatz für 100 Epochen bei Bildgröße 640 trainieren. Für eine vollständige Liste verfügbarer Argumente siehe die [Konfigurationsseite](../../usage/cfg.md). + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Modell laden + model = YOLO('yolov8n.yaml') # ein neues Modell aus YAML aufbauen + model = YOLO('yolov8n.pt') # ein vortrainiertes Modell laden (empfohlen für Training) + model = YOLO('yolov8n.yaml').load('yolov8n.pt') # aus YAML aufbauen und Gewichte übertragen + + # Das Modell trainieren + results = model.train(data='coco128.yaml', epochs=100, imgsz=640) + ``` + === "CLI" + + ```bash + # Ein neues Modell aus YAML aufbauen und Training von Grund auf starten + yolo detect train data=coco128.yaml model=yolov8n.yaml epochs=100 imgsz=640 + + # Training von einem vortrainierten *.pt Modell starten + yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 + + # Ein neues Modell aus YAML aufbauen, vortrainierte Gewichte übertragen und Training starten + yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640 + ``` + +### Datenformat + +Das Datenformat für YOLO-Erkennungsdatensätze finden Sie detailliert im [Dataset Guide](../../datasets/detect/index.md). Um Ihren vorhandenen Datensatz von anderen Formaten (wie COCO etc.) in das YOLO-Format zu konvertieren, verwenden Sie bitte das [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO)-Tool von Ultralytics. + +## Validierung + +Genauigkeit des trainierten YOLOv8n-Modells auf dem COCO128-Datensatz validieren. Es müssen keine Argumente übergeben werden, da das `modell` seine Trainingsdaten und Argumente als Modellattribute beibehält. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Modell laden + model = YOLO('yolov8n.pt') # ein offizielles Modell laden + model = YOLO('pfad/zum/besten.pt') # ein benutzerdefiniertes Modell laden + + # Das Modell validieren + metrics = model.val() # keine Argumente nötig, Datensatz und Einstellungen erinnert + metrics.box.map # map50-95 + metrics.box.map50 # map50 + metrics.box.map75 # map75 + metrics.box.maps # eine Liste enthält map50-95 jeder Kategorie + ``` + === "CLI" + + ```bash + yolo detect val model=yolov8n.pt # offizielles Modell validieren + yolo detect val model=pfad/zum/besten.pt # benutzerdefiniertes Modell validieren + ``` + +## Vorhersage + +Ein trainiertes YOLOv8n-Modell verwenden, um Vorhersagen auf Bildern durchzuführen. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Modell laden + model = YOLO('yolov8n.pt') # ein offizielles Modell laden + model = YOLO('pfad/zum/besten.pt') # ein benutzerdefiniertes Modell laden + + # Mit dem Modell vorhersagen + results = model('https://ultralytics.com/images/bus.jpg') # Vorhersage auf einem Bild + ``` + === "CLI" + + ```bash + yolo detect predict model=yolov8n.pt source='https://ultralytics.com/images/bus.jpg' # Vorhersage mit offiziellem Modell + yolo detect predict model=pfad/zum/besten.pt source='https://ultralytics.com/images/bus.jpg' # Vorhersage mit benutzerdefiniertem Modell + ``` + +Volle Details über den `predict`-Modus finden Sie auf der [Predict-Seite](https://docs.ultralytics.com/modes/predict/). + +## Export + +Ein YOLOv8n-Modell in ein anderes Format wie ONNX, CoreML usw. exportieren. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Modell laden + model = YOLO('yolov8n.pt') # ein offizielles Modell laden + model = YOLO('pfad/zum/besten.pt') # ein benutzerdefiniert trainiertes Modell laden + + # Das Modell exportieren + model.export(format='onnx') + ``` + === "CLI" + + ```bash + yolo export model=yolov8n.pt format=onnx # offizielles Modell exportieren + yolo export model=pfad/zum/besten.pt format=onnx # benutzerdefiniert trainiertes Modell exportieren + ``` + +Verfügbare YOLOv8 Exportformate sind in der untenstehenden Tabelle aufgeführt. Sie können direkt auf den exportierten Modellen Vorhersagen treffen oder diese validieren, zum Beispiel `yolo predict model=yolov8n.onnx`. Verwendungsbeispiele werden für Ihr Modell nach Abschluss des Exports angezeigt. + +| Format | `format`-Argument | Modell | Metadaten | Argumente | +|--------------------------------------------------------------------|-------------------|---------------------------|-----------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | ✅ | `imgsz`, `half` | + +Volle Details zum `export` finden Sie auf der [Export-Seite](https://docs.ultralytics.com/modes/export/). diff --git a/docs/de/tasks/index.md b/docs/de/tasks/index.md new file mode 100644 index 00000000..6da5787e --- /dev/null +++ b/docs/de/tasks/index.md @@ -0,0 +1,55 @@ +--- +comments: true +description: Erfahren Sie, welche grundlegenden Aufgaben im Bereich der Computer Vision YOLOv8 durchführen kann, einschließlich Erkennung, Segmentierung, Klassifizierung und Haltungsschätzung, und wie sie in Ihren KI-Projekten verwendet werden können. +keywords: Ultralytics, YOLOv8, Erkennung, Segmentierung, Klassifizierung, Pose-Schätzung, KI-Framework, Computer Vision-Aufgaben +--- + +# Ultralytics YOLOv8 Aufgaben + +
+Ultralytics YOLO unterstützte Aufgaben + +YOLOv8 ist ein KI-Framework, das mehrere Aufgaben im Bereich der Computer Vision **unterstützt**. Das Framework kann für die [Erkennung](detect.md), [Segmentierung](segment.md), [Klassifizierung](classify.md) und die [Pose](pose.md)-Schätzung verwendet werden. Jede dieser Aufgaben hat ein unterschiedliches Ziel und Anwendungsgebiete. + +!!! Hinweis + + 🚧 Unsere mehrsprachigen Dokumentation befindet sich derzeit im Aufbau und wir arbeiten hart daran, sie zu verbessern. Danke für Ihre Geduld! 🙏 + +

+
+ +
+ Schauen Sie zu: Entdecken Sie Ultralytics YOLO Aufgaben: Objekterkennung, Segmentierung, Verfolgung und Pose-Schätzung. +

+ +## [Erkennung](detect.md) + +Erkennung ist die primäre von YOLOv8 unterstützte Aufgabe. Sie beinhaltet das Erkennen von Objekten in einem Bild oder Videobild und das Zeichnen von Rahmen um sie herum. Die erkannten Objekte werden anhand ihrer Merkmale in verschiedene Kategorien klassifiziert. YOLOv8 kann mehrere Objekte in einem einzelnen Bild oder Videobild mit hoher Genauigkeit und Geschwindigkeit erkennen. + +[Beispiele für Erkennung](detect.md){ .md-button .md-button--primary} + +## [Segmentierung](segment.md) + +Segmentierung ist eine Aufgabe, die das Aufteilen eines Bildes in unterschiedliche Regionen anhand des Bildinhalts beinhaltet. Jeder Region wird basierend auf ihrem Inhalt eine Markierung zugewiesen. Diese Aufgabe ist nützlich in Anwendungen wie der Bildsegmentierung und medizinischen Bildgebung. YOLOv8 verwendet eine Variante der U-Net-Architektur, um die Segmentierung durchzuführen. + +[Beispiele für Segmentierung](segment.md){ .md-button .md-button--primary} + +## [Klassifizierung](classify.md) + +Klassifizierung ist eine Aufgabe, die das Einordnen eines Bildes in verschiedene Kategorien umfasst. YOLOv8 kann genutzt werden, um Bilder anhand ihres Inhalts zu klassifizieren. Es verwendet eine Variante der EfficientNet-Architektur, um die Klassifizierung durchzuführen. + +[Beispiele für Klassifizierung](classify.md){ .md-button .md-button--primary} + +## [Pose](pose.md) + +Die Pose-/Keypoint-Erkennung ist eine Aufgabe, die das Erkennen von spezifischen Punkten in einem Bild oder Videobild beinhaltet. Diese Punkte werden als Keypoints bezeichnet und werden zur Bewegungsverfolgung oder Pose-Schätzung verwendet. YOLOv8 kann Keypoints in einem Bild oder Videobild mit hoher Genauigkeit und Geschwindigkeit erkennen. + +[Beispiele für Posen](pose.md){ .md-button .md-button--primary} + +## Fazit + +YOLOv8 unterstützt mehrere Aufgaben, einschließlich Erkennung, Segmentierung, Klassifizierung und Keypoint-Erkennung. Jede dieser Aufgaben hat unterschiedliche Ziele und Anwendungsgebiete. Durch das Verständnis der Unterschiede zwischen diesen Aufgaben können Sie die geeignete Aufgabe für Ihre Anwendung im Bereich der Computer Vision auswählen. diff --git a/docs/de/tasks/pose.md b/docs/de/tasks/pose.md new file mode 100644 index 00000000..ef051382 --- /dev/null +++ b/docs/de/tasks/pose.md @@ -0,0 +1,185 @@ +--- +comments: true +description: Erfahren Sie, wie Sie Ultralytics YOLOv8 für Aufgaben der Pose-Schätzung verwenden können. Finden Sie vortrainierte Modelle, lernen Sie, wie man eigene trainiert, validiert, vorhersagt und exportiert. +keywords: Ultralytics, YOLO, YOLOv8, Pose-Schätzung, Erkennung von Schlüsselpunkten, Objekterkennung, vortrainierte Modelle, maschinelles Lernen, künstliche Intelligenz +--- + +# Pose-Schätzung + +![Beispiele für die Pose-Schätzung](https://user-images.githubusercontent.com/26833433/243418616-9811ac0b-a4a7-452a-8aba-484ba32bb4a8.png) + +Die Pose-Schätzung ist eine Aufgabe, die das Identifizieren der Lage spezifischer Punkte in einem Bild beinhaltet, die normalerweise als Schlüsselpunkte bezeichnet werden. Die Schlüsselpunkte können verschiedene Teile des Objekts wie Gelenke, Landmarken oder andere charakteristische Merkmale repräsentieren. Die Positionen der Schlüsselpunkte sind üblicherweise als eine Gruppe von 2D `[x, y]` oder 3D `[x, y, sichtbar]` Koordinaten dargestellt. + +Das Ergebnis eines Pose-Schätzungsmodells ist eine Gruppe von Punkten, die die Schlüsselpunkte auf einem Objekt im Bild darstellen, normalerweise zusammen mit den Konfidenzwerten für jeden Punkt. Die Pose-Schätzung eignet sich gut, wenn Sie spezifische Teile eines Objekts in einer Szene identifizieren müssen und deren Lage zueinander. + +

+
+ +
+ Ansehen: Pose-Schätzung mit Ultralytics YOLOv8. +

+ +!!! Tipp "Tipp" + + YOLOv8 _pose_-Modelle verwenden den Suffix `-pose`, z. B. `yolov8n-pose.pt`. Diese Modelle sind auf dem [COCO-Schlüsselpunkte](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco-pose.yaml)-Datensatz trainiert und für eine Vielzahl von Pose-Schätzungsaufgaben geeignet. + +## [Modelle](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8) + +Hier werden vortrainierte YOLOv8 Pose-Modelle gezeigt. Erkennungs-, Segmentierungs- und Pose-Modelle sind auf dem [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml)-Datensatz vortrainiert, während Klassifizierungsmodelle auf dem [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml)-Datensatz vortrainiert sind. + +[Modelle](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) werden automatisch aus der neuesten Ultralytics-[Veröffentlichung](https://github.com/ultralytics/assets/releases) bei erstmaliger Verwendung heruntergeladen. + +| Modell | Größe
(Pixel) | mAPpose
50-95 | mAPpose
50 | Geschwindigkeit
CPU ONNX
(ms) | Geschwindigkeit
A100 TensorRT
(ms) | Parameter
(M) | FLOPs
(B) | +|------------------------------------------------------------------------------------------------------|------------------------|------------------------|---------------------|--------------------------------------------|-------------------------------------------------|------------------------|--------------------| +| [YOLOv8n-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-pose.pt) | 640 | 50,4 | 80,1 | 131,8 | 1,18 | 3,3 | 9,2 | +| [YOLOv8s-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-pose.pt) | 640 | 60,0 | 86,2 | 233,2 | 1,42 | 11,6 | 30,2 | +| [YOLOv8m-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-pose.pt) | 640 | 65,0 | 88,8 | 456,3 | 2,00 | 26,4 | 81,0 | +| [YOLOv8l-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-pose.pt) | 640 | 67,6 | 90,0 | 784,5 | 2,59 | 44,4 | 168,6 | +| [YOLOv8x-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose.pt) | 640 | 69,2 | 90,2 | 1607,1 | 3,73 | 69,4 | 263,2 | +| [YOLOv8x-pose-p6](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose-p6.pt) | 1280 | 71,6 | 91,2 | 4088,7 | 10,04 | 99,1 | 1066,4 | + +- **mAPval** Werte gelten für ein einzelnes Modell mit einfacher Skala auf dem [COCO Keypoints val2017](http://cocodataset.org)-Datensatz. +
Zu reproduzieren mit `yolo val pose data=coco-pose.yaml device=0`. +- **Geschwindigkeit** gemittelt über COCO-Validierungsbilder mit einer [Amazon EC2 P4d](https://aws.amazon.com/de/ec2/instance-types/p4/)-Instanz. +
Zu reproduzieren mit `yolo val pose data=coco8-pose.yaml batch=1 device=0|cpu`. + +## Trainieren + +Trainieren Sie ein YOLOv8-Pose-Modell auf dem COCO128-Pose-Datensatz. + +!!! Beispiel "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Modell laden + model = YOLO('yolov8n-pose.yaml') # ein neues Modell aus YAML bauen + model = YOLO('yolov8n-pose.pt') # ein vortrainiertes Modell laden (empfohlen für das Training) + model = YOLO('yolov8n-pose.yaml').load('yolov8n-pose.pt') # aus YAML bauen und Gewichte übertragen + + # Modell trainieren + results = model.train(data='coco8-pose.yaml', epochs=100, imgsz=640) + ``` + === "CLI" + + ```bash + # Ein neues Modell aus YAML bauen und das Training von Grund auf starten + yolo pose train data=coco8-pose.yaml model=yolov8n-pose.yaml epochs=100 imgsz=640 + + # Training von einem vortrainierten *.pt Modell starten + yolo pose train data=coco8-pose.yaml model=yolov8n-pose.pt epochs=100 imgsz=640 + + # Ein neues Modell aus YAML bauen, vortrainierte Gewichte übertragen und das Training starten + yolo pose train data=coco8-pose.yaml model=yolov8n-pose.yaml pretrained=yolov8n-pose.pt epochs=100 imgsz=640 + ``` + +### Datensatzformat + +Das YOLO-Pose-Datensatzformat finden Sie detailliert im [Datensatz-Leitfaden](../../datasets/pose/index.md). Um Ihren bestehenden Datensatz aus anderen Formaten (wie COCO usw.) in das YOLO-Format zu konvertieren, verwenden Sie bitte das [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO)-Tool von Ultralytics. + +## Validieren + +Die Genauigkeit des trainierten YOLOv8n-Pose-Modells auf dem COCO128-Pose-Datensatz validieren. Es müssen keine Argumente übergeben werden, da das `Modell` seine Trainings`daten` und Argumente als Modellattribute beibehält. + +!!! Beispiel "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Modell laden + model = YOLO('yolov8n-pose.pt') # ein offizielles Modell laden + model = YOLO('pfad/zu/best.pt') # ein benutzerdefiniertes Modell laden + + # Modell validieren + metrics = model.val() # keine Argumente nötig, Datensatz und Einstellungen sind gespeichert + metrics.box.map # map50-95 + metrics.box.map50 # map50 + metrics.box.map75 # map75 + metrics.box.maps # Liste enthält map50-95 jeder Kategorie + ``` + === "CLI" + + ```bash + yolo pose val model=yolov8n-pose.pt # offizielles Modell validieren + yolo pose val model=pfad/zu/best.pt # benutzerdefiniertes Modell validieren + ``` + +## Vorhersagen + +Ein trainiertes YOLOv8n-Pose-Modell verwenden, um Vorhersagen auf Bildern zu machen. + +!!! Beispiel "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Modell laden + model = YOLO('yolov8n-pose.pt') # ein offizielles Modell laden + model = YOLO('pfad/zu/best.pt') # ein benutzerdefiniertes Modell laden + + # Mit dem Modell Vorhersagen machen + results = model('https://ultralytics.com/images/bus.jpg') # Vorhersage auf einem Bild machen + ``` + === "CLI" + + ```bash + yolo pose predict model=yolov8n-pose.pt source='https://ultralytics.com/images/bus.jpg' # Vorhersage mit dem offiziellen Modell machen + yolo pose predict model=pfad/zu/best.pt source='https://ultralytics.com/images/bus.jpg' # Vorhersage mit dem benutzerdefinierten Modell machen + ``` + +Vollständige `predict`-Modusdetails finden Sie auf der [Vorhersage](https://docs.ultralytics.com/modes/predict/)-Seite. + +## Exportieren + +Ein YOLOv8n-Pose-Modell in ein anderes Format wie ONNX, CoreML usw. exportieren. + +!!! Beispiel "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Modell laden + model = YOLO('yolov8n-pose.pt') # ein offizielles Modell laden + model = YOLO('pfad/zu/best.pt') # ein benutzerdefiniertes Modell laden + + # Modell exportieren + model.export(format='onnx') + ``` + === "CLI" + + ```bash + yolo export model=yolov8n-pose.pt format=onnx # offizielles Modell exportieren + yolo export model=pfad/zu/best.pt format=onnx # benutzerdefiniertes Modell exportieren + ``` + +Verfügbare YOLOv8-Pose-Exportformate sind in der folgenden Tabelle aufgeführt. Sie können direkt auf exportierten Modellen vorhersagen oder validieren, z. B. `yolo predict model=yolov8n-pose.onnx`. Verwendungsbeispiele werden für Ihr Modell nach Abschluss des Exports angezeigt. + +| Format | `format` Argument | Modell | Metadaten | Argumente | +|--------------------------------------------------------------------|-------------------|--------------------------------|-----------|-----------------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n-pose.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-pose.torchscript` | ✅ | `imgsz`, `optimieren` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-pose.onnx` | ✅ | `imgsz`, `halb`, `dynamisch`, `vereinfachen`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-pose_openvino_model/` | ✅ | `imgsz`, `halb` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-pose.engine` | ✅ | `imgsz`, `halb`, `dynamisch`, `vereinfachen`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-pose.mlpackage` | ✅ | `imgsz`, `halb`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-pose_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-pose.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-pose.tflite` | ✅ | `imgsz`, `halb`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-pose_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-pose_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-pose_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-pose_ncnn_model/` | ✅ | `imgsz`, `halb` | + +Vollständige `export`-Details finden Sie auf der [Export](https://docs.ultralytics.com/modes/export/)-Seite. diff --git a/docs/de/tasks/segment.md b/docs/de/tasks/segment.md new file mode 100644 index 00000000..7f4e8d5a --- /dev/null +++ b/docs/de/tasks/segment.md @@ -0,0 +1,188 @@ +--- +comments: true +description: Erfahren Sie, wie Sie Instanzsegmentierungsmodelle mit Ultralytics YOLO verwenden. Anleitungen zum Training, zur Validierung, zur Bildvorhersage und zum Export von Modellen. +Schlagworte: yolov8, Instanzsegmentierung, Ultralytics, COCO-Datensatz, Bildsegmentierung, Objekterkennung, Modelltraining, Modellvalidierung, Bildvorhersage, Modellexport +--- + +# Instanzsegmentierung + +![Beispiele für Instanzsegmentierung](https://user-images.githubusercontent.com/26833433/243418644-7df320b8-098d-47f1-85c5-26604d761286.png) + +Instanzsegmentierung geht einen Schritt weiter als die Objekterkennung und beinhaltet die Identifizierung einzelner Objekte in einem Bild und deren Abtrennung vom Rest des Bildes. + +Das Ergebnis eines Instanzsegmentierungsmodells ist eine Reihe von Masken oder Konturen, die jedes Objekt im Bild umreißen, zusammen mit Klassenbezeichnungen und Vertrauensscores für jedes Objekt. Instanzsegmentierung ist nützlich, wenn man nicht nur wissen muss, wo sich Objekte in einem Bild befinden, sondern auch, welche genaue Form sie haben. + +

+
+ +
+ Schauen Sie: Führen Sie Segmentierung mit dem vortrainierten Ultralytics YOLOv8 Modell in Python aus. +

+ +!!! Tipp "Tipp" + + YOLOv8 Segment-Modelle verwenden das Suffix `-seg`, d.h. `yolov8n-seg.pt` und sind auf dem [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml)-Datensatz vortrainiert. + +## [Modelle](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8) + +Hier werden vortrainierte YOLOv8 Segment-Modelle gezeigt. Detect-, Segment- und Pose-Modelle sind auf dem [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml)-Datensatz vortrainiert, während Classify-Modelle auf dem [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml)-Datensatz vortrainiert sind. + +[Modelle](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) laden sich automatisch von der neuesten Ultralytics [Veröffentlichung](https://github.com/ultralytics/assets/releases) beim ersten Gebrauch herunter. + +| Modell | Größe
(Pixel) | mAPKasten
50-95 | mAPMasken
50-95 | Geschwindigkeit
CPU ONNX
(ms) | Geschwindigkeit
A100 TensorRT
(ms) | Parameter
(M) | FLOPs
(B) | +|----------------------------------------------------------------------------------------------|-----------------------|-------------------------|-------------------------|------------------------------------------|-----------------------------------------------|-----------------------|-------------------| +| [YOLOv8n-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-seg.pt) | 640 | 36.7 | 30.5 | 96.1 | 1.21 | 3.4 | 12.6 | +| [YOLOv8s-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-seg.pt) | 640 | 44.6 | 36.8 | 155.7 | 1.47 | 11.8 | 42.6 | +| [YOLOv8m-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-seg.pt) | 640 | 49.9 | 40.8 | 317.0 | 2.18 | 27.3 | 110.2 | +| [YOLOv8l-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-seg.pt) | 640 | 52.3 | 42.6 | 572.4 | 2.79 | 46.0 | 220.5 | +| [YOLOv8x-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-seg.pt) | 640 | 53.4 | 43.4 | 712.1 | 4.02 | 71.8 | 344.1 | + +- Die **mAPval**-Werte sind für ein einzelnes Modell, einzelne Skala auf dem [COCO val2017](http://cocodataset.org)-Datensatz. +
Zum Reproduzieren nutzen Sie `yolo val segment data=coco.yaml device=0` +- Die **Geschwindigkeit** ist über die COCO-Validierungsbilder gemittelt und verwendet eine [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/)-Instanz. +
Zum Reproduzieren `yolo val segment data=coco128-seg.yaml batch=1 device=0|cpu` + +## Training + +Trainieren Sie YOLOv8n-seg auf dem COCO128-seg-Datensatz für 100 Epochen mit einer Bildgröße von 640. Eine vollständige Liste der verfügbaren Argumente finden Sie auf der Seite [Konfiguration](../../usage/cfg.md). + +!!! Beispiel "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Modell laden + model = YOLO('yolov8n-seg.yaml') # ein neues Modell aus YAML erstellen + model = YOLO('yolov8n-seg.pt') # ein vortrainiertes Modell laden (empfohlen für das Training) + model = YOLO('yolov8n-seg.yaml').load('yolov8n.pt') # aus YAML erstellen und Gewichte übertragen + + # Das Modell trainieren + results = model.train(data='coco128-seg.yaml', epochs=100, imgsz=640) + ``` + === "CLI" + + ```bash + # Ein neues Modell aus YAML erstellen und das Training von vorne beginnen + yolo segment train data=coco128-seg.yaml model=yolov8n-seg.yaml epochs=100 imgsz=640 + + # Das Training von einem vortrainierten *.pt Modell aus starten + yolo segment train data=coco128-seg.yaml model=yolov8n-seg.pt epochs=100 imgsz=640 + + # Ein neues Modell aus YAML erstellen, vortrainierte Gewichte darauf übertragen und das Training beginnen + yolo segment train data=coco128-seg.yaml model=yolov8n-seg.yaml pretrained=yolov8n-seg.pt epochs=100 imgsz=640 + ``` + +### Datenformat + +Das YOLO Segmentierungsdatenformat finden Sie detailliert im [Dataset Guide](../../datasets/segment/index.md). Um Ihre vorhandenen Daten aus anderen Formaten (wie COCO usw.) in das YOLO-Format umzuwandeln, verwenden Sie bitte das [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO)-Tool von Ultralytics. + +## Val + +Validieren Sie die Genauigkeit des trainierten YOLOv8n-seg-Modells auf dem COCO128-seg-Datensatz. Es müssen keine Argumente übergeben werden, da das `Modell` seine Trainingsdaten und -argumente als Modellattribute behält. + +!!! Beispiel "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Modell laden + model = YOLO('yolov8n-seg.pt') # offizielles Modell laden + model = YOLO('pfad/zu/best.pt') # benutzerdefiniertes Modell laden + + # Das Modell validieren + metrics = model.val() # Keine Argumente erforderlich, Datensatz und Einstellungen werden behalten + metrics.box.map # mAP50-95(B) + metrics.box.map50 # mAP50(B) + metrics.box.map75 # mAP75(B) + metrics.box.maps # eine Liste enthält mAP50-95(B) für jede Kategorie + metrics.seg.map # mAP50-95(M) + metrics.seg.map50 # mAP50(M) + metrics.seg.map75 # mAP75(M) + metrics.seg.maps # eine Liste enthält mAP50-95(M) für jede Kategorie + ``` + === "CLI" + + ```bash + yolo segment val model=yolov8n-seg.pt # offizielles Modell validieren + yolo segment val model=pfad/zu/best.pt # benutzerdefiniertes Modell validieren + ``` + +## Predict + +Verwenden Sie ein trainiertes YOLOv8n-seg-Modell für Vorhersagen auf Bildern. + +!!! Beispiel "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Modell laden + model = YOLO('yolov8n-seg.pt') # offizielles Modell laden + model = YOLO('pfad/zu/best.pt') # benutzerdefiniertes Modell laden + + # Mit dem Modell Vorhersagen treffen + results = model('https://ultralytics.com/images/bus.jpg') # Vorhersage auf einem Bild + ``` + === "CLI" + + ```bash + yolo segment predict model=yolov8n-seg.pt source='https://ultralytics.com/images/bus.jpg' # Vorhersage mit offiziellem Modell treffen + yolo segment predict model=pfad/zu/best.pt source='https://ultralytics.com/images/bus.jpg' # Vorhersage mit benutzerdefiniertem Modell treffen + ``` + +Die vollständigen Details zum `predict`-Modus finden Sie auf der Seite [Predict](https://docs.ultralytics.com/modes/predict/). + +## Export + +Exportieren Sie ein YOLOv8n-seg-Modell in ein anderes Format wie ONNX, CoreML usw. + +!!! Beispiel "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Modell laden + model = YOLO('yolov8n-seg.pt') # offizielles Modell laden + model = YOLO('pfad/zu/best.pt') # benutzerdefiniertes trainiertes Modell laden + + # Das Modell exportieren + model.export(format='onnx') + ``` + === "CLI" + + ```bash + yolo export model=yolov8n-seg.pt format=onnx # offizielles Modell exportieren + yolo export model=pfad/zu/best.pt format=onnx # benutzerdefiniertes trainiertes Modell exportieren + ``` + +Die verfügbaren YOLOv8-seg-Exportformate sind in der folgenden Tabelle aufgeführt. Sie können direkt auf exportierten Modellen Vorhersagen treffen oder sie validieren, z.B. `yolo predict model=yolov8n-seg.onnx`. Verwendungsbeispiele werden für Ihr Modell nach dem Export angezeigt. + +| Format | `format`-Argument | Modell | Metadaten | Argumente | +|--------------------------------------------------------------------|-------------------|-------------------------------|-----------|-----------------------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n-seg.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-seg.torchscript` | ✅ | `imgsz`, `optimieren` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-seg.onnx` | ✅ | `imgsz`, `halb`, `dynamisch`, `vereinfachen`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-seg_openvino_model/` | ✅ | `imgsz`, `halb` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-seg.engine` | ✅ | `imgsz`, `halb`, `dynamisch`, `vereinfachen`, `Arbeitsspeicher` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-seg.mlpackage` | ✅ | `imgsz`, `halb`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-seg_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-seg.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-seg.tflite` | ✅ | `imgsz`, `halb`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-seg_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-seg_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-seg_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-seg_ncnn_model/` | ✅ | `imgsz`, `halb` | + +Die vollständigen Details zum `export` finden Sie auf der Seite [Export](https://docs.ultralytics.com/modes/export/). diff --git a/docs/en/datasets/detect/index.md b/docs/en/datasets/detect/index.md index 20dcaac1..a99846e4 100644 --- a/docs/en/datasets/detect/index.md +++ b/docs/en/datasets/detect/index.md @@ -72,16 +72,16 @@ Here's how you can use these formats to train your model: Here is a list of the supported datasets and a brief description for each: -- [**Argoverse**](./argoverse.md): A collection of sensor data collected from autonomous vehicles. It contains 3D tracking annotations for car objects. -- [**COCO**](./coco.md): Common Objects in Context (COCO) is a large-scale object detection, segmentation, and captioning dataset with 80 object categories. -- [**COCO8**](./coco8.md): A smaller subset of the COCO dataset, COCO8 is more lightweight and faster to train. -- [**GlobalWheat2020**](./globalwheat2020.md): A dataset containing images of wheat heads for the Global Wheat Challenge 2020. -- [**Objects365**](./objects365.md): A large-scale object detection dataset with 365 object categories and 600k images, aimed at advancing object detection research. -- [**OpenImagesV7**](./open-images-v7.md): A comprehensive dataset by Google with 1.7M train images and 42k validation images. -- [**SKU-110K**](./sku-110k.md): A dataset containing images of densely packed retail products, intended for retail environment object detection. -- [**VisDrone**](./visdrone.md): A dataset focusing on drone-based images, containing various object categories like cars, pedestrians, and cyclists. -- [**VOC**](./voc.md): PASCAL VOC is a popular object detection dataset with 20 object categories including vehicles, animals, and furniture. -- [**xView**](./xview.md): A dataset containing high-resolution satellite imagery, designed for the detection of various object classes in overhead views. +- [**Argoverse**](argoverse.md): A collection of sensor data collected from autonomous vehicles. It contains 3D tracking annotations for car objects. +- [**COCO**](coco.md): Common Objects in Context (COCO) is a large-scale object detection, segmentation, and captioning dataset with 80 object categories. +- [**COCO8**](coco8.md): A smaller subset of the COCO dataset, COCO8 is more lightweight and faster to train. +- [**GlobalWheat2020**](globalwheat2020.md): A dataset containing images of wheat heads for the Global Wheat Challenge 2020. +- [**Objects365**](objects365.md): A large-scale object detection dataset with 365 object categories and 600k images, aimed at advancing object detection research. +- [**OpenImagesV7**](open-images-v7.md): A comprehensive dataset by Google with 1.7M train images and 42k validation images. +- [**SKU-110K**](sku-110k.md): A dataset containing images of densely packed retail products, intended for retail environment object detection. +- [**VisDrone**](visdrone.md): A dataset focusing on drone-based images, containing various object categories like cars, pedestrians, and cyclists. +- [**VOC**](voc.md): PASCAL VOC is a popular object detection dataset with 20 object categories including vehicles, animals, and furniture. +- [**xView**](xview.md): A dataset containing high-resolution satellite imagery, designed for the detection of various object classes in overhead views. ### Adding your own dataset diff --git a/docs/en/datasets/obb/index.md b/docs/en/datasets/obb/index.md index c6f973b9..c2d326a7 100644 --- a/docs/en/datasets/obb/index.md +++ b/docs/en/datasets/obb/index.md @@ -57,7 +57,7 @@ To train a model using these OBB formats: Currently, the following datasets with Oriented Bounding Boxes are supported: -- [**DOTA v2**](./dota-v2.md): DOTA (A Large-scale Dataset for Object Detection in Aerial Images) version 2, emphasizes detection from aerial perspectives and contains oriented bounding boxes with 1.7 million instances and 11,268 images. +- [**DOTA v2**](dota-v2.md): DOTA (A Large-scale Dataset for Object Detection in Aerial Images) version 2, emphasizes detection from aerial perspectives and contains oriented bounding boxes with 1.7 million instances and 11,268 images. ### Incorporating your own OBB dataset diff --git a/docs/en/datasets/pose/index.md b/docs/en/datasets/pose/index.md index aea573fe..a71acad1 100644 --- a/docs/en/datasets/pose/index.md +++ b/docs/en/datasets/pose/index.md @@ -96,7 +96,7 @@ This section outlines the datasets that are compatible with Ultralytics YOLO for - **Keypoints**: 17 keypoints including nose, eyes, ears, shoulders, elbows, wrists, hips, knees, and ankles. - **Usage**: Suitable for training human pose estimation models. - **Additional Notes**: The dataset is rich and diverse, containing over 200k labeled images. -- [Read more about COCO-Pose](./coco.md) +- [Read more about COCO-Pose](coco.md) ### COCO8-Pose @@ -106,7 +106,7 @@ This section outlines the datasets that are compatible with Ultralytics YOLO for - **Keypoints**: 17 keypoints including nose, eyes, ears, shoulders, elbows, wrists, hips, knees, and ankles. - **Usage**: Suitable for testing and debugging object detection models, or for experimenting with new detection approaches. - **Additional Notes**: COCO8-Pose is ideal for sanity checks and CI checks. -- [Read more about COCO8-Pose](./coco8-pose.md) +- [Read more about COCO8-Pose](coco8-pose.md) ### Tiger-Pose @@ -115,7 +115,7 @@ This section outlines the datasets that are compatible with Ultralytics YOLO for - **Number of Classes**: 1 (Tiger). - **Keypoints**: 12 keypoints. - **Usage**: Great for animal pose or any other pose that is not human-based. -- [Read more about Tiger-Pose](./tiger-pose.md) +- [Read more about Tiger-Pose](tiger-pose.md) ### Adding your own dataset diff --git a/docs/en/datasets/segment/index.md b/docs/en/datasets/segment/index.md index eb9497bd..3a3f3b41 100644 --- a/docs/en/datasets/segment/index.md +++ b/docs/en/datasets/segment/index.md @@ -143,6 +143,6 @@ Certainly, here is the table updated with code snippets: | `device` | `str, optional` | Device to run the models on. Defaults to an empty string (CPU or GPU, if available). | `''` | | `output_dir` | `str or None, optional` | Directory to save the annotated results. Defaults to a `'labels'` folder in the same directory as `'data'`. | `None` | -The `auto_annotate` function takes the path to your images, along with optional arguments for specifying the pre-trained detection and [SAM segmentation models](https://docs.ultralytics.com/models/sam), the device to run the models on, and the output directory for saving the annotated results. +The `auto_annotate` function takes the path to your images, along with optional arguments for specifying the pre-trained detection and [SAM segmentation models](../../models/sam.md), the device to run the models on, and the output directory for saving the annotated results. By leveraging the power of pre-trained models, auto-annotation can significantly reduce the time and effort required for creating high-quality segmentation datasets. This feature is particularly useful for researchers and developers working with large image collections, as it allows them to focus on model development and evaluation rather than manual annotation. diff --git a/docs/en/guides/model-deployment-options.md b/docs/en/guides/model-deployment-options.md index dca36d1d..10980448 100644 --- a/docs/en/guides/model-deployment-options.md +++ b/docs/en/guides/model-deployment-options.md @@ -262,21 +262,21 @@ ncnn is a high-performance neural network inference framework optimized for the The following table provides a snapshot of the various deployment options available for YOLOv8 models, helping you to assess which may best fit your project needs based on several critical criteria. For an in-depth look at each deployment option's format, please see the [Ultralytics documentation page on export formats](https://docs.ultralytics.com/modes/export/#export-formats). -| Deployment Option | Performance Benchmarks | Compatibility and Integration | Community Support and Ecosystem | Case Studies | Maintenance and Updates | Security Considerations | Hardware Acceleration | -|--------------------|------------------------|-------------------------------|--------------------------------|--------------|------------------------|-------------------------|-----------------------| -| PyTorch | Good flexibility; may trade off raw performance | Excellent with Python libraries | Extensive resources and community | Research and prototypes | Regular, active development | Dependent on deployment environment | CUDA support for GPU acceleration | -| TorchScript | Better for production than PyTorch | Smooth transition from PyTorch to C++ | Specialized but narrower than PyTorch | Industry where Python is a bottleneck | Consistent updates with PyTorch | Improved security without full Python | Inherits CUDA support from PyTorch | -| ONNX | Variable depending on runtime | High across different frameworks | Broad ecosystem, supported by many orgs | Flexibility across ML frameworks | Regular updates for new operations | Ensure secure conversion and deployment practices | Various hardware optimizations | -| OpenVINO | Optimized for Intel hardware | Best within Intel ecosystem | Solid in computer vision domain | IoT and edge with Intel hardware | Regular updates for Intel hardware | Robust features for sensitive applications | Tailored for Intel hardware | -| TensorRT | Top-tier on NVIDIA GPUs | Best for NVIDIA hardware | Strong network through NVIDIA | Real-time video and image inference | Frequent updates for new GPUs | Emphasis on security | Designed for NVIDIA GPUs | -| CoreML | Optimized for on-device Apple hardware | Exclusive to Apple ecosystem | Strong Apple and developer support | On-device ML on Apple products | Regular Apple updates | Focus on privacy and security | Apple neural engine and GPU | -| TF SavedModel | Scalable in server environments | Wide compatibility in TensorFlow ecosystem | Large support due to TensorFlow popularity | Serving models at scale | Regular updates by Google and community | Robust features for enterprise | Various hardware accelerations | -| TF GraphDef | Stable for static computation graphs | Integrates well with TensorFlow infrastructure | Resources for optimizing static graphs | Scenarios requiring static graphs | Updates alongside TensorFlow core | Established TensorFlow security practices | TensorFlow acceleration options | -| TF Lite | Speed and efficiency on mobile/embedded | Wide range of device support | Robust community, Google backed | Mobile applications with minimal footprint | Latest features for mobile | Secure environment on end-user devices | GPU and DSP among others | -| TF Edge TPU | Optimized for Google's Edge TPU hardware | Exclusive to Edge TPU devices | Growing with Google and third-party resources | IoT devices requiring real-time processing | Improvements for new Edge TPU hardware | Google's robust IoT security | Custom-designed for Google Coral | -| TF.js | Reasonable in-browser performance | High with web technologies | Web and Node.js developers support | Interactive web applications | TensorFlow team and community contributions | Web platform security model | Enhanced with WebGL and other APIs | -| PaddlePaddle | Competitive, easy to use and scalable | Baidu ecosystem, wide application support | Rapidly growing, especially in China | Chinese market and language processing | Focus on Chinese AI applications | Emphasizes data privacy and security | Including Baidu's Kunlun chips | -| ncnn | Optimized for mobile ARM-based devices | Mobile and embedded ARM systems | Niche but active mobile/embedded ML community | Android and ARM systems efficiency | High performance maintenance on ARM | On-device security advantages | ARM CPUs and GPUs optimizations | +| Deployment Option | Performance Benchmarks | Compatibility and Integration | Community Support and Ecosystem | Case Studies | Maintenance and Updates | Security Considerations | Hardware Acceleration | +|-------------------|-------------------------------------------------|------------------------------------------------|-----------------------------------------------|--------------------------------------------|---------------------------------------------|---------------------------------------------------|------------------------------------| +| PyTorch | Good flexibility; may trade off raw performance | Excellent with Python libraries | Extensive resources and community | Research and prototypes | Regular, active development | Dependent on deployment environment | CUDA support for GPU acceleration | +| TorchScript | Better for production than PyTorch | Smooth transition from PyTorch to C++ | Specialized but narrower than PyTorch | Industry where Python is a bottleneck | Consistent updates with PyTorch | Improved security without full Python | Inherits CUDA support from PyTorch | +| ONNX | Variable depending on runtime | High across different frameworks | Broad ecosystem, supported by many orgs | Flexibility across ML frameworks | Regular updates for new operations | Ensure secure conversion and deployment practices | Various hardware optimizations | +| OpenVINO | Optimized for Intel hardware | Best within Intel ecosystem | Solid in computer vision domain | IoT and edge with Intel hardware | Regular updates for Intel hardware | Robust features for sensitive applications | Tailored for Intel hardware | +| TensorRT | Top-tier on NVIDIA GPUs | Best for NVIDIA hardware | Strong network through NVIDIA | Real-time video and image inference | Frequent updates for new GPUs | Emphasis on security | Designed for NVIDIA GPUs | +| CoreML | Optimized for on-device Apple hardware | Exclusive to Apple ecosystem | Strong Apple and developer support | On-device ML on Apple products | Regular Apple updates | Focus on privacy and security | Apple neural engine and GPU | +| TF SavedModel | Scalable in server environments | Wide compatibility in TensorFlow ecosystem | Large support due to TensorFlow popularity | Serving models at scale | Regular updates by Google and community | Robust features for enterprise | Various hardware accelerations | +| TF GraphDef | Stable for static computation graphs | Integrates well with TensorFlow infrastructure | Resources for optimizing static graphs | Scenarios requiring static graphs | Updates alongside TensorFlow core | Established TensorFlow security practices | TensorFlow acceleration options | +| TF Lite | Speed and efficiency on mobile/embedded | Wide range of device support | Robust community, Google backed | Mobile applications with minimal footprint | Latest features for mobile | Secure environment on end-user devices | GPU and DSP among others | +| TF Edge TPU | Optimized for Google's Edge TPU hardware | Exclusive to Edge TPU devices | Growing with Google and third-party resources | IoT devices requiring real-time processing | Improvements for new Edge TPU hardware | Google's robust IoT security | Custom-designed for Google Coral | +| TF.js | Reasonable in-browser performance | High with web technologies | Web and Node.js developers support | Interactive web applications | TensorFlow team and community contributions | Web platform security model | Enhanced with WebGL and other APIs | +| PaddlePaddle | Competitive, easy to use and scalable | Baidu ecosystem, wide application support | Rapidly growing, especially in China | Chinese market and language processing | Focus on Chinese AI applications | Emphasizes data privacy and security | Including Baidu's Kunlun chips | +| ncnn | Optimized for mobile ARM-based devices | Mobile and embedded ARM systems | Niche but active mobile/embedded ML community | Android and ARM systems efficiency | High performance maintenance on ARM | On-device security advantages | ARM CPUs and GPUs optimizations | This comparative analysis gives you a high-level overview. For deployment, it's essential to consider the specific requirements and constraints of your project, and consult the detailed documentation and resources available for each option. diff --git a/docs/en/hub/app/index.md b/docs/en/hub/app/index.md index 0f12bacc..464c5ffc 100644 --- a/docs/en/hub/app/index.md +++ b/docs/en/hub/app/index.md @@ -42,7 +42,7 @@ Welcome to the Ultralytics HUB App! We are excited to introduce this powerful mo ## App Documentation -- [**iOS**](./ios.md): Learn about YOLO CoreML models accelerated on Apple's Neural Engine for iPhones and iPads. -- [**Android**](./android.md): Explore TFLite acceleration on Android mobile devices. +- [**iOS**](ios.md): Learn about YOLO CoreML models accelerated on Apple's Neural Engine for iPhones and iPads. +- [**Android**](android.md): Explore TFLite acceleration on Android mobile devices. Get started today by downloading the Ultralytics HUB App on your mobile device and unlock the potential of YOLOv5 and YOLOv8 models on-the-go. Don't forget to check out our comprehensive [HUB Docs](../index.md) for more information on training, deploying, and using your custom models with the Ultralytics HUB platform. diff --git a/docs/en/hub/index.md b/docs/en/hub/index.md index 01ab1075..9eedc724 100644 --- a/docs/en/hub/index.md +++ b/docs/en/hub/index.md @@ -50,12 +50,12 @@ HUB is designed to be user-friendly and intuitive, with a drag-and-drop interfac We hope that the resources here will help you get the most out of HUB. Please browse the HUB Docs for details, raise an issue on GitHub for support, and join our Discord community for questions and discussions! -- [**Quickstart**](./quickstart.md). Start training and deploying YOLO models with HUB in seconds. -- [**Datasets: Preparing and Uploading**](./datasets.md). Learn how to prepare and upload your datasets to HUB in YOLO format. -- [**Projects: Creating and Managing**](./projects.md). Group your models into projects for improved organization. -- [**Models: Training and Exporting**](./models.md). Train YOLOv5 and YOLOv8 models on your custom datasets and export them to various formats for deployment. -- [**Integrations: Options**](./integrations.md). Explore different integration options for your trained models, such as TensorFlow, ONNX, OpenVINO, CoreML, and PaddlePaddle. -- [**Ultralytics HUB App**](./app/index.md). Learn about the Ultralytics App for iOS and Android, which allows you to run models directly on your mobile device. - * [**iOS**](./app/ios.md). Learn about YOLO CoreML models accelerated on Apple's Neural Engine on iPhones and iPads. - * [**Android**](./app/android.md). Explore TFLite acceleration on mobile devices. -- [**Inference API**](./inference_api.md). Understand how to use the Inference API for running your trained models in the cloud to generate predictions. +- [**Quickstart**](quickstart.md). Start training and deploying YOLO models with HUB in seconds. +- [**Datasets: Preparing and Uploading**](datasets.md). Learn how to prepare and upload your datasets to HUB in YOLO format. +- [**Projects: Creating and Managing**](projects.md). Group your models into projects for improved organization. +- [**Models: Training and Exporting**](models.md). Train YOLOv5 and YOLOv8 models on your custom datasets and export them to various formats for deployment. +- [**Integrations: Options**](integrations.md). Explore different integration options for your trained models, such as TensorFlow, ONNX, OpenVINO, CoreML, and PaddlePaddle. +- [**Ultralytics HUB App**](app/index.md). Learn about the Ultralytics App for iOS and Android, which allows you to run models directly on your mobile device. + * [**iOS**](app/ios.md). Learn about YOLO CoreML models accelerated on Apple's Neural Engine on iPhones and iPads. + * [**Android**](app/android.md). Explore TFLite acceleration on mobile devices. +- [**Inference API**](inference_api.md). Understand how to use the Inference API for running your trained models in the cloud to generate predictions. diff --git a/docs/en/hub/models.md b/docs/en/hub/models.md index a302cd3e..65b7880c 100644 --- a/docs/en/hub/models.md +++ b/docs/en/hub/models.md @@ -128,7 +128,7 @@ You can also use our Ultralytics Cloud API to effortlessly [run inference](https ![Ultralytics HUB screenshot of the Preview tab (Ultralytics Cloud API card) inside the Model page](https://raw.githubusercontent.com/ultralytics/assets/main/docs/hub/models/hub_preview_model_2.jpg) -Furthermore, you can preview your model in real-time directly on your [iOS](https://apps.apple.com/xk/app/ultralytics/id1583935240) or [Android](https://play.google.com/store/apps/details?id=com.ultralytics.ultralytics_app) mobile device by [downloading](https://ultralytics.com/app_install) our [Ultralytics HUB Mobile Application](./app/index.md). +Furthermore, you can preview your model in real-time directly on your [iOS](https://apps.apple.com/xk/app/ultralytics/id1583935240) or [Android](https://play.google.com/store/apps/details?id=com.ultralytics.ultralytics_app) mobile device by [downloading](https://ultralytics.com/app_install) our [Ultralytics HUB Mobile Application](app/index.md). ![Ultralytics HUB screenshot of the Deploy tab inside the Model page with arrow pointing to the Real-Time Preview card](https://raw.githubusercontent.com/ultralytics/assets/main/docs/hub/models/hub_preview_model_3.jpg) diff --git a/docs/en/models/index.md b/docs/en/models/index.md index e67f5d61..83110d1c 100644 --- a/docs/en/models/index.md +++ b/docs/en/models/index.md @@ -12,17 +12,17 @@ Welcome to Ultralytics' model documentation! We offer support for a wide range o Here are some of the key models supported: -1. **[YOLOv3](./yolov3.md)**: The third iteration of the YOLO model family, originally by Joseph Redmon, known for its efficient real-time object detection capabilities. -2. **[YOLOv4](./yolov4.md)**: A darknet-native update to YOLOv3, released by Alexey Bochkovskiy in 2020. -3. **[YOLOv5](./yolov5.md)**: An improved version of the YOLO architecture by Ultralytics, offering better performance and speed trade-offs compared to previous versions. -4. **[YOLOv6](./yolov6.md)**: Released by [Meituan](https://about.meituan.com/) in 2022, and in use in many of the company's autonomous delivery robots. -5. **[YOLOv7](./yolov7.md)**: Updated YOLO models released in 2022 by the authors of YOLOv4. -6. **[YOLOv8](./yolov8.md)**: The latest version of the YOLO family, featuring enhanced capabilities such as instance segmentation, pose/keypoints estimation, and classification. -7. **[Segment Anything Model (SAM)](./sam.md)**: Meta's Segment Anything Model (SAM). -8. **[Mobile Segment Anything Model (MobileSAM)](./mobile-sam.md)**: MobileSAM for mobile applications, by Kyung Hee University. -9. **[Fast Segment Anything Model (FastSAM)](./fast-sam.md)**: FastSAM by Image & Video Analysis Group, Institute of Automation, Chinese Academy of Sciences. -10. **[YOLO-NAS](./yolo-nas.md)**: YOLO Neural Architecture Search (NAS) Models. -11. **[Realtime Detection Transformers (RT-DETR)](./rtdetr.md)**: Baidu's PaddlePaddle Realtime Detection Transformer (RT-DETR) models. +1. **[YOLOv3](yolov3.md)**: The third iteration of the YOLO model family, originally by Joseph Redmon, known for its efficient real-time object detection capabilities. +2. **[YOLOv4](yolov4.md)**: A darknet-native update to YOLOv3, released by Alexey Bochkovskiy in 2020. +3. **[YOLOv5](yolov5.md)**: An improved version of the YOLO architecture by Ultralytics, offering better performance and speed trade-offs compared to previous versions. +4. **[YOLOv6](yolov6.md)**: Released by [Meituan](https://about.meituan.com/) in 2022, and in use in many of the company's autonomous delivery robots. +5. **[YOLOv7](yolov7.md)**: Updated YOLO models released in 2022 by the authors of YOLOv4. +6. **[YOLOv8](yolov8.md)**: The latest version of the YOLO family, featuring enhanced capabilities such as instance segmentation, pose/keypoints estimation, and classification. +7. **[Segment Anything Model (SAM)](sam.md)**: Meta's Segment Anything Model (SAM). +8. **[Mobile Segment Anything Model (MobileSAM)](mobile-sam.md)**: MobileSAM for mobile applications, by Kyung Hee University. +9. **[Fast Segment Anything Model (FastSAM)](fast-sam.md)**: FastSAM by Image & Video Analysis Group, Institute of Automation, Chinese Academy of Sciences. +10. **[YOLO-NAS](yolo-nas.md)**: YOLO Neural Architecture Search (NAS) Models. +11. **[Realtime Detection Transformers (RT-DETR)](rtdetr.md)**: Baidu's PaddlePaddle Realtime Detection Transformer (RT-DETR) models.


diff --git a/docs/en/models/mobile-sam.md b/docs/en/models/mobile-sam.md index be753c29..d9e315a4 100644 --- a/docs/en/models/mobile-sam.md +++ b/docs/en/models/mobile-sam.md @@ -89,7 +89,7 @@ You can download the model [here](https://github.com/ChaoningZhang/MobileSAM/blo model.predict('ultralytics/assets/zidane.jpg', bboxes=[439, 437, 524, 709]) ``` -We have implemented `MobileSAM` and `SAM` using the same API. For more usage information, please see the [SAM page](./sam.md). +We have implemented `MobileSAM` and `SAM` using the same API. For more usage information, please see the [SAM page](sam.md). ## Citations and Acknowledgements diff --git a/docs/en/models/yolov4.md b/docs/en/models/yolov4.md index 1af7ccdb..c2f4cabd 100644 --- a/docs/en/models/yolov4.md +++ b/docs/en/models/yolov4.md @@ -13,7 +13,7 @@ Welcome to the Ultralytics documentation page for YOLOv4, a state-of-the-art, re ## Introduction -YOLOv4 stands for You Only Look Once version 4. It is a real-time object detection model developed to address the limitations of previous YOLO versions like [YOLOv3](./yolov3.md) and other object detection models. Unlike other convolutional neural network (CNN) based object detectors, YOLOv4 is not only applicable for recommendation systems but also for standalone process management and human input reduction. Its operation on conventional graphics processing units (GPUs) allows for mass usage at an affordable price, and it is designed to work in real-time on a conventional GPU while requiring only one such GPU for training. +YOLOv4 stands for You Only Look Once version 4. It is a real-time object detection model developed to address the limitations of previous YOLO versions like [YOLOv3](yolov3.md) and other object detection models. Unlike other convolutional neural network (CNN) based object detectors, YOLOv4 is not only applicable for recommendation systems but also for standalone process management and human input reduction. Its operation on conventional graphics processing units (GPUs) allows for mass usage at an affordable price, and it is designed to work in real-time on a conventional GPU while requiring only one such GPU for training. ## Architecture diff --git a/docs/en/models/yolov5.md b/docs/en/models/yolov5.md index e20b9b88..96954e6a 100644 --- a/docs/en/models/yolov5.md +++ b/docs/en/models/yolov5.md @@ -8,7 +8,7 @@ keywords: YOLOv5u, object detection, pre-trained models, Ultralytics, Inference, ## Overview -YOLOv5u represents an advancement in object detection methodologies. Originating from the foundational architecture of the [YOLOv5](https://github.com/ultralytics/yolov5) model developed by Ultralytics, YOLOv5u integrates the anchor-free, objectness-free split head, a feature previously introduced in the [YOLOv8](./yolov8.md) models. This adaptation refines the model's architecture, leading to an improved accuracy-speed tradeoff in object detection tasks. Given the empirical results and its derived features, YOLOv5u provides an efficient alternative for those seeking robust solutions in both research and practical applications. +YOLOv5u represents an advancement in object detection methodologies. Originating from the foundational architecture of the [YOLOv5](https://github.com/ultralytics/yolov5) model developed by Ultralytics, YOLOv5u integrates the anchor-free, objectness-free split head, a feature previously introduced in the [YOLOv8](yolov8.md) models. This adaptation refines the model's architecture, leading to an improved accuracy-speed tradeoff in object detection tasks. Given the empirical results and its derived features, YOLOv5u provides an efficient alternative for those seeking robust solutions in both research and practical applications. ![Ultralytics YOLOv5](https://raw.githubusercontent.com/ultralytics/assets/main/yolov5/v70/splash.png) diff --git a/docs/en/robots.txt b/docs/en/robots.txt index e43dbf99..6794e596 100644 --- a/docs/en/robots.txt +++ b/docs/en/robots.txt @@ -1,3 +1,10 @@ User-agent: * Sitemap: http://docs.ultralytics.com/sitemap.xml +Sitemap: http://docs.ultralytics.com/de/sitemap.xml +Sitemap: http://docs.ultralytics.com/es/sitemap.xml +Sitemap: http://docs.ultralytics.com/fr/sitemap.xml +Sitemap: http://docs.ultralytics.com/ja/sitemap.xml +Sitemap: http://docs.ultralytics.com/ko/sitemap.xml +Sitemap: http://docs.ultralytics.com/pt/sitemap.xml +Sitemap: http://docs.ultralytics.com/ru/sitemap.xml Sitemap: http://docs.ultralytics.com/zh/sitemap.xml diff --git a/docs/en/usage/cli.md b/docs/en/usage/cli.md index d33156c1..1851d728 100644 --- a/docs/en/usage/cli.md +++ b/docs/en/usage/cli.md @@ -31,7 +31,7 @@ The YOLO command line interface (CLI) allows for simple single-line commands wit MODE (required) is one of [train, val, predict, export, track] ARGS (optional) are any number of custom 'arg=value' pairs like 'imgsz=320' that override defaults. ``` - See all ARGS in the full [Configuration Guide](./cfg.md) or with `yolo cfg` + See all ARGS in the full [Configuration Guide](cfg.md) or with `yolo cfg` === "Train" diff --git a/docs/es/datasets/index.md b/docs/es/datasets/index.md new file mode 100644 index 00000000..5cc6fda6 --- /dev/null +++ b/docs/es/datasets/index.md @@ -0,0 +1,127 @@ +--- +comments: true +description: Explore diferentes conjuntos de datos de visión por computadora soportados por Ultralytics para la detección de objetos, segmentación, estimación de poses, clasificación de imágenes y seguimiento de múltiples objetos. +keywords: visión por computadora, conjuntos de datos, Ultralytics, YOLO, detección de objetos, segmentación de instancias, estimación de poses, clasificación de imágenes, seguimiento de múltiples objetos +--- + +# Resumen de Conjuntos de Datos + +Ultralytics brinda soporte para varios conjuntos de datos para facilitar tareas de visión por computadora como detección, segmentación de instancias, estimación de poses, clasificación y seguimiento de múltiples objetos. A continuación se presenta una lista de los principales conjuntos de datos de Ultralytics, seguido por un resumen de cada tarea de visión por computadora y los respectivos conjuntos de datos. + +!!! note + + 🚧 Nuestra documentación multilingüe está actualmente en construcción y estamos trabajando arduamente para mejorarla. ¡Gracias por su paciencia! 🙏 + +## [Conjuntos de Datos de Detección](../../datasets/detect/index.md) + +La detección de objetos con cuadros delimitadores es una técnica de visión por computadora que implica detectar y localizar objetos en una imagen dibujando un cuadro alrededor de cada objeto. + +- [Argoverse](../../datasets/detect/argoverse.md): Un conjunto de datos que contiene datos de seguimiento en 3D y predicción de movimientos en entornos urbanos con anotaciones detalladas. +- [COCO](../../datasets/detect/coco.md): Un conjunto de datos a gran escala diseñado para detección de objetos, segmentación y subtitulado con más de 200 mil imágenes etiquetadas. +- [COCO8](../../datasets/detect/coco8.md): Contiene las primeras 4 imágenes de COCO train y COCO val, adecuado para pruebas rápidas. +- [Global Wheat 2020](../../datasets/detect/globalwheat2020.md): Un conjunto de datos de imágenes de cabezas de trigo recolectadas alrededor del mundo para tareas de detección y localización de objetos. +- [Objects365](../../datasets/detect/objects365.md): Un conjunto de datos a gran escala y de alta calidad para la detección de objetos con 365 categorías y más de 600 mil imágenes anotadas. +- [OpenImagesV7](../../datasets/detect/open-images-v7.md): Un conjunto de datos completo de Google con 1.7 millones de imágenes de entrenamiento y 42 mil imágenes de validación. +- [SKU-110K](../../datasets/detect/sku-110k.md): Un conjunto de datos que presenta detección de objetos densa en entornos minoristas con más de 11 mil imágenes y 1.7 millones de cuadros delimitadores. +- [VisDrone](../../datasets/detect/visdrone.md): Un conjunto de datos que contiene datos de detección de objetos y seguimiento de múltiples objetos de imágenes capturadas por drones con más de 10 mil imágenes y secuencias de video. +- [VOC](../../datasets/detect/voc.md): El conjunto de datos de Clases de Objetos Visuales de Pascal (VOC) para la detección de objetos y segmentación con 20 clases de objetos y más de 11 mil imágenes. +- [xView](../../datasets/detect/xview.md): Un conjunto de datos para la detección de objetos en imágenes aéreas con 60 categorías de objetos y más de un millón de objetos anotados. + +## [Conjuntos de Datos de Segmentación de Instancias](../../datasets/segment/index.md) + +La segmentación de instancias es una técnica de visión por computadora que implica identificar y localizar objetos en una imagen a nivel de píxel. + +- [COCO](../../datasets/segment/coco.md): Un conjunto de datos a gran escala diseñado para tareas de detección de objetos, segmentación y subtitulado con más de 200 mil imágenes etiquetadas. +- [COCO8-seg](../../datasets/segment/coco8-seg.md): Un conjunto de datos más pequeño para tareas de segmentación de instancias, que contiene un subconjunto de 8 imágenes de COCO con anotaciones de segmentación. + +## [Estimación de Poses](../../datasets/pose/index.md) + +La estimación de poses es una técnica utilizada para determinar la pose del objeto en relación con la cámara o el sistema de coordenadas del mundo. + +- [COCO](../../datasets/pose/coco.md): Un conjunto de datos a gran escala con anotaciones de pose humana diseñado para tareas de estimación de poses. +- [COCO8-pose](../../datasets/pose/coco8-pose.md): Un conjunto de datos más pequeño para tareas de estimación de poses, que contiene un subconjunto de 8 imágenes de COCO con anotaciones de pose humana. +- [Tiger-pose](../../datasets/pose/tiger-pose.md): Un conjunto de datos compacto que consiste en 263 imágenes centradas en tigres, anotadas con 12 puntos clave por tigre para tareas de estimación de poses. + +## [Clasificación](../../datasets/classify/index.md) + +La clasificación de imágenes es una tarea de visión por computadora que implica categorizar una imagen en una o más clases o categorías predefinidas basadas en su contenido visual. + +- [Caltech 101](../../datasets/classify/caltech101.md): Un conjunto de datos que contiene imágenes de 101 categorías de objetos para tareas de clasificación de imágenes. +- [Caltech 256](../../datasets/classify/caltech256.md): Una versión extendida de Caltech 101 con 256 categorías de objetos y imágenes más desafiantes. +- [CIFAR-10](../../datasets/classify/cifar10.md): Un conjunto de datos de 60 mil imágenes a color de 32x32 en 10 clases, con 6 mil imágenes por clase. +- [CIFAR-100](../../datasets/classify/cifar100.md): Una versión extendida de CIFAR-10 con 100 categorías de objetos y 600 imágenes por clase. +- [Fashion-MNIST](../../datasets/classify/fashion-mnist.md): Un conjunto de datos compuesto por 70 mil imágenes en escala de grises de 10 categorías de moda para tareas de clasificación de imágenes. +- [ImageNet](../../datasets/classify/imagenet.md): Un conjunto de datos a gran escala para detección de objetos y clasificación de imágenes con más de 14 millones de imágenes y 20 mil categorías. +- [ImageNet-10](../../datasets/classify/imagenet10.md): Un subconjunto más pequeño de ImageNet con 10 categorías para experimentación y pruebas más rápidas. +- [Imagenette](../../datasets/classify/imagenette.md): Un subconjunto más pequeño de ImageNet que contiene 10 clases fácilmente distinguibles para entrenamientos y pruebas más rápidos. +- [Imagewoof](../../datasets/classify/imagewoof.md): Un subconjunto más desafiante de ImageNet que contiene 10 categorías de razas de perros para tareas de clasificación de imágenes. +- [MNIST](../../datasets/classify/mnist.md): Un conjunto de datos de 70 mil imágenes en escala de grises de dígitos escritos a mano para tareas de clasificación de imágenes. + +## [Cuadros Delimitadores Orientados (OBB)](../../datasets/obb/index.md) + +Los Cuadros Delimitadores Orientados (OBB) es un método en visión por computadora para detectar objetos angulados en imágenes utilizando cuadros delimitadores rotados, a menudo aplicado en imágenes aéreas y satelitales. + +- [DOTAv2](../../datasets/obb/dota-v2.md): Un popular conjunto de datos de imágenes aéreas de OBB con 1.7 millones de instancias y 11,268 imágenes. + +## [Seguimiento de Múltiples Objetos](../../datasets/track/index.md) + +El seguimiento de múltiples objetos es una técnica de visión por computadora que implica detectar y seguir múltiples objetos a lo largo del tiempo en una secuencia de video. + +- [Argoverse](../../datasets/detect/argoverse.md): Un conjunto de datos que contiene datos de seguimiento en 3D y predicción de movimientos en entornos urbanos con anotaciones detalladas para tareas de seguimiento de múltiples objetos. +- [VisDrone](../../datasets/detect/visdrone.md): Un conjunto de datos que contiene datos de detección de objetos y seguimiento de múltiples objetos de imágenes capturadas por drones con más de 10 mil imágenes y secuencias de video. + +## Contribuir con Nuevos Conjuntos de Datos + +Contribuir con un nuevo conjunto de datos implica varios pasos para garantizar que se alinee bien con la infraestructura existente. A continuación, se presentan los pasos necesarios: + +### Pasos para Contribuir con un Nuevo Conjunto de Datos + +1. **Recolectar Imágenes**: Reúne las imágenes que pertenecen al conjunto de datos. Estas podrían ser recopiladas de varias fuentes, tales como bases de datos públicas o tu propia colección. + +2. **Annotar Imágenes**: Anota estas imágenes con cuadros delimitadores, segmentos o puntos clave, dependiendo de la tarea. + +3. **Exportar Anotaciones**: Convierte estas anotaciones en el formato de archivo *.txt de YOLO que Ultralytics soporta. + +4. **Organizar Conjunto de Datos**: Organiza tu conjunto de datos en la estructura de carpetas correcta. Deberías tener directorios de nivel superior `train/` y `val/`, y dentro de cada uno, un subdirectorio `images/` y `labels/`. + + ``` + dataset/ + ├── train/ + │ ├── images/ + │ └── labels/ + └── val/ + ├── images/ + └── labels/ + ``` + +5. **Crear un Archivo `data.yaml`**: En el directorio raíz de tu conjunto de datos, crea un archivo `data.yaml` que describa el conjunto de datos, clases y otra información necesaria. + +6. **Optimizar Imágenes (Opcional)**: Si deseas reducir el tamaño del conjunto de datos para un procesamiento más eficiente, puedes optimizar las imágenes usando el código a continuación. Esto no es requerido, pero se recomienda para tamaños de conjuntos de datos más pequeños y velocidades de descarga más rápidas. + +7. **Comprimir Conjunto de Datos**: Comprime toda la carpeta del conjunto de datos en un archivo .zip. + +8. **Documentar y PR**: Crea una página de documentación describiendo tu conjunto de datos y cómo encaja en el marco existente. Después de eso, envía una Solicitud de Extracción (PR). Consulta las [Pautas de Contribución de Ultralytics](https://docs.ultralytics.com/help/contributing) para obtener más detalles sobre cómo enviar una PR. + +### Código de Ejemplo para Optimizar y Comprimir un Conjunto de Datos + +!!! example "Optimizar y Comprimir un Conjunto de Datos" + + === "Python" + + ```python + from pathlib import Path + from ultralytics.data.utils import compress_one_image + from ultralytics.utils.downloads import zip_directory + + # Definir el directorio del conjunto de datos + path = Path('ruta/al/conjunto-de-datos') + + # Optimizar imágenes en el conjunto de datos (opcional) + for f in path.rglob('*.jpg'): + compress_one_image(f) + + # Comprimir el conjunto de datos en 'ruta/al/conjunto-de-datos.zip' + zip_directory(path) + ``` + +Siguiendo estos pasos, puedes contribuir con un nuevo conjunto de datos que se integre bien con la estructura existente de Ultralytics. diff --git a/docs/es/index.md b/docs/es/index.md new file mode 100644 index 00000000..0d338d08 --- /dev/null +++ b/docs/es/index.md @@ -0,0 +1,82 @@ +--- +comments: true +description: Explore una guía completa sobre Ultralytics YOLOv8, un modelo de alta velocidad y precisión para detección de objetos y segmentación de imágenes. Tutoriales de instalación, predicción, entrenamiento y más. +keywords: Ultralytics, YOLOv8, detección de objetos, segmentación de imágenes, aprendizaje automático, aprendizaje profundo, visión por computadora, instalación YOLOv8, predicción YOLOv8, entrenamiento YOLOv8, historia de YOLO, licencias YOLO +--- + +

+

+ + Banner de Ultralytics YOLO +

+ GitHub de Ultralytics + + LinkedIn de Ultralytics + + Twitter de Ultralytics + + YouTube de Ultralytics + + TikTok de Ultralytics + + Instagram de Ultralytics + + Discord de Ultralytics +
+
+ Integración continua de Ultralytics + Cobertura de código de Ultralytics + Cita de YOLOv8 + Descargas de Docker +
+ Ejecutar en Gradient + Abrir en Colab + Abrir en Kaggle +
+ +Presentamos [Ultralytics](https://ultralytics.com) [YOLOv8](https://github.com/ultralytics/ultralytics), la última versión del aclamado modelo para detección de objetos y segmentación de imágenes en tiempo real. YOLOv8 está construido sobre avances de vanguardia en aprendizaje profundo y visión por computadora, ofreciendo un rendimiento sin paralelo en términos de velocidad y precisión. Su diseño simplificado lo hace adecuado para varias aplicaciones y fácilmente adaptable a diferentes plataformas de hardware, desde dispositivos de borde hasta API en la nube. + +Explore los documentos de YOLOv8, un recurso integral diseñado para ayudarle a comprender y utilizar sus características y capacidades. Independientemente de que sea un practicante experimentado en aprendizaje automático o nuevo en el campo, este centro tiene como objetivo maximizar el potencial de YOLOv8 en sus proyectos. + +!!! note + + 🚧 Nuestra documentación en varios idiomas está actualmente en construcción y estamos trabajando duro para mejorarla. ¡Gracias por su paciencia! 🙏 + +## Dónde empezar + +- **Instalar** `ultralytics` con pip y comenzar a funcionar en minutos   [:material-clock-fast: Comenzar](quickstart.md){ .md-button } +- **Predecir** nuevas imágenes y videos con YOLOv8   [:octicons-image-16: Predecir en Imágenes](modes/predict.md){ .md-button } +- **Entrenar** un nuevo modelo YOLOv8 en su propio conjunto de datos personalizado   [:fontawesome-solid-brain: Entrenar un Modelo](modes/train.md){ .md-button } +- **Explorar** tareas de YOLOv8 como segmentar, clasificar, posar y seguir   [:material-magnify-expand: Explorar Tareas](tasks/index.md){ .md-button } + +

+
+ +
+ Ver: Cómo entrenar un modelo YOLOv8 en Su Conjunto de Datos Personalizado en Google Colab. +

+ +## YOLO: Una Breve Historia + +[YOLO](https://arxiv.org/abs/1506.02640) (You Only Look Once), un modelo popular de detección de objetos y segmentación de imágenes, fue desarrollado por Joseph Redmon y Ali Farhadi en la Universidad de Washington. Lanzado en 2015, YOLO rápidamente ganó popularidad por su alta velocidad y precisión. + +- [YOLOv2](https://arxiv.org/abs/1612.08242), lanzado en 2016, mejoró el modelo original incorporando normalización por lotes, cajas ancla y clústeres de dimensiones. +- [YOLOv3](https://pjreddie.com/media/files/papers/YOLOv3.pdf), lanzado en 2018, mejoró aún más el rendimiento del modelo usando una red dorsal más eficiente, múltiples anclas y agrupación piramidal espacial. +- [YOLOv4](https://arxiv.org/abs/2004.10934) fue lanzado en 2020, introduciendo innovaciones como la ampliación de datos del mosaico, un nuevo cabezal de detección sin ancla y una nueva función de pérdida. +- [YOLOv5](https://github.com/ultralytics/yolov5) mejoró aún más el rendimiento del modelo y agregó nuevas características como la optimización de hiperparámetros, seguimiento de experimentos integrados y exportación automática a formatos de exportación populares. +- [YOLOv6](https://github.com/meituan/YOLOv6) fue publicado en código abierto por [Meituan](https://about.meituan.com/) en 2022 y se utiliza en muchos de los robots de entrega autónomos de la empresa. +- [YOLOv7](https://github.com/WongKinYiu/yolov7) añadió tareas adicionales como la estimación de posturas en el conjunto de datos COCO keypoints. +- [YOLOv8](https://github.com/ultralytics/ultralytics) es la última versión de YOLO de Ultralytics. Como un modelo de vanguardia y del estado del arte (SOTA), YOLOv8 se basa en el éxito de las versiones anteriores, introduciendo nuevas características y mejoras para obtener un rendimiento mejorado, flexibilidad y eficiencia. YOLOv8 soporta una gama completa de tareas de IA de visión, incluyendo [detección](tasks/detect.md), [segmentación](tasks/segment.md), [estimación de pose](tasks/pose.md), [seguimiento](modes/track.md) y [clasificación](tasks/classify.md). Esta versatilidad permite a los usuarios aprovechar las capacidades de YOLOv8 en una amplia gama de aplicaciones y dominios. + +## Licencias de YOLO: ¿Cómo están licenciados los YOLO de Ultralytics? + +Ultralytics ofrece dos opciones de licencia para acomodar casos de uso diversos: + +- **Licencia AGPL-3.0**: Esta licencia de código abierto aprobada por [OSI](https://opensource.org/licenses/) es ideal para estudiantes y entusiastas, promoviendo la colaboración abierta y el intercambio de conocimiento. Consulte el archivo [LICENSE](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) para obtener más detalles. +- **Licencia Empresarial**: Diseñada para uso comercial, esta licencia permite la integración sin problemas de software de Ultralytics y modelos de IA en bienes y servicios comerciales, eludiendo los requisitos de código abierto de AGPL-3.0. Si su escenario implica la incorporación de nuestras soluciones en una oferta comercial, póngase en contacto a través de [Licencias de Ultralytics](https://ultralytics.com/license). + +Nuestra estrategia de licenciamiento está diseñada para asegurar que cualquier mejora a nuestros proyectos de código abierto se devuelva a la comunidad. Mantenemos los principios del código abierto cerca de nuestros corazones ❤️, y nuestra misión es garantizar que nuestras contribuciones puedan ser utilizadas y ampliadas de formas que sean beneficiosas para todos. diff --git a/docs/es/models/index.md b/docs/es/models/index.md new file mode 100644 index 00000000..1654c6e2 --- /dev/null +++ b/docs/es/models/index.md @@ -0,0 +1,94 @@ +--- +comments: true +description: Explora la amplia gama de modelos de la familia YOLO, SAM, MobileSAM, FastSAM, YOLO-NAS y RT-DETR compatibles con Ultralytics. Comienza con ejemplos de uso tanto para CLI como para Python. +keywords: Ultralytics, documentación, YOLO, SAM, MobileSAM, FastSAM, YOLO-NAS, RT-DETR, modelos, arquitecturas, Python, CLI +--- + +# Modelos soportados por Ultralytics + +¡Bienvenido a la documentación de modelos de Ultralytics! Ofrecemos soporte para una amplia gama de modelos, cada uno adaptado a tareas específicas como [detección de objetos](../tasks/detect.md), [segmentación de instancias](../tasks/segment.md), [clasificación de imágenes](../tasks/classify.md), [estimación de postura](../tasks/pose.md) y [seguimiento de múltiples objetos](../modes/track.md). Si estás interesado en contribuir con tu arquitectura de modelo a Ultralytics, consulta nuestra [Guía de Contribución](../../help/contributing.md). + +!!! note + + 🚧 Nuestra documentación en varios idiomas está actualmente en construcción y estamos trabajando arduamente para mejorarla. ¡Gracias por tu paciencia! 🙏 + +## Modelos Destacados + +Aquí tienes algunos de los modelos clave soportados: + +1. **[YOLOv3](../../models/yolov3.md)**: La tercera iteración de la familia de modelos YOLO, originalmente creada por Joseph Redmon, conocida por su capacidad de detección de objetos en tiempo real de manera eficiente. +2. **[YOLOv4](../../models/yolov4.md)**: Una actualización para la red oscura de YOLOv3, lanzada por Alexey Bochkovskiy en 2020. +3. **[YOLOv5](../../models/yolov5.md)**: Una versión mejorada de la arquitectura YOLO por Ultralytics, que ofrece mejores compensaciones de rendimiento y velocidad en comparación con versiones anteriores. +4. **[YOLOv6](../../models/yolov6.md)**: Lanzado por [Meituan](https://about.meituan.com/) en 2022, y utilizado en muchos de los robots autónomos de entrega de la compañía. +5. **[YOLOv7](../../models/yolov7.md)**: Modelos YOLO actualizados lanzados en 2022 por los autores de YOLOv4. +6. **[YOLOv8](../../models/yolov8.md)**: La última versión de la familia YOLO, que presenta capacidades mejoradas como segmentación de instancias, estimación de postura/puntos clave y clasificación. +7. **[Modelo de Segmentación de Cualquier Cosa (SAM)](../../models/sam.md)**: El Modelo de Segmentación de Cualquier Cosa (SAM) de Meta. +8. **[Modelo de Segmentación de Cualquier Cosa Móvil (MobileSAM)](../../models/mobile-sam.md)**: MobileSAM para aplicaciones móviles, por la Universidad Kyung Hee. +9. **[Modelo de Segmentación de Cualquier Cosa Rápida (FastSAM)](../../models/fast-sam.md)**: FastSAM del Grupo de Análisis de Imágenes y Video, Instituto de Automatización, Academia China de Ciencias. +10. **[YOLO-NAS](../../models/yolo-nas.md)**: Modelos de Búsqueda de Arquitectura Neural de YOLO (NAS). +11. **[Transformadores de Detección en Tiempo Real (RT-DETR)](../../models/rtdetr.md)**: Modelos de Transformadores de Detección en Tiempo Real (RT-DETR) de Baidu PaddlePaddle. + +

+
+ +
+ Mira: Ejecuta modelos YOLO de Ultralytics en solo unas pocas líneas de código. +

+ +## Comenzando: Ejemplos de Uso + +!!! example "" + + === "Python" + + Los modelos preentrenados en PyTorch `*.pt` así como los archivos de configuración `*.yaml` pueden pasarse a las clases `YOLO()`, `SAM()`, `NAS()` y `RTDETR()` para crear una instancia de modelo en Python: + + ```python + from ultralytics import YOLO + + # Cargar un modelo YOLOv8n preentrenado en COCO + modelo = YOLO('yolov8n.pt') + + # Mostrar información del modelo (opcional) + modelo.info() + + # Entrenar el modelo en el conjunto de datos de ejemplo COCO8 durante 100 épocas + resultados = modelo.train(data='coco8.yaml', epochs=100, imgsz=640) + + # Ejecutar inferencia con el modelo YOLOv8n en la imagen 'bus.jpg' + resultados = modelo('path/to/bus.jpg') + ``` + + === "CLI" + + Comandos CLI están disponibles para ejecutar directamente los modelos: + + ```bash + # Cargar un modelo YOLOv8n preentrenado en COCO y entrenarlo en el conjunto de datos de ejemplo COCO8 durante 100 épocas + yolo train model=yolov8n.pt data=coco8.yaml epochs=100 imgsz=640 + + # Cargar un modelo YOLOv8n preentrenado en COCO y ejecutar inferencia en la imagen 'bus.jpg' + yolo predict model=yolov8n.pt source=path/to/bus.jpg + ``` + +## Contribuyendo con Nuevos Modelos + +¿Interesado en contribuir con tu modelo a Ultralytics? ¡Genial! Siempre estamos abiertos a expandir nuestro portafolio de modelos. + +1. **Haz un Fork del Repositorio**: Comienza haciendo un fork del [repositorio de GitHub de Ultralytics](https://github.com/ultralytics/ultralytics). + +2. **Clona tu Fork**: Clona tu fork en tu máquina local y crea una nueva rama para trabajar. + +3. **Implementa tu Modelo**: Añade tu modelo siguiendo los estándares y guías de codificación proporcionados en nuestra [Guía de Contribución](../../help/contributing.md). + +4. **Prueba a Fondo**: Asegúrate de probar tu modelo rigurosamente, tanto de manera aislada como parte del pipeline. + +5. **Crea un Pull Request**: Una vez que estés satisfecho con tu modelo, crea un pull request al repositorio principal para su revisión. + +6. **Revisión de Código y Fusión**: Después de la revisión, si tu modelo cumple con nuestros criterios, se fusionará en el repositorio principal. + +Consulta nuestra [Guía de Contribución](../../help/contributing.md) para los pasos detallados. diff --git a/docs/es/modes/benchmark.md b/docs/es/modes/benchmark.md new file mode 100644 index 00000000..d430ec4b --- /dev/null +++ b/docs/es/modes/benchmark.md @@ -0,0 +1,94 @@ +--- +comments: true +description: Aprenda cómo perfilar la velocidad y exactitud de YOLOv8 en varios formatos de exportación; obtenga perspectivas sobre las métricas mAP50-95, accuracy_top5 y más. +keywords: Ultralytics, YOLOv8, benchmarking, perfilado de velocidad, perfilado de exactitud, mAP50-95, accuracy_top5, ONNX, OpenVINO, TensorRT, formatos de exportación YOLO +--- + +# Model Benchmarking con Ultralytics YOLO + +Ecosistema e integraciones de Ultralytics YOLO + +## Introducción + +Una vez que su modelo está entrenado y validado, el siguiente paso lógico es evaluar su rendimiento en varios escenarios del mundo real. El modo benchmark en Ultralytics YOLOv8 cumple con este propósito proporcionando un marco sólido para valorar la velocidad y exactitud de su modelo a través de una gama de formatos de exportación. + +## ¿Por Qué Es Crucial el Benchmarking? + +- **Decisiones Informadas:** Obtenga perspectivas sobre el equilibrio entre velocidad y precisión. +- **Asignación de Recursos:** Entienda cómo diferentes formatos de exportación se desempeñan en diferentes hardware. +- **Optimización:** Aprenda cuál formato de exportación ofrece el mejor rendimiento para su caso de uso específico. +- **Eficiencia de Costo:** Haga un uso más eficiente de los recursos de hardware basado en los resultados del benchmark. + +### Métricas Clave en el Modo Benchmark + +- **mAP50-95:** Para detección de objetos, segmentación y estimación de pose. +- **accuracy_top5:** Para clasificación de imágenes. +- **Tiempo de Inferencia:** Tiempo tomado para cada imagen en milisegundos. + +### Formatos de Exportación Soportados + +- **ONNX:** Para un rendimiento óptimo de CPU +- **TensorRT:** Para la máxima eficiencia de GPU +- **OpenVINO:** Para la optimización en hardware de Intel +- **CoreML, TensorFlow SavedModel y Más:** Para necesidades de despliegue diversas. + +!!! tip "Consejo" + + * Exporte a ONNX o OpenVINO para acelerar la velocidad de CPU hasta 3 veces. + * Exporte a TensorRT para acelerar la velocidad de GPU hasta 5 veces. + +## Ejemplos de Uso + +Ejecute benchmarks de YOLOv8n en todos los formatos de exportación soportados incluyendo ONNX, TensorRT, etc. Vea la sección de Argumentos a continuación para una lista completa de argumentos de exportación. + +!!! example "" + + === "Python" + + ```python + from ultralytics.utils.benchmarks import benchmark + + # Benchmark en GPU + benchmark(model='yolov8n.pt', data='coco8.yaml', imgsz=640, half=False, device=0) + ``` + === "CLI" + + ```bash + yolo benchmark model=yolov8n.pt data='coco8.yaml' imgsz=640 half=False device=0 + ``` + +## Argumentos + +Argumentos como `model`, `data`, `imgsz`, `half`, `device`, y `verbose` proporcionan a los usuarios la flexibilidad de ajustar los benchmarks a sus necesidades específicas y comparar el rendimiento de diferentes formatos de exportación con facilidad. + +| Clave | Valor | Descripción | +|-----------|---------|----------------------------------------------------------------------------------------------------------| +| `model` | `None` | ruta al archivo del modelo, es decir, yolov8n.pt, yolov8n.yaml | +| `data` | `None` | ruta a YAML que referencia el conjunto de datos de benchmarking (bajo la etiqueta `val`) | +| `imgsz` | `640` | tamaño de imagen como escalar o lista (h, w), es decir, (640, 480) | +| `half` | `False` | cuantificación FP16 | +| `int8` | `False` | cuantificación INT8 | +| `device` | `None` | dispositivo en el que se ejecutará, es decir, dispositivo cuda=0 o dispositivo=0,1,2,3 o dispositivo=cpu | +| `verbose` | `False` | no continuar en caso de error (bool), o umbral de piso de valor (float) | + +## Formatos de Exportación + +Los benchmarks intentarán ejecutarse automáticamente en todos los posibles formatos de exportación a continuación. + +| Formato | Argumento `format` | Modelo | Metadatos | Argumentos | +|--------------------------------------------------------------------|--------------------|---------------------------|-----------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | ✅ | `imgsz`, `half` | + +Vea los detalles completos de `export` en la página [Export](https://docs.ultralytics.com/modes/export/). diff --git a/docs/es/modes/export.md b/docs/es/modes/export.md new file mode 100644 index 00000000..688822dd --- /dev/null +++ b/docs/es/modes/export.md @@ -0,0 +1,108 @@ +--- +comments: true +description: Guía paso a paso sobre cómo exportar sus modelos YOLOv8 a varios formatos como ONNX, TensorRT, CoreML y más para su despliegue. ¡Explora ahora!. +keywords: YOLO, YOLOv8, Ultralytics, Exportación de modelos, ONNX, TensorRT, CoreML, TensorFlow SavedModel, OpenVINO, PyTorch, exportar modelo +--- + +# Exportación de Modelos con Ultralytics YOLO + +Ecosistema de Ultralytics YOLO e integraciones + +## Introducción + +El objetivo final de entrenar un modelo es desplegarlo para aplicaciones en el mundo real. El modo exportación en Ultralytics YOLOv8 ofrece una gama versátil de opciones para exportar tu modelo entrenado a diferentes formatos, haciéndolo desplegable en varias plataformas y dispositivos. Esta guía integral pretende guiarte a través de los matices de la exportación de modelos, mostrando cómo lograr la máxima compatibilidad y rendimiento. + +

+
+ +
+ Ver: Cómo Exportar un Modelo Entrenado Personalizado de Ultralytics YOLOv8 y Ejecutar Inferencia en Vivo en la Webcam. +

+ +## ¿Por Qué Elegir el Modo Exportación de YOLOv8? + +- **Versatilidad:** Exporta a múltiples formatos incluyendo ONNX, TensorRT, CoreML y más. +- **Rendimiento:** Acelera hasta 5 veces la velocidad en GPU con TensorRT y 3 veces en CPU con ONNX o OpenVINO. +- **Compatibilidad:** Hacer que tu modelo sea universalmente desplegable en numerosos entornos de hardware y software. +- **Facilidad de Uso:** Interfaz de línea de comandos simple y API de Python para una exportación de modelos rápida y sencilla. + +### Características Clave del Modo de Exportación + +Aquí tienes algunas de las funcionalidades destacadas: + +- **Exportación con Un Solo Clic:** Comandos simples para exportar a diferentes formatos. +- **Exportación por Lotes:** Exporta modelos capaces de inferencia por lotes. +- **Inferencia Optimizada:** Los modelos exportados están optimizados para tiempos de inferencia más rápidos. +- **Vídeos Tutoriales:** Guías y tutoriales en profundidad para una experiencia de exportación fluida. + +!!! tip "Consejo" + + * Exporta a ONNX u OpenVINO para acelerar la CPU hasta 3 veces. + * Exporta a TensorRT para acelerar la GPU hasta 5 veces. + +## Ejemplos de Uso + +Exporta un modelo YOLOv8n a un formato diferente como ONNX o TensorRT. Consulta la sección Argumentos más abajo para una lista completa de argumentos de exportación. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Carga un modelo + model = YOLO('yolov8n.pt') # carga un modelo oficial + model = YOLO('path/to/best.pt') # carga un modelo entrenado personalizado + + # Exporta el modelo + model.export(format='onnx') + ``` + === "CLI" + + ```bash + yolo export model=yolov8n.pt format=onnx # exporta modelo oficial + yolo export model=path/to/best.pt format=onnx # exporta modelo entrenado personalizado + ``` + +## Argumentos + +Los ajustes de exportación para modelos YOLO se refieren a las diversas configuraciones y opciones utilizadas para guardar o exportar el modelo para su uso en otros entornos o plataformas. Estos ajustes pueden afectar el rendimiento del modelo, su tamaño y su compatibilidad con diferentes sistemas. Algunos ajustes comunes de exportación de YOLO incluyen el formato del archivo del modelo exportado (p. ej., ONNX, TensorFlow SavedModel), el dispositivo en el que se ejecutará el modelo (p. ej., CPU, GPU) y la presencia de características adicionales como máscaras o múltiples etiquetas por caja. Otros factores que pueden afectar el proceso de exportación incluyen la tarea específica para la que se está utilizando el modelo y los requisitos o limitaciones del entorno o plataforma objetivo. Es importante considerar y configurar cuidadosamente estos ajustes para asegurar que el modelo exportado está optimizado para el caso de uso previsto y se pueda utilizar eficazmente en el entorno objetivo. + +| Llave | Valor | Descripción | +|-------------|-----------------|-----------------------------------------------------------------| +| `format` | `'torchscript'` | formato al que exportar | +| `imgsz` | `640` | tamaño de imagen como escalar o lista (h, w), p. ej. (640, 480) | +| `keras` | `False` | usu Keras para la exportación de TF SavedModel | +| `optimize` | `False` | TorchScript: optimizar para móvil | +| `half` | `False` | cuantificación FP16 | +| `int8` | `False` | cuantificación INT8 | +| `dynamic` | `False` | ONNX/TensorRT: ejes dinámicos | +| `simplify` | `False` | ONNX/TensorRT: simplificar modelo | +| `opset` | `None` | ONNX: versión de opset (opcional, por defecto la más reciente) | +| `workspace` | `4` | TensorRT: tamaño del espacio de trabajo (GB) | +| `nms` | `False` | CoreML: añadir NMS | + +## Formatos de Exportación + +Los formatos de exportación disponibles de YOLOv8 están en la tabla a continuación. Puedes exportar a cualquier formato usando el argumento `format`, por ejemplo, `format='onnx'` o `format='engine'`. + +| Formato | Argumento `format` | Modelo | Metadatos | Argumentos | +|--------------------------------------------------------------------|--------------------|---------------------------|-----------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | ✅ | `imgsz`, `half` | diff --git a/docs/es/modes/index.md b/docs/es/modes/index.md new file mode 100644 index 00000000..b8321ac0 --- /dev/null +++ b/docs/es/modes/index.md @@ -0,0 +1,73 @@ +--- +comments: true +description: Desde el entrenamiento hasta el seguimiento, aprovecha al máximo YOLOv8 con Ultralytics. Obtén información y ejemplos para cada modo compatible incluyendo validación, exportación y evaluación comparativa. +keywords: Ultralytics, YOLOv8, Aprendizaje Automático, Detección de Objetos, Entrenamiento, Validación, Predicción, Exportación, Seguimiento, Benchmarking +--- + +# Modos de Ultralytics YOLOv8 + +Ecosistema Ultralytics YOLO e integraciones + +## Introducción + +Ultralytics YOLOv8 no es solo otro modelo de detección de objetos; es un marco de trabajo versátil diseñado para cubrir todo el ciclo de vida de los modelos de aprendizaje automático, desde la ingesta de datos y el entrenamiento del modelo hasta la validación, implementación y seguimiento en el mundo real. Cada modo sirve para un propósito específico y está diseñado para ofrecerte la flexibilidad y eficiencia necesarias para diferentes tareas y casos de uso. + +

+
+ +
+ Mira: Tutorial de Modos Ultralytics: Entrenar, Validar, Predecir, Exportar y Hacer Benchmarking. +

+ +### Modos a Primera Vista + +Comprender los diferentes **modos** que soporta Ultralytics YOLOv8 es crítico para sacar el máximo provecho a tus modelos: + +- **Modo Entrenar (Train)**: Afina tu modelo en conjuntos de datos personalizados o pre-cargados. +- **Modo Validar (Val)**: Un punto de control post-entrenamiento para validar el rendimiento del modelo. +- **Modo Predecir (Predict)**: Libera el poder predictivo de tu modelo en datos del mundo real. +- **Modo Exportar (Export)**: Prepara tu modelo para la implementación en varios formatos. +- **Modo Seguir (Track)**: Extiende tu modelo de detección de objetos a aplicaciones de seguimiento en tiempo real. +- **Modo Benchmark (Benchmark)**: Analiza la velocidad y precisión de tu modelo en diversos entornos de implementación. + +Esta guía completa tiene como objetivo proporcionarte una visión general y conocimientos prácticos de cada modo, ayudándote a aprovechar todo el potencial de YOLOv8. + +## [Entrenar (Train)](train.md) + +El modo Entrenar se utiliza para entrenar un modelo YOLOv8 en un conjunto de datos personalizado. En este modo, el modelo se entrena utilizando el conjunto de datos y los hiperparámetros especificados. El proceso de entrenamiento implica optimizar los parámetros del modelo para que pueda predecir con precisión las clases y ubicaciones de los objetos en una imagen. + +[Ejemplos de Entrenamiento](train.md){ .md-button .md-button--primary} + +## [Validar (Val)](val.md) + +El modo Validar se usa para validar un modelo YOLOv8 después de haber sido entrenado. En este modo, el modelo se evalúa en un conjunto de validación para medir su precisión y rendimiento de generalización. Este modo se puede usar para ajustar los hiperparámetros del modelo y mejorar su rendimiento. + +[Ejemplos de Validación](val.md){ .md-button .md-button--primary} + +## [Predecir (Predict)](predict.md) + +El modo Predecir se utiliza para realizar predicciones usando un modelo YOLOv8 entrenado en imágenes o videos nuevos. En este modo, el modelo se carga desde un archivo de punto de control, y el usuario puede proporcionar imágenes o videos para realizar inferencias. El modelo predice las clases y ubicaciones de los objetos en las imágenes o videos de entrada. + +[Ejemplos de Predicción](predict.md){ .md-button .md-button--primary} + +## [Exportar (Export)](export.md) + +El modo Exportar se utiliza para exportar un modelo YOLOv8 a un formato que se pueda usar para la implementación. En este modo, el modelo se convierte a un formato que puede ser utilizado por otras aplicaciones de software o dispositivos de hardware. Este modo es útil al implementar el modelo en entornos de producción. + +[Ejemplos de Exportación](export.md){ .md-button .md-button--primary} + +## [Seguir (Track)](track.md) + +El modo Seguir se usa para rastrear objetos en tiempo real utilizando un modelo YOLOv8. En este modo, el modelo se carga desde un archivo de punto de control, y el usuario puede proporcionar un flujo de video en vivo para realizar seguimiento de objetos en tiempo real. Este modo es útil para aplicaciones como sistemas de vigilancia o coches autónomos. + +[Ejemplos de Seguimiento](track.md){ .md-button .md-button--primary} + +## [Benchmark (Benchmark)](benchmark.md) + +El modo Benchmark se utiliza para perfilar la velocidad y precisión de varios formatos de exportación de YOLOv8. Los benchmarks proporcionan información sobre el tamaño del formato de exportación, sus métricas de `mAP50-95` (para detección de objetos, segmentación y pose) o métricas de `accuracy_top5` (para clasificación), y el tiempo de inferencia en milisegundos por imagen a través de varios formatos de exportación como ONNX, OpenVINO, TensorRT y otros. Esta información puede ayudar a los usuarios a elegir el formato de exportación óptimo para su caso de uso específico, basado en sus requerimientos de velocidad y precisión. + +[Ejemplos de Benchmarking](benchmark.md){ .md-button .md-button--primary} diff --git a/docs/es/modes/predict.md b/docs/es/modes/predict.md new file mode 100644 index 00000000..2384c15b --- /dev/null +++ b/docs/es/modes/predict.md @@ -0,0 +1,226 @@ +--- +comments: true +description: Descubra cómo utilizar el modo predictivo de YOLOv8 para diversas tareas. Aprenda acerca de diferentes fuentes de inferencia como imágenes, videos y formatos de datos. +keywords: Ultralytics, YOLOv8, modo predictivo, fuentes de inferencia, tareas de predicción, modo de transmisión, procesamiento de imágenes, procesamiento de videos, aprendizaje automático, IA +--- + +# Predicción del Modelo con YOLO de Ultralytics + +Ecosistema de YOLO de Ultralytics e integraciones + +## Introducción + +En el mundo del aprendizaje automático y la visión por computadora, el proceso de dar sentido a los datos visuales se denomina 'inferencia' o 'predicción'. YOLOv8 de Ultralytics ofrece una característica poderosa conocida como **modo predictivo** que está diseñada para inferencias de alto rendimiento y en tiempo real en una amplia gama de fuentes de datos. + +

+
+ +
+ Ver: Cómo Extraer las Salidas del Modelo YOLOv8 de Ultralytics para Proyectos Personalizados. +

+ +## Aplicaciones en el Mundo Real + +| Manufactura | Deportes | Seguridad | +|:-----------------------------------------------------------------------------------------------------------------------------------------:|:--------------------------------------------------------------------------------------------------------------------------------------:|:-------------------------------------------------------------------------------------------------------------------------------------:| +| ![Detección de Repuestos de Vehículos](https://github.com/RizwanMunawar/ultralytics/assets/62513924/a0f802a8-0776-44cf-8f17-93974a4a28a1) | ![Detección de Jugadores de Fútbol](https://github.com/RizwanMunawar/ultralytics/assets/62513924/7d320e1f-fc57-4d7f-a691-78ee579c3442) | ![Detección de Caídas de Personas](https://github.com/RizwanMunawar/ultralytics/assets/62513924/86437c4a-3227-4eee-90ef-9efb697bdb43) | +| Detección de Repuestos de Vehículos | Detección de Jugadores de Fútbol | Detección de Caídas de Personas | + +## ¿Por Qué Utilizar YOLO de Ultralytics para la Inferencia? + +Estas son algunas razones para considerar el modo predictivo de YOLOv8 para sus necesidades de inferencia: + +- **Versatilidad:** Capaz de realizar inferencias en imágenes, videos e incluso transmisiones en vivo. +- **Rendimiento:** Diseñado para procesamiento en tiempo real y de alta velocidad sin sacrificar precisión. +- **Facilidad de Uso:** Interfaces de Python y CLI intuitivas para una rápida implementación y pruebas. +- **Alta Personalización:** Diversos ajustes y parámetros para afinar el comportamiento de inferencia del modelo según sus requisitos específicos. + +### Características Principales del Modo Predictivo + +El modo predictivo de YOLOv8 está diseñado para ser robusto y versátil, y cuenta con: + +- **Compatibilidad con Múltiples Fuentes de Datos:** Ya sea que sus datos estén en forma de imágenes individuales, una colección de imágenes, archivos de video o transmisiones de video en tiempo real, el modo predictivo le tiene cubierto. +- **Modo de Transmisión:** Utilice la función de transmisión para generar un generador eficiente de memoria de objetos `Results`. Active esto configurando `stream=True` en el método de llamada del predictor. +- **Procesamiento por Lotes:** La capacidad de procesar múltiples imágenes o fotogramas de video en un solo lote, acelerando aún más el tiempo de inferencia. +- **Amigable para la Integración:** Se integra fácilmente con pipelines de datos existentes y otros componentes de software, gracias a su API flexible. + +Los modelos YOLO de Ultralytics devuelven ya sea una lista de objetos `Results` de Python, o un generador de objetos `Results` de Python eficiente en memoria cuando se pasa `stream=True` al modelo durante la inferencia: + +!!! ejemplo "Predict" + + === "Devolver una lista con `stream=False`" + ```python + from ultralytics import YOLO + + # Cargar un modelo + model = YOLO('yolov8n.pt') # modelo YOLOv8n preentrenado + + # Ejecutar inferencia por lotes en una lista de imágenes + results = model(['im1.jpg', 'im2.jpg']) # devuelve una lista de objetos Results + + # Procesar lista de resultados + for result in results: + boxes = result.boxes # Objeto Boxes para salidas de bbox + masks = result.masks # Objeto Masks para salidas de máscaras de segmentación + keypoints = result.keypoints # Objeto Keypoints para salidas de postura + probs = result.probs # Objeto Probs para salidas de clasificación + ``` + + === "Devolver un generador con `stream=True`" + ```python + from ultralytics import YOLO + + # Cargar un modelo + model = YOLO('yolov8n.pt') # modelo YOLOv8n preentrenado + + # Ejecutar inferencia por lotes en una lista de imágenes + results = model(['im1.jpg', 'im2.jpg'], stream=True) # devuelve un generador de objetos Results + + # Procesar generador de resultados + for result in results: + boxes = result.boxes # Objeto Boxes para salidas de bbox + .masks = result.masks # Objeto Masks para salidas de máscaras de segmentación + keypoints = result.keypoints # Objeto Keypoints para salidas de postura + probs = result.probs # Objeto Probs para salidas de clasificación + ``` + +## Fuentes de Inferencia + +YOLOv8 puede procesar diferentes tipos de fuentes de entrada para la inferencia, como se muestra en la tabla a continuación. Las fuentes incluyen imágenes estáticas, transmisiones de video y varios formatos de datos. La tabla también indica si cada fuente se puede utilizar en modo de transmisión con el argumento `stream=True` ✅. El modo de transmisión es beneficioso para procesar videos o transmisiones en vivo ya que crea un generador de resultados en lugar de cargar todos los fotogramas en la memoria. + +!!! consejo "Consejo" + + Utilice `stream=True` para procesar videos largos o conjuntos de datos grandes para gestionar eficientemente la memoria. Cuando `stream=False`, los resultados de todos los fotogramas o puntos de datos se almacenan en la memoria, lo que puede aumentar rápidamente y causar errores de memoria insuficiente para entradas grandes. En contraste, `stream=True` utiliza un generador, que solo mantiene los resultados del fotograma o punto de datos actual en la memoria, reduciendo significativamente el consumo de memoria y previniendo problemas de falta de memoria. + +| Fuente | Argumento | Tipo | Notas | +|---------------------|--------------------------------------------|----------------|---------------------------------------------------------------------------------------------------------------------------------| +| imagen | `'image.jpg'` | `str` o `Path` | Archivo único de imagen. | +| URL | `'https://ultralytics.com/images/bus.jpg'` | `str` | URL a una imagen. | +| captura de pantalla | `'screen'` | `str` | Captura una captura de pantalla. | +| PIL | `Image.open('im.jpg')` | `PIL.Image` | Formato HWC con canales RGB. | +| OpenCV | `cv2.imread('im.jpg')` | `np.ndarray` | Formato HWC con canales BGR `uint8 (0-255)`. | +| numpy | `np.zeros((640,1280,3))` | `np.ndarray` | Formato HWC con canales BGR `uint8 (0-255)`. | +| torch | `torch.zeros(16,3,320,640)` | `torch.Tensor` | Formato BCHW con canales RGB `float32 (0.0-1.0)`. | +| CSV | `'sources.csv'` | `str` o `Path` | Archivo CSV que contiene rutas a imágenes, videos o directorios. | +| video ✅ | `'video.mp4'` | `str` o `Path` | Archivo de video en formatos como MP4, AVI, etc. | +| directorio ✅ | `'path/'` | `str` o `Path` | Ruta a un directorio que contiene imágenes o videos. | +| glob ✅ | `'path/*.jpg'` | `str` | Patrón glob para coincidir con múltiples archivos. Utilice el carácter `*` como comodín. | +| YouTube ✅ | `'https://youtu.be/LNwODJXcvt4'` | `str` | URL a un video de YouTube. | +| transmisión ✅ | `'rtsp://example.com/media.mp4'` | `str` | URL para protocolos de transmisión como RTSP, RTMP, TCP o una dirección IP. | +| multi-transmisión ✅ | `'list.streams'` | `str` o `Path` | Archivo de texto `*.streams` con una URL de transmisión por fila, es decir, 8 transmisiones se ejecutarán con tamaño de lote 8. | + +A continuación se muestran ejemplos de código para usar cada tipo de fuente: + +!!! ejemplo "Fuentes de predicción" + + === "imagen" + Ejecute inferencia en un archivo de imagen. + ```python + from ultralytics import YOLO + + # Cargar el modelo YOLOv8n preentrenado + model = YOLO('yolov8n.pt') + + # Definir la ruta al archivo de imagen + source = 'ruta/a/imagen.jpg' + + # Ejecutar inferencia en la fuente + results = model(source) # lista de objetos Results + ``` + + === "captura de pantalla" + Ejecute inferencia en el contenido actual de la pantalla como captura de pantalla. + ```python + from ultralytics import YOLO + + # Cargar el modelo YOLOv8n preentrenado + model = YOLO('yolov8n.pt') + + # Definir captura de pantalla actual como fuente + source = 'screen' + + # Ejecutar inferencia en la fuente + results = model(source) # lista de objetos Results + ``` + + === "URL" + Ejecute inferencia en una imagen o video alojados remotamente a través de URL. + ```python + from ultralytics import YOLO + + # Cargar el modelo YOLOv8n preentrenado + model = YOLO('yolov8n.pt') + + # Definir URL remota de imagen o video + source = 'https://ultralytics.com/images/bus.jpg' + + # Ejecutar inferencia en la fuente + results = model(source) # lista de objetos Results + ``` + + === "PIL" + Ejecute inferencia en una imagen abierta con la Biblioteca de Imágenes de Python (PIL). + ```python + from PIL import Image + from ultralytics import YOLO + + # Cargar el modelo YOLOv8n preentrenado + model = YOLO('yolov8n.pt') + + # Abrir una imagen usando PIL + source = Image.open('ruta/a/imagen.jpg') + + # Ejecutar inferencia en la fuente + results = model(source) # lista de objetos Results + ``` + + === "OpenCV" + Ejecute inferencia en una imagen leída con OpenCV. + ```python + import cv2 + from ultralytics import YOLO + + # Cargar el modelo YOLOv8n preentrenado + model = YOLO('yolov8n.pt') + + # Leer una imagen usando OpenCV + source = cv2.imread('ruta/a/imagen.jpg') + + # Ejecutar inferencia en la fuente + results = model(source) # lista de objetos Results + ``` + + === "numpy" + Ejecute inferencia en una imagen representada como un array de numpy. + ```python + import numpy as np + from ultralytics import YOLO + + # Cargar el modelo YOLOv8n preentrenado + model = YOLO('yolov8n.pt') + + # Crear un array aleatorio de numpy con forma HWC (640, 640, 3) con valores en rango [0, 255] y tipo uint8 + source = np.random.randint(low=0, high=255, size=(640, 640, 3), dtype='uint8') + + # Ejecutar inferencia en la fuente + results = model(source) # lista de objetos Results + ``` + + === "torch" + Ejecute inferencia en una imagen representada como un tensor de PyTorch. + ```python + import torch + from ultralytics import YOLO + + # Cargar el modelo YOLOv8n preentrenado + model = YOLO('yolov8n.pt') + + # Crear un tensor aleatorio de torch con forma BCHW (1, 3, 640, 640) con valores en rango [0, 1] y tipo float32 + source = torch.rand(1, 3, 640, 640, dtype=torch.float32) + + # Ejecutar inferencia en la fuente + results = model(source) # lista de objetos Results diff --git a/docs/es/modes/track.md b/docs/es/modes/track.md new file mode 100644 index 00000000..719e6c7e --- /dev/null +++ b/docs/es/modes/track.md @@ -0,0 +1,200 @@ +--- +comments: true +description: Aprende a utilizar Ultralytics YOLO para el seguimiento de objetos en flujos de video. Guías para usar diferentes rastreadores y personalizar la configuración del rastreador. +keywords: Ultralytics, YOLO, seguimiento de objetos, flujos de video, BoT-SORT, ByteTrack, guía de Python, guía de CLI +--- + +# Seguimiento de Múltiples Objetos con Ultralytics YOLO + +Ejemplos de seguimiento de múltiples objetos + +El seguimiento de objetos en el ámbito del análisis de video es una tarea crítica que no solo identifica la ubicación y clase de objetos dentro del cuadro, sino que también mantiene una ID única para cada objeto detectado a medida que avanza el video. Las aplicaciones son ilimitadas, desde vigilancia y seguridad hasta análisis deportivos en tiempo real. + +## ¿Por Qué Elegir Ultralytics YOLO para el Seguimiento de Objetos? + +La salida de los rastreadores de Ultralytics es consistente con la detección de objetos estándar, pero con el valor añadido de las IDs de objetos. Esto facilita el seguimiento de objetos en flujos de video y la realización de análisis posteriores. Aquí tienes algunas razones por las que deberías considerar usar Ultralytics YOLO para tus necesidades de seguimiento de objetos: + +- **Eficiencia:** Procesa flujos de video en tiempo real sin comprometer la precisión. +- **Flexibilidad:** Soporta múltiples algoritmos de seguimiento y configuraciones. +- **Facilidad de Uso:** API simple de Python y opciones CLI para una rápida integración y despliegue. +- **Personalización:** Fácil de usar con modelos YOLO entrenados a medida, permitiendo la integración en aplicaciones específicas del dominio. + +

+
+ +
+ Ver: Detección de Objetos y Seguimiento con Ultralytics YOLOv8. +

+ +## Aplicaciones en el Mundo Real + +| Transporte | Venta al por Menor | Acuicultura | +|:------------------------------------------------------------------------------------------------------------------------------:|:-----------------------------------------------------------------------------------------------------------------------------:|:--------------------------------------------------------------------------------------------------------------------------:| +| ![Seguimiento de Vehículos](https://github.com/RizwanMunawar/ultralytics/assets/62513924/ee6e6038-383b-4f21-ac29-b2a1c7d386ab) | ![Seguimiento de Personas](https://github.com/RizwanMunawar/ultralytics/assets/62513924/93bb4ee2-77a0-4e4e-8eb6-eb8f527f0527) | ![Seguimiento de Peces](https://github.com/RizwanMunawar/ultralytics/assets/62513924/a5146d0f-bfa8-4e0a-b7df-3c1446cd8142) | +| Seguimiento de Vehículos | Seguimiento de Personas | Seguimiento de Peces | + +## Características a Simple Vista + +Ultralytics YOLO extiende sus características de detección de objetos para proporcionar un seguimiento de objetos robusto y versátil: + +- **Seguimiento en Tiempo Real:** Rastrea sin problemas los objetos en videos de alta frecuencia de cuadros. +- **Soporte de Múltiples Rastreadores:** Elige entre una variedad de algoritmos de seguimiento establecidos. +- **Configuraciones de Rastreador Personalizables:** Adapta el algoritmo de seguimiento para satisfacer requisitos específicos ajustando diversos parámetros. + +## Rastreadores Disponibles + +Ultralytics YOLO soporta los siguientes algoritmos de seguimiento. Pueden ser habilitados pasando el archivo de configuración YAML relevante como `tracker=tracker_type.yaml`: + +* [BoT-SORT](https://github.com/NirAharon/BoT-SORT) - Usa `botsort.yaml` para habilitar este rastreador. +* [ByteTrack](https://github.com/ifzhang/ByteTrack) - Usa `bytetrack.yaml` para habilitar este rastreador. + +El rastreador predeterminado es BoT-SORT. + +## Seguimiento + +Para ejecutar el rastreador en flujos de video, usa un modelo Detect, Segment o Pose entrenado tales como YOLOv8n, YOLOv8n-seg y YOLOv8n-pose. + +!!! ejemplo "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Cargar un modelo oficial o personalizado + model = YOLO('yolov8n.pt') # Cargar un modelo oficial Detect + model = YOLO('yolov8n-seg.pt') # Cargar un modelo oficial Segment + model = YOLO('yolov8n-pose.pt') # Cargar un modelo oficial Pose + model = YOLO('path/to/best.pt') # Cargar un modelo entrenado a medida + + # Realizar el seguimiento con el modelo + results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True) # Seguimiento con el rastreador predeterminado + results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml") # Seguimiento con el rastreador ByteTrack + ``` + + === "CLI" + + ```bash + # Realizar seguimiento con varios modelos usando la interfaz de línea de comandos + yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" # Modelo oficial Detect + yolo track model=yolov8n-seg.pt source="https://youtu.be/LNwODJXcvt4" # Modelo oficial Segment + yolo track model=yolov8n-pose.pt source="https://youtu.be/LNwODJXcvt4" # Modelo oficial Pose + yolo track model=path/to/best.pt source="https://youtu.be/LNwODJXcvt4" # Modelo entrenado a medida + + # Realizar seguimiento usando el rastreador ByteTrack + yolo track model=path/to/best.pt tracker="bytetrack.yaml" + ``` + +Como se puede ver en el uso anterior, el seguimiento está disponible para todos los modelos Detect, Segment y Pose ejecutados en videos o fuentes de transmisión. + +## Configuración + +### Argumentos de Seguimiento + +La configuración de seguimiento comparte propiedades con el modo Predict, como `conf`, `iou` y `show`. Para configuraciones adicionales, consulta la página del modelo [Predict](https://docs.ultralytics.com/modes/predict/). + +!!! ejemplo "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Configurar los parámetros de seguimiento y ejecutar el rastreador + model = YOLO('yolov8n.pt') + results = model.track(source="https://youtu.be/LNwODJXcvt4", conf=0.3, iou=0.5, show=True) + ``` + + === "CLI" + + ```bash + # Configurar parámetros de seguimiento y ejecutar el rastreador usando la interfaz de línea de comandos + yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" conf=0.3, iou=0.5 show + ``` + +### Selección de Rastreador + +Ultralytics también te permite usar un archivo de configuración de rastreador modificado. Para hacerlo, simplemente haz una copia de un archivo de configuración de rastreador (por ejemplo, `custom_tracker.yaml`) de [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers) y modifica cualquier configuración (excepto el `tracker_type`) según tus necesidades. + +!!! ejemplo "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Cargar el modelo y ejecutar el rastreador con un archivo de configuración personalizado + model = YOLO('yolov8n.pt') + results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker='custom_tracker.yaml') + ``` + + === "CLI" + + ```bash + # Cargar el modelo y ejecutar el rastreador con un archivo de configuración personalizado usando la interfaz de línea de comandos + yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" tracker='custom_tracker.yaml' + ``` + +Para obtener una lista completa de los argumentos de seguimiento, consulta la página [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers). + +## Ejemplos en Python + +### Bucle de Seguimiento Persistente + +Aquí hay un script en Python que utiliza OpenCV (`cv2`) y YOLOv8 para ejecutar el seguimiento de objetos en fotogramas de video. Este script aún asume que ya has instalado los paquetes necesarios (`opencv-python` y `ultralytics`). El argumento `persist=True` le indica al rastreador que la imagen o fotograma actual es el siguiente en una secuencia y que espera rastros de la imagen anterior en la imagen actual. + +!!! ejemplo "Bucle de transmisión en vivo con seguimiento" + + ```python + import cv2 + from ultralytics import YOLO + + # Cargar el modelo YOLOv8 + model = YOLO('yolov8n.pt') + + # Abrir el archivo de video + video_path = "path/to/video.mp4" + cap = cv2.VideoCapture(video_path) + + # Bucle a través de los fotogramas del video + while cap.isOpened(): + # Leer un fotograma del video + success, frame = cap.read() + + if success: + # Ejecutar seguimiento YOLOv8 en el fotograma, persistiendo los rastreos entre fotogramas + results = model.track(frame, persist=True) + + # Visualizar los resultados en el fotograma + annotated_frame = results[0].plot() + + # Mostrar el fotograma anotado + cv2.imshow("Seguimiento YOLOv8", annotated_frame) + + # Romper el bucle si se presiona 'q' + if cv2.waitKey(1) & 0xFF == ord("q"): + break + else: + # Romper el bucle si se alcanza el final del video + break + + # Liberar el objeto de captura de video y cerrar la ventana de visualización + cap.release() + cv2.destroyAllWindows() + ``` + +Toma en cuenta el cambio de `model(frame)` a `model.track(frame)`, que habilita el seguimiento de objetos en lugar de simplemente la detección. Este script modificado ejecutará el rastreador en cada fotograma del video, visualizará los resultados y los mostrará en una ventana. El bucle puede ser terminado presionando 'q'. + +## Contribuir con Nuevos Rastreadores + +¿Eres experto en seguimiento de múltiples objetos y has implementado o adaptado exitosamente un algoritmo de seguimiento con Ultralytics YOLO? Te invitamos a contribuir en nuestra sección de Rastreadores en [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers)! Tus aplicaciones en el mundo real y soluciones podrían ser invaluables para los usuarios que trabajan en tareas de seguimiento. + +Al contribuir en esta sección, ayudarás a ampliar el alcance de las soluciones de seguimiento disponibles dentro del marco de trabajo de Ultralytics YOLO, añadiendo otra capa de funcionalidad y utilidad para la comunidad. + +Para iniciar tu contribución, por favor consulta nuestra [Guía de Contribución](https://docs.ultralytics.com/help/contributing) para obtener instrucciones completas sobre cómo enviar una Solicitud de Extracción (PR) 🛠️. ¡Estamos emocionados de ver lo que traes a la mesa! + +Juntos, vamos a mejorar las capacidades de seguimiento del ecosistema Ultralytics YOLO 🙏! diff --git a/docs/es/modes/train.md b/docs/es/modes/train.md new file mode 100644 index 00000000..33f2688a --- /dev/null +++ b/docs/es/modes/train.md @@ -0,0 +1,206 @@ +--- +comments: true +description: Guía paso a paso para entrenar modelos YOLOv8 con Ultralytics YOLO incluyendo ejemplos de entrenamiento con una sola GPU y múltiples GPUs +keywords: Ultralytics, YOLOv8, YOLO, detección de objetos, modo de entrenamiento, conjunto de datos personalizado, entrenamiento GPU, multi-GPU, hiperparámetros, ejemplos CLI, ejemplos Python +--- + +# Entrenamiento de Modelos con Ultralytics YOLO + +Ecosistema e integraciones de Ultralytics YOLO + +## Introducción + +Entrenar un modelo de aprendizaje profundo implica alimentarlo con datos y ajustar sus parámetros para que pueda hacer predicciones precisas. El modo de entrenamiento en Ultralytics YOLOv8 está diseñado para un entrenamiento efectivo y eficiente de modelos de detección de objetos, aprovechando al máximo las capacidades del hardware moderno. Esta guía tiene como objetivo cubrir todos los detalles que necesita para comenzar a entrenar sus propios modelos utilizando el robusto conjunto de características de YOLOv8. + +

+
+ +
+ Ver: Cómo Entrenar un modelo YOLOv8 en Tu Conjunto de Datos Personalizado en Google Colab. +

+ +## ¿Por Qué Elegir Ultralytics YOLO para Entrenamiento? + +Aquí hay algunas razones convincentes para optar por el modo Entrenamiento de YOLOv8: + +- **Eficiencia:** Aprovecha al máximo tu hardware, ya sea en una configuración de una sola GPU o escalando entre múltiples GPUs. +- **Versatilidad:** Entrena con conjuntos de datos personalizados además de los ya disponibles como COCO, VOC e ImageNet. +- **Amigable al Usuario:** Interfaces CLI y Python simples pero potentes para una experiencia de entrenamiento sencilla. +- **Flexibilidad de Hiperparámetros:** Una amplia gama de hiperparámetros personalizables para ajustar el rendimiento del modelo. + +### Características Clave del Modo Entrenamiento + +Las siguientes son algunas características notables del modo Entrenamiento de YOLOv8: + +- **Descarga Automática de Conjuntos de Datos:** Conjuntos de datos estándar como COCO, VOC e ImageNet se descargan automáticamente en el primer uso. +- **Soporte Multi-GPU:** Escala tus esfuerzos de entrenamiento sin problemas en múltiples GPUs para acelerar el proceso. +- **Configuración de Hiperparámetros:** La opción de modificar hiperparámetros a través de archivos de configuración YAML o argumentos CLI. +- **Visualización y Monitoreo:** Seguimiento en tiempo real de métricas de entrenamiento y visualización del proceso de aprendizaje para una mejor comprensión. + +!!! consejo "Consejo" + + * Los conjuntos de datos de YOLOv8 como COCO, VOC, ImageNet y muchos otros se descargan automáticamente en el primer uso, es decir, `yolo train data=coco.yaml` + +## Ejemplos de Uso + +Entrena YOLOv8n en el conjunto de datos COCO128 durante 100 épocas con un tamaño de imagen de 640. El dispositivo de entrenamiento se puede especificar usando el argumento `device`. Si no se pasa ningún argumento, se usará la GPU `device=0` si está disponible; de lo contrario, se usará `device=cpu`. Consulta la sección de Argumentos a continuación para una lista completa de argumentos de entrenamiento. + +!!! ejemplo "Ejemplo de Entrenamiento con una sola GPU y CPU" + + El dispositivo se determina automáticamente. Si hay una GPU disponible, se usará; de lo contrario, el entrenamiento comenzará en la CPU. + + === "Python" + + ```python + from ultralytics import YOLO + + # Cargar un modelo + model = YOLO('yolov8n.yaml') # construir un modelo nuevo desde YAML + model = YOLO('yolov8n.pt') # cargar un modelo preentrenado (recomendado para entrenamiento) + model = YOLO('yolov8n.yaml').load('yolov8n.pt') # construir desde YAML y transferir pesos + + # Entrenar el modelo + results = model.train(data='coco128.yaml', epochs=100, imgsz=640) + ``` + + === "CLI" + + ```bash + # Construir un modelo nuevo desde YAML y comenzar el entrenamiento desde cero + yolo detect train data=coco128.yaml model=yolov8n.yaml epochs=100 imgsz=640 + + # Comenzar el entrenamiento desde un modelo preentrenado *.pt + yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 + + # Construir un modelo nuevo desde YAML, transferir pesos preentrenados a él y comenzar el entrenamiento + yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640 + ``` + +### Entrenamiento Multi-GPU + +El entrenamiento Multi-GPU permite una utilización más eficiente de los recursos de hardware disponibles, distribuyendo la carga de entrenamiento en varias GPUs. Esta característica está disponible tanto a través de la API de Python como de la interfaz de línea de comandos. Para habilitar el entrenamiento Multi-GPU, especifica los IDs de los dispositivos GPU que deseas usar. + +!!! ejemplo "Ejemplo de Entrenamiento Multi-GPU" + + Para entrenar con 2 GPUs, dispositivos CUDA 0 y 1, usa los siguientes comandos. Amplía a GPUs adicionales según sea necesario. + + === "Python" + + ```python + from ultralytics import YOLO + + # Cargar un modelo + model = YOLO('yolov8n.pt') # cargar un modelo preentrenado (recomendado para entrenamiento) + + # Entrenar el modelo con 2 GPUs + results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device=[0, 1]) + ``` + + === "CLI" + + ```bash + # Comenzar el entrenamiento desde un modelo preentrenado *.pt usando las GPUs 0 y 1 + yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=0,1 + ``` + +### Entrenamiento con Apple M1 y M2 MPS + +Con el soporte para los chips Apple M1 y M2 integrados en los modelos Ultralytics YOLO, ahora es posible entrenar tus modelos en dispositivos que utilizan el potente marco de Metal Performance Shaders (MPS). El MPS ofrece una forma de alto rendimiento para ejecutar tareas de cálculo y procesamiento de imágenes en el silicio personalizado de Apple. + +Para habilitar el entrenamiento en chips Apple M1 y M2, debes especificar 'mps' como tu dispositivo al iniciar el proceso de entrenamiento. A continuación se muestra un ejemplo de cómo podrías hacer esto en Python y a través de la línea de comandos: + +!!! ejemplo "Ejemplo de Entrenamiento MPS" + + === "Python" + + ```python + from ultralytics import YOLO + + # Cargar un modelo + model = YOLO('yolov8n.pt') # cargar un modelo preentrenado (recomendado para entrenamiento) + + # Entrenar el modelo con 2 GPUs + results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device='mps') + ``` + + === "CLI" + + ```bash + # Comenzar el entrenamiento desde un modelo preentrenado *.pt usando las GPUs 0 y 1 + yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=mps + ``` + +Al aprovechar el poder computacional de los chips M1/M2, esto permite un procesamiento más eficiente de las tareas de entrenamiento. Para obtener una guía más detallada y opciones de configuración avanzadas, consulta la [documentación de PyTorch MPS](https://pytorch.org/docs/stable/notes/mps.html). + +## Registros (Logging) + +Al entrenar un modelo YOLOv8, puedes encontrar valioso llevar un registro del rendimiento del modelo con el tiempo. Aquí es donde entra en juego el registro. Ultralytics' YOLO ofrece soporte para tres tipos de registradores: Comet, ClearML y TensorBoard. + +Para usar un registrador, selecciónalo en el menú desplegable en el fragmento de código anterior y ejecútalo. El registrador elegido se instalará e inicializará. + +### Comet + +[Comet](https://www.comet.ml/site/) es una plataforma que permite a los científicos de datos y desarrolladores rastrear, comparar, explicar y optimizar experimentos y modelos. Ofrece funcionalidades como métricas en tiempo real, diferencias de código y seguimiento de hiperparámetros. + +Para usar Comet: + +!!! ejemplo "" + + === "Python" + ```python + # pip install comet_ml + import comet_ml + + comet_ml.init() + ``` + +Recuerda iniciar sesión en tu cuenta de Comet en su sitio web y obtener tu clave API. Necesitarás agregar esto a tus variables de entorno o tu script para registrar tus experimentos. + +### ClearML + +[ClearML](https://www.clear.ml/) es una plataforma de código abierto que automatiza el seguimiento de experimentos y ayuda con la compartición eficiente de recursos. Está diseñado para ayudar a los equipos a gestionar, ejecutar y reproducir su trabajo de ML de manera más eficiente. + +Para usar ClearML: + +!!! ejemplo "" + + === "Python" + ```python + # pip install clearml + import clearml + + clearml.browser_login() + ``` + +Después de ejecutar este script, necesitarás iniciar sesión en tu cuenta de ClearML en el navegador y autenticar tu sesión. + +### TensorBoard + +[TensorBoard](https://www.tensorflow.org/tensorboard) es una herramienta de visualización para TensorFlow. Te permite visualizar tu grafo TensorFlow, trazar métricas cuantitativas sobre la ejecución de tu grafo y mostrar datos adicionales como imágenes que lo atraviesan. + +Para usar TensorBoard en [Google Colab](https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb): + +!!! ejemplo "" + + === "CLI" + ```bash + load_ext tensorboard + tensorboard --logdir ultralytics/runs # reemplazar con el directorio 'runs' + ``` + +Para usar TensorBoard localmente, ejecuta el siguiente comando y visualiza los resultados en http://localhost:6006/. + +!!! ejemplo "" + + === "CLI" + ```bash + tensorboard --logdir ultralytics/runs # reemplazar con el directorio 'runs' + ``` + +Esto cargará TensorBoard y lo dirigirá al directorio donde se guardan tus registros de entrenamiento. + +Después de configurar tu registrador, puedes proceder con tu entrenamiento de modelo. Todas las métricas de entrenamiento se registrarán automáticamente en la plataforma elegida y podrás acceder a estos registros para monitorear el rendimiento de tu modelo con el tiempo, comparar diferentes modelos e identificar áreas de mejora. diff --git a/docs/es/modes/val.md b/docs/es/modes/val.md new file mode 100644 index 00000000..d70df3a7 --- /dev/null +++ b/docs/es/modes/val.md @@ -0,0 +1,86 @@ +--- +comments: true +description: Guía para validar modelos YOLOv8. Aprenda a evaluar el rendimiento de sus modelos YOLO utilizando configuraciones y métricas de validación con ejemplos en Python y CLI. +keywords: Ultralytics, Documentación YOLO, YOLOv8, validación, evaluación de modelos, hiperparámetros, precisión, métricas, Python, CLI +--- + +# Validación de modelos con Ultralytics YOLO + +Ecosistema e integraciones de Ultralytics YOLO + +## Introducción + +La validación es un paso crítico en el flujo de trabajo de aprendizaje automático, permitiéndole evaluar la calidad de sus modelos entrenados. El modo Val en Ultralytics YOLOv8 proporciona un robusto conjunto de herramientas y métricas para evaluar el rendimiento de sus modelos de detección de objetos. Esta guía sirve como un recurso completo para comprender cómo utilizar efectivamente el modo Val para asegurar que sus modelos sean precisos y confiables. + +## ¿Por qué validar con Ultralytics YOLO? + +Estas son las ventajas de usar el modo Val de YOLOv8: + +- **Precisión:** Obtenga métricas precisas como mAP50, mAP75 y mAP50-95 para evaluar de manera integral su modelo. +- **Comodidad:** Utilice funciones integradas que recuerdan los ajustes de entrenamiento, simplificando el proceso de validación. +- **Flexibilidad:** Valide su modelo con el mismo conjunto de datos o diferentes conjuntos de datos y tamaños de imagen. +- **Ajuste de Hiperparámetros:** Use las métricas de validación para ajustar su modelo y mejorar el rendimiento. + +### Características principales del modo Val + +Estas son las funcionalidades notables ofrecidas por el modo Val de YOLOv8: + +- **Configuraciones Automatizadas:** Los modelos recuerdan sus configuraciones de entrenamiento para una validación sencilla. +- **Soporte de Múltiples Métricas:** Evalúe su modelo basado en una gama de métricas de precisión. +- **CLI y API de Python:** Elija entre la interfaz de línea de comandos o API de Python basada en su preferencia para validación. +- **Compatibilidad de Datos:** Funciona sin problemas con conjuntos de datos utilizados durante la fase de entrenamiento así como con conjuntos de datos personalizados. + +!!! tip "Consejo" + + * Los modelos YOLOv8 recuerdan automáticamente sus ajustes de entrenamiento, así que puede validar un modelo en el mismo tamaño de imagen y en el conjunto de datos original fácilmente con solo `yolo val model=yolov8n.pt` o `model('yolov8n.pt').val()` + +## Ejemplos de Uso + +Valide la precisión del modelo YOLOv8n entrenado en el conjunto de datos COCO128. No es necesario pasar ningún argumento ya que el `modelo` retiene sus `datos` de entrenamiento y argumentos como atributos del modelo. Vea la sección de Argumentos a continuación para una lista completa de argumentos de exportación. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Cargar un modelo + model = YOLO('yolov8n.pt') # cargar un modelo oficial + model = YOLO('ruta/a/best.pt') # cargar un modelo personalizado + + # Validar el modelo + metrics = model.val() # no se necesitan argumentos, el conjunto de datos y ajustes se recuerdan + metrics.box.map # map50-95 + metrics.box.map50 # map50 + metrics.box.map75 # map75 + metrics.box.maps # una lista que contiene map50-95 de cada categoría + ``` + === "CLI" + + ```bash + yolo detect val model=yolov8n.pt # val model oficial + yolo detect val model=ruta/a/best.pt # val model personalizado + ``` + +## Argumentos + +Los ajustes de validación para modelos YOLO se refieren a los diversos hiperparámetros y configuraciones utilizados para evaluar el rendimiento del modelo en un conjunto de datos de validación. Estos ajustes pueden afectar el rendimiento, la velocidad y la precisión del modelo. Algunos ajustes comunes de validación YOLO incluyen el tamaño del lote, la frecuencia con la que se realiza la validación durante el entrenamiento y las métricas utilizadas para evaluar el rendimiento del modelo. Otros factores que pueden afectar el proceso de validación incluyen el tamaño y la composición del conjunto de datos de validación y la tarea específica para la que se utiliza el modelo. Es importante ajustar y experimentar cuidadosamente con estos ajustes para asegurarse de que el modelo esté funcionando bien en el conjunto de datos de validación y para detectar y prevenir el sobreajuste. + +| Clave | Valor | Descripción | +|---------------|---------|---------------------------------------------------------------------------------------------------| +| `data` | `None` | ruta al archivo de datos, por ejemplo coco128.yaml | +| `imgsz` | `640` | tamaño de las imágenes de entrada como entero | +| `batch` | `16` | número de imágenes por lote (-1 para AutoBatch) | +| `save_json` | `False` | guardar resultados en archivo JSON | +| `save_hybrid` | `False` | guardar versión híbrida de las etiquetas (etiquetas + predicciones adicionales) | +| `conf` | `0.001` | umbral de confianza del objeto para detección | +| `iou` | `0.6` | umbral de Intersección sobre Unión (IoU) para NMS | +| `max_det` | `300` | número máximo de detecciones por imagen | +| `half` | `True` | usar precisión de punto flotante de media preción (FP16) | +| `device` | `None` | dispositivo en el que se ejecuta, por ejemplo dispositivo cuda=0/1/2/3 o dispositivo=cpu | +| `dnn` | `False` | utilizar OpenCV DNN para inferencia ONNX | +| `plots` | `False` | mostrar gráficos durante el entrenamiento | +| `rect` | `False` | val rectangular con cada lote compilado para el mínimo relleno | +| `split` | `val` | división del conjunto de datos a utilizar para la validación, por ejemplo 'val', 'test' o 'train' | +| diff --git a/docs/es/quickstart.md b/docs/es/quickstart.md new file mode 100644 index 00000000..aa6373d6 --- /dev/null +++ b/docs/es/quickstart.md @@ -0,0 +1,187 @@ +--- +comments: true +description: Explore diversos métodos para instalar Ultralytics usando pip, conda, git y Docker. Aprende cómo usar Ultralytics con la interfaz de línea de comandos o dentro de tus proyectos de Python. +keywords: instalación de Ultralytics, pip install Ultralytics, instalación de Docker Ultralytics, interfaz de línea de comandos de Ultralytics, interfaz de Python de Ultralytics +--- + +## Instalar Ultralytics + +Ultralytics ofrece varios métodos de instalación incluyendo pip, conda y Docker. Instala YOLOv8 a través del paquete `ultralytics` de pip para la última versión estable o clonando el [repositorio de GitHub de Ultralytics](https://github.com/ultralytics/ultralytics) para obtener la versión más actualizada. Docker se puede utilizar para ejecutar el paquete en un contenedor aislado, evitando la instalación local. + +!!! example "Instalar" + + === "Instalación con Pip (recomendado)" + Instala el paquete `ultralytics` usando pip o actualiza una instalación existente ejecutando `pip install -U ultralytics`. Visita el Índice de Paquetes de Python (PyPI) para más detalles sobre el paquete `ultralytics`: [https://pypi.org/project/ultralytics/](https://pypi.org/project/ultralytics/). + + [![Versión en PyPI](https://badge.fury.io/py/ultralytics.svg)](https://badge.fury.io/py/ultralytics) [![Descargas](https://static.pepy.tech/badge/ultralytics)](https://pepy.tech/project/ultralytics) + + ```bash + # Instalar el paquete ultralytics desde PyPI + pip install ultralytics + ``` + + También puedes instalar el paquete `ultralytics` directamente del [repositorio](https://github.com/ultralytics/ultralytics) en GitHub. Esto puede ser útil si quieres la última versión de desarrollo. Asegúrate de tener la herramienta de línea de comandos Git instalada en tu sistema. El comando `@main` instala la rama `main` y puede modificarse a otra rama, es decir, `@my-branch`, o eliminarse por completo para volver por defecto a la rama `main`. + + ```bash + # Instalar el paquete ultralytics desde GitHub + pip install git+https://github.com/ultralytics/ultralytics.git@main + ``` + + + === "Instalación con Conda" + Conda es un gestor de paquetes alternativo a pip que también puede utilizarse para la instalación. Visita Anaconda para más detalles en [https://anaconda.org/conda-forge/ultralytics](https://anaconda.org/conda-forge/ultralytics). El repositorio de paquetes de alimentación de Ultralytics para actualizar el paquete de conda está en [https://github.com/conda-forge/ultralytics-feedstock/](https://github.com/conda-forge/ultralytics-feedstock/). + + + [![Receta de Conda](https://img.shields.io/badge/recipe-ultralytics-green.svg)](https://anaconda.org/conda-forge/ultralytics) [![Descargas de Conda](https://img.shields.io/conda/dn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics) [![Versión de Conda](https://img.shields.io/conda/vn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics) [![Plataformas de Conda](https://img.shields.io/conda/pn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics) + + ```bash + # Instalar el paquete ultralytics usando conda + conda install -c conda-forge ultralytics + ``` + + !!! note + + Si estás instalando en un entorno CUDA, la mejor práctica es instalar `ultralytics`, `pytorch` y `pytorch-cuda` en el mismo comando para permitir que el gestor de paquetes de conda resuelva cualquier conflicto, o en su defecto instalar `pytorch-cuda` al final para permitir que sobrescriba el paquete específico de CPU `pytorch` si es necesario. + ```bash + # Instalar todos los paquetes juntos usando conda + conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics + ``` + + ### Imagen Docker de Conda + + Las imágenes Docker de Conda de Ultralytics también están disponibles en [DockerHub](https://hub.docker.com/r/ultralytics/ultralytics). Estas imágenes están basadas en [Miniconda3](https://docs.conda.io/projects/miniconda/en/latest/) y son una manera simple de comenzar a usar `ultralytics` en un entorno Conda. + + ```bash + # Establecer el nombre de la imagen como una variable + t=ultralytics/ultralytics:latest-conda + + # Descargar la última imagen de ultralytics de Docker Hub + sudo docker pull $t + + # Ejecutar la imagen de ultralytics en un contenedor con soporte para GPU + sudo docker run -it --ipc=host --gpus all $t # todas las GPUs + sudo docker run -it --ipc=host --gpus '"device=2,3"' $t # especificar GPUs + ``` + + === "Clonar con Git" + Clona el repositorio `ultralytics` si estás interesado en contribuir al desarrollo o deseas experimentar con el código fuente más reciente. Después de clonar, navega al directorio e instala el paquete en modo editable `-e` usando pip. + ```bash + # Clonar el repositorio ultralytics + git clone https://github.com/ultralytics/ultralytics + + # Navegar al directorio clonado + cd ultralytics + + # Instalar el paquete en modo editable para desarrollo + pip install -e . + ``` + +Consulta el archivo [requirements.txt](https://github.com/ultralytics/ultralytics/blob/main/requirements.txt) de `ultralytics` para ver una lista de dependencias. Ten en cuenta que todos los ejemplos anteriores instalan todas las dependencias requeridas. + +!!! tip "Consejo" + + Los requisitos de PyTorch varían según el sistema operativo y los requisitos de CUDA, por lo que se recomienda instalar primero PyTorch siguiendo las instrucciones en [https://pytorch.org/get-started/locally](https://pytorch.org/get-started/locally). + + + Instrucciones de Instalación de PyTorch + + +## Usar Ultralytics con CLI + +La interfaz de línea de comandos (CLI) de Ultralytics permite el uso de comandos simples de una sola línea sin la necesidad de un entorno de Python. La CLI no requiere personalización ni código Python. Puedes simplemente ejecutar todas las tareas desde el terminal con el comando `yolo`. Consulta la [Guía de CLI](../usage/cli.md) para aprender más sobre el uso de YOLOv8 desde la línea de comandos. + +!!! example + + === "Sintaxis" + + Los comandos `yolo` de Ultralytics usan la siguiente sintaxis: + ```bash + yolo TAREA MODO ARGUMENTOS + + Donde TAREA (opcional) es uno de [detectar, segmentar, clasificar] + MODO (requerido) es uno de [train, val, predict, export, track] + ARGUMENTOS (opcionales) son cualquier número de pares personalizados 'arg=valor' como 'imgsz=320' que sobrescriben los valores por defecto. + ``` + Ver todos los ARGUMENTOS en la guía completa [Configuration Guide](../usage/cfg.md) o con `yolo cfg` + + === "Entrenar" + + Entrenar un modelo de detección durante 10 épocas con una tasa de aprendizaje inicial de 0.01 + ```bash + yolo train data=coco128.yaml model=yolov8n.pt epochs=10 lr0=0.01 + ``` + + === "Predecir" + + Predecir un video de YouTube usando un modelo de segmentación preentrenado con un tamaño de imagen de 320: + ```bash + yolo predict model=yolov8n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320 + ``` + + === "Validar" + + Validar un modelo de detección preentrenado con un tamaño de lote de 1 y un tamaño de imagen de 640: + ```bash + yolo val model=yolov8n.pt data=coco128.yaml batch=1 imgsz=640 + ``` + + === "Exportar" + + Exportar un modelo de clasificación YOLOv8n a formato ONNX con un tamaño de imagen de 224 por 128 (no se requiere TAREA) + ```bash + yolo export model=yolov8n-cls.pt format=onnx imgsz=224,128 + ``` + + === "Especial" + + Ejecutar comandos especiales para ver la versión, ver configuraciones, ejecutar chequeos y más: + ```bash + yolo help + yolo checks + yolo version + yolo settings + yolo copy-cfg + yolo cfg + ``` + +!!! warning "Advertencia" + + Los argumentos deben pasarse como pares `arg=valor`, separados por un signo igual `=` y delimitados por espacios ` ` entre pares. No utilices prefijos de argumentos `--` ni comas `,` entre los argumentos. + + - `yolo predict model=yolov8n.pt imgsz=640 conf=0.25`   ✅ + - `yolo predict model yolov8n.pt imgsz 640 conf 0.25`   ❌ + - `yolo predict --model yolov8n.pt --imgsz 640 --conf 0.25`   ❌ + +[Guía de CLI](../usage/cli.md){.md-button .md-button--primary} + +## Usar Ultralytics con Python + +La interfaz de Python de YOLOv8 permite una integración perfecta en tus proyectos de Python, facilitando la carga, ejecución y procesamiento de la salida del modelo. Diseñada con sencillez y facilidad de uso en mente, la interfaz de Python permite a los usuarios implementar rápidamente la detección de objetos, segmentación y clasificación en sus proyectos. Esto hace que la interfaz de Python de YOLOv8 sea una herramienta invaluable para cualquier persona que busque incorporar estas funcionalidades en sus proyectos de Python. + +Por ejemplo, los usuarios pueden cargar un modelo, entrenarlo, evaluar su rendimiento en un conjunto de validación e incluso exportarlo al formato ONNX con solo unas pocas líneas de código. Consulta la [Guía de Python](../usage/python.md) para aprender más sobre el uso de YOLOv8 dentro de tus proyectos de Python. + +!!! example + + ```python + from ultralytics import YOLO + + # Crear un nuevo modelo YOLO desde cero + model = YOLO('yolov8n.yaml') + + # Cargar un modelo YOLO preentrenado (recomendado para entrenamiento) + model = YOLO('yolov8n.pt') + + # Entrenar el modelo usando el conjunto de datos 'coco128.yaml' durante 3 épocas + results = model.train(data='coco128.yaml', epochs=3) + + # Evaluar el rendimiento del modelo en el conjunto de validación + results = model.val() + + # Realizar detección de objetos en una imagen usando el modelo + results = model('https://ultralytics.com/images/bus.jpg') + + # Exportar el modelo al formato ONNX + success = model.export(format='onnx') + ``` + +[Guía de Python](../usage/python.md){.md-button .md-button--primary} diff --git a/docs/es/tasks/classify.md b/docs/es/tasks/classify.md new file mode 100644 index 00000000..8127aca0 --- /dev/null +++ b/docs/es/tasks/classify.md @@ -0,0 +1,172 @@ +--- +comments: true +description: Aprenda sobre los modelos de clasificación de imágenes YOLOv8 Classify. Obtenga información detallada sobre la Lista de Modelos Preentrenados y cómo Entrenar, Validar, Predecir y Exportar modelos. +keywords: Ultralytics, YOLOv8, Clasificación de imágenes, Modelos preentrenados, YOLOv8n-cls, Entrenamiento, Validación, Predicción, Exportación de modelos +--- + +# Clasificación de Imágenes + +Ejemplos de clasificación de imágenes + +La clasificación de imágenes es la tarea más sencilla de las tres y consiste en clasificar una imagen completa en una de un conjunto de clases predefinidas. + +La salida de un clasificador de imágenes es una única etiqueta de clase y una puntuación de confianza. La clasificación de imágenes es útil cuando solo necesita saber a qué clase pertenece una imagen y no necesita conocer dónde están ubicados los objetos de esa clase o cuál es su forma exacta. + +!!! tip "Consejo" + + Los modelos YOLOv8 Classify utilizan el sufijo `-cls`, por ejemplo, `yolov8n-cls.pt` y están preentrenados en [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml). + +## [Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8) + +Los modelos Classify preentrenados YOLOv8 se muestran aquí. Los modelos Detect, Segment y Pose están preentrenados en el conjunto de datos [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), mientras que los modelos Classify están preentrenados en el conjunto de datos [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml). + +Los [modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) se descargan automáticamente desde el último [lanzamiento](https://github.com/ultralytics/assets/releases) de Ultralytics en el primer uso. + +| Modelo | Tamaño
(píxeles) | Exactitud
top1 | Exactitud
top5 | Velocidad
CPU ONNX
(ms) | Velocidad
A100 TensorRT
(ms) | Parámetros
(M) | FLOPs
(B) en 640 | +|----------------------------------------------------------------------------------------------|--------------------------|------------------------|------------------------|------------------------------------|-----------------------------------------|------------------------|--------------------------| +| [YOLOv8n-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-cls.pt) | 224 | 66.6 | 87.0 | 12.9 | 0.31 | 2.7 | 4.3 | +| [YOLOv8s-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-cls.pt) | 224 | 72.3 | 91.1 | 23.4 | 0.35 | 6.4 | 13.5 | +| [YOLOv8m-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-cls.pt) | 224 | 76.4 | 93.2 | 85.4 | 0.62 | 17.0 | 42.7 | +| [YOLOv8l-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-cls.pt) | 224 | 78.0 | 94.1 | 163.0 | 0.87 | 37.5 | 99.7 | +| [YOLOv8x-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-cls.pt) | 224 | 78.4 | 94.3 | 232.0 | 1.01 | 57.4 | 154.8 | + +- Los valores de **Exactitud** son las precisiones de los modelos en el conjunto de datos de validación de [ImageNet](https://www.image-net.org/). +
Para reproducir usar `yolo val classify data=path/to/ImageNet device=0` +- **Velocidad** promediada sobre imágenes de validación de ImageNet usando una instancia de [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) +
Para reproducir usar `yolo val classify data=path/to/ImageNet batch=1 device=0|cpu` + +## Entrenamiento + +Entrena el modelo YOLOv8n-cls en el conjunto de datos MNIST160 durante 100 épocas con un tamaño de imagen de 64. Para obtener una lista completa de argumentos disponibles, consulte la página de [Configuración](../../usage/cfg.md). + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Cargar un modelo + model = YOLO('yolov8n-cls.yaml') # construir un nuevo modelo desde YAML + model = YOLO('yolov8n-cls.pt') # cargar un modelo preentrenado (recomendado para entrenamiento) + model = YOLO('yolov8n-cls.yaml').load('yolov8n-cls.pt') # construir desde YAML y transferir pesos + + # Entrenar el modelo + results = model.train(data='mnist160', epochs=100, imgsz=64) + ``` + + === "CLI" + + ```bash + # Construir un nuevo modelo desde YAML y empezar entrenamiento desde cero + yolo classify train data=mnist160 model=yolov8n-cls.yaml epochs=100 imgsz=64 + + # Empezar entrenamiento desde un modelo *.pt preentrenado + yolo classify train data=mnist160 model=yolov8n-cls.pt epochs=100 imgsz=64 + + # Construir un nuevo modelo desde YAML, transferir pesos preentrenados e iniciar entrenamiento + yolo classify train data=mnist160 model=yolov8n-cls.yaml pretrained=yolov8n-cls.pt epochs=100 imgsz=64 + ``` + +### Formato del conjunto de datos + +El formato del conjunto de datos de clasificación YOLO puede encontrarse en detalle en la [Guía de Conjuntos de Datos](../../datasets/classify/index.md). + +## Validación + +Validar la exactitud del modelo YOLOv8n-cls entrenado en el conjunto de datos MNIST160. No es necesario pasar ningún argumento ya que el `modelo` retiene su `data` y argumentos como atributos del modelo. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Cargar un modelo + model = YOLO('yolov8n-cls.pt') # cargar un modelo oficial + model = YOLO('path/to/best.pt') # cargar un modelo personalizado + + # Validar el modelo + metrics = model.val() # no se necesitan argumentos, el conjunto de datos y configuraciones se recuerdan + metrics.top1 # precisión top1 + metrics.top5 # precisión top5 + ``` + === "CLI" + + ```bash + yolo classify val model=yolov8n-cls.pt # validar modelo oficial + yolo classify val model=path/to/best.pt # validar modelo personalizado + ``` + +## Predicción + +Usar un modelo YOLOv8n-cls entrenado para realizar predicciones en imágenes. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Cargar un modelo + model = YOLO('yolov8n-cls.pt') # cargar un modelo oficial + model = YOLO('path/to/best.pt') # cargar un modelo personalizado + + # Predecir con el modelo + results = model('https://ultralytics.com/images/bus.jpg') # predecir en una imagen + ``` + === "CLI" + + ```bash + yolo classify predict model=yolov8n-cls.pt source='https://ultralytics.com/images/bus.jpg' # predecir con modelo oficial + yolo classify predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # predecir con modelo personalizado + ``` + +Ver detalles completos del modo `predict` en la página de [Predicción](https://docs.ultralytics.com/modes/predict/). + +## Exportación + +Exportar un modelo YOLOv8n-cls a un formato diferente como ONNX, CoreML, etc. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Cargar un modelo + model = YOLO('yolov8n-cls.pt') # cargar un modelo oficial + model = YOLO('path/to/best.pt') # cargar un modelo entrenado personalizado + + # Exportar el modelo + model.export(format='onnx') + ``` + === "CLI" + + ```bash + yolo export model=yolov8n-cls.pt format=onnx # exportar modelo oficial + yolo export model=path/to/best.pt format=onnx # exportar modelo entrenado personalizado + ``` + +Los formatos de exportación disponibles para YOLOv8-cls se encuentran en la tabla a continuación. Puede predecir o validar directamente en modelos exportados, por ejemplo, `yolo predict model=yolov8n-cls.onnx`. Ejemplos de uso se muestran para su modelo después de que se completa la exportación. + +| Formato | Argumento `format` | Modelo | Metadatos | Argumentos | +|--------------------------------------------------------------------|--------------------|-------------------------------|-----------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n-cls.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-cls.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-cls.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-cls_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-cls.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-cls.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-cls_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-cls.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-cls.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-cls_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-cls_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-cls_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-cls_ncnn_model/` | ✅ | `imgsz`, `half` | + +Vea detalles completos de `exportación` en la página de [Exportación](https://docs.ultralytics.com/modes/export/). diff --git a/docs/es/tasks/detect.md b/docs/es/tasks/detect.md new file mode 100644 index 00000000..3f0a7fc3 --- /dev/null +++ b/docs/es/tasks/detect.md @@ -0,0 +1,184 @@ +--- +comments: true +description: Documentación oficial de YOLOv8 de Ultralytics. Aprende a entrenar, validar, predecir y exportar modelos en varios formatos. Incluyendo estadísticas detalladas de rendimiento. +keywords: YOLOv8, Ultralytics, detección de objetos, modelos preentrenados, entrenamiento, validación, predicción, exportación de modelos, COCO, ImageNet, PyTorch, ONNX, CoreML +--- + +# Detección de Objetos + +Ejemplos de detección de objetos + +La detección de objetos es una tarea que implica identificar la ubicación y clase de objetos en una imagen o flujo de video. + +La salida de un detector de objetos es un conjunto de cajas delimitadoras que encierran a los objetos en la imagen, junto con etiquetas de clase y puntajes de confianza para cada caja. La detección de objetos es una buena opción cuando necesitas identificar objetos de interés en una escena, pero no necesitas saber exactamente dónde se encuentra el objeto o su forma exacta. + +

+
+ +
+ Ver: Detección de Objetos con Modelo Preentrenado YOLOv8 de Ultralytics. +

+ +!!! tip "Consejo" + + Los modelos YOLOv8 Detect son los modelos predeterminados de YOLOv8, es decir, `yolov8n.pt` y están preentrenados en [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml). + +## [Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8) + +Los modelos preentrenados de YOLOv8 Detect se muestran aquí. Los modelos de Detect, Segment y Pose están preentrenados en el conjunto de datos [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), mientras que los modelos de Classify están preentrenados en el conjunto de datos [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml). + +Los [modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) se descargan automáticamente desde el último lanzamiento de Ultralytics [release](https://github.com/ultralytics/assets/releases) en el primer uso. + +| Modelo | tamaño
(píxeles) | mAPval
50-95 | Velocidad
CPU ONNX
(ms) | Velocidad
A100 TensorRT
(ms) | parámetros
(M) | FLOPs
(B) | +|--------------------------------------------------------------------------------------|--------------------------|----------------------|------------------------------------|-----------------------------------------|------------------------|-------------------| +| [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n.pt) | 640 | 37.3 | 80.4 | 0.99 | 3.2 | 8.7 | +| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s.pt) | 640 | 44.9 | 128.4 | 1.20 | 11.2 | 28.6 | +| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m.pt) | 640 | 50.2 | 234.7 | 1.83 | 25.9 | 78.9 | +| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l.pt) | 640 | 52.9 | 375.2 | 2.39 | 43.7 | 165.2 | +| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x.pt) | 640 | 53.9 | 479.1 | 3.53 | 68.2 | 257.8 | + +- Los valores de **mAPval** son para un solo modelo a una sola escala en el conjunto de datos [COCO val2017](http://cocodataset.org). +
Reproduce utilizando `yolo val detect data=coco.yaml device=0` +- La **Velocidad** es el promedio sobre las imágenes de COCO val utilizando una instancia [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/). +
Reproduce utilizando `yolo val detect data=coco128.yaml batch=1 device=0|cpu` + +## Entrenamiento + +Entrena a YOLOv8n en el conjunto de datos COCO128 durante 100 épocas a tamaño de imagen 640. Para una lista completa de argumentos disponibles, consulta la página [Configuración](../../usage/cfg.md). + +!!! ejemplo "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Cargar un modelo + model = YOLO('yolov8n.yaml') # construye un nuevo modelo desde YAML + model = YOLO('yolov8n.pt') # carga un modelo preentrenado (recomendado para entrenamiento) + model = YOLO('yolov8n.yaml').load('yolov8n.pt') # construye desde YAML y transfiere los pesos + + # Entrenar el modelo + results = model.train(data='coco128.yaml', epochs=100, imgsz=640) + ``` + === "CLI" + + ```bash + # Construir un nuevo modelo desde YAML y comenzar entrenamiento desde cero + yolo detect train data=coco128.yaml model=yolov8n.yaml epochs=100 imgsz=640 + + # Comenzar entrenamiento desde un modelo *.pt preentrenado + yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 + + # Construir un nuevo modelo desde YAML, transferir pesos preentrenados y comenzar entrenamiento + yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640 + ``` + +### Formato del conjunto de datos + +El formato del conjunto de datos de detección de YOLO se puede encontrar en detalle en la [Guía de Conjuntos de Datos](../../datasets/detect/index.md). Para convertir tu conjunto de datos existente desde otros formatos (como COCO, etc.) al formato YOLO, por favor usa la herramienta [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) de Ultralytics. + +## Validación + +Valida la precisión del modelo YOLOv8n entrenado en el conjunto de datos COCO128. No es necesario pasar ningún argumento, ya que el `modelo` retiene sus datos de `entrenamiento` y argumentos como atributos del modelo. + +!!! ejemplo "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Cargar un modelo + model = YOLO('yolov8n.pt') # cargar un modelo oficial + model = YOLO('ruta/a/mejor.pt') # cargar un modelo personalizado + + # Validar el modelo + metrics = model.val() # sin argumentos necesarios, el conjunto de datos y configuraciones se recuerdan + metrics.box.map # map50-95 + metrics.box.map50 # map50 + metrics.box.map75 # map75 + metrics.box.maps # una lista contiene map50-95 de cada categoría + ``` + === "CLI" + + ```bash + yolo detect val model=yolov8n.pt # validar modelo oficial + yolo detect val model=ruta/a/mejor.pt # validar modelo personalizado + ``` + +## Predicción + +Utiliza un modelo YOLOv8n entrenado para realizar predicciones en imágenes. + +!!! ejemplo "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Cargar un modelo + model = YOLO('yolov8n.pt') # cargar un modelo oficial + model = YOLO('ruta/a/mejor.pt') # cargar un modelo personalizado + + # Predecir con el modelo + results = model('https://ultralytics.com/images/bus.jpg') # predecir en una imagen + ``` + === "CLI" + + ```bash + yolo detect predict model=yolov8n.pt source='https://ultralytics.com/images/bus.jpg' # predecir con modelo oficial + yolo detect predict model=ruta/a/mejor.pt source='https://ultralytics.com/images/bus.jpg' # predecir con modelo personalizado + ``` + +Consulta los detalles completos del modo `predict` en la página [Predicción](https://docs.ultralytics.com/modes/predict/). + +## Exportación + +Exporta un modelo YOLOv8n a un formato diferente como ONNX, CoreML, etc. + +!!! ejemplo "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Cargar un modelo + model = YOLO('yolov8n.pt') # cargar un modelo oficial + model = YOLO('ruta/a/mejor.pt') # cargar un modelo entrenado personalizado + + # Exportar el modelo + model.export(format='onnx') + ``` + === "CLI" + + ```bash + yolo export model=yolov8n.pt format=onnx # exportar modelo oficial + yolo export model=ruta/a/mejor.pt format=onnx # exportar modelo entrenado personalizado + ``` + +Los formatos de exportación de YOLOv8 disponibles se encuentran en la tabla a continuación. Puedes predecir o validar directamente en modelos exportados, es decir, `yolo predict model=yolov8n.onnx`. Ejemplos de uso se muestran para tu modelo después de que la exportación se completa. + +| Formato | Argumento `format` | Modelo | Metadata | Argumentos | +|--------------------------------------------------------------------|--------------------|----------------------------|----------|------------------------------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | ✅ | `imgsz`, `optimizar` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | ✅ | `imgsz`, `mitad`, `dinámico`, `simplificar`, `conjunto de operaciones` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `modelo_yolov8n_openvino/` | ✅ | `imgsz`, `mitad` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | ✅ | `imgsz`, `mitad`, `dinámico`, `simplificar`, `espacio de trabajo` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | ✅ | `imgsz`, `mitad`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `modelo_guardado_yolov8n/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | ✅ | `imgsz`, `mitad`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `modelo_web_yolov8n/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `modelo_yolov8n_paddle/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `modelo_ncnn_yolov8n/` | ✅ | `imgsz`, `mitad` | + +Consulta los detalles completos de la `exportación` en la página [Exportar](https://docs.ultralytics.com/modes/export/). diff --git a/docs/es/tasks/index.md b/docs/es/tasks/index.md new file mode 100644 index 00000000..a94edd24 --- /dev/null +++ b/docs/es/tasks/index.md @@ -0,0 +1,55 @@ +--- +comments: true +description: Aprenda sobre las tareas fundamentales de visión por computadora que YOLOv8 puede realizar, incluyendo detección, segmentación, clasificación y estimación de pose. Comprenda sus usos en sus proyectos de IA. +keywords: Ultralytics, YOLOv8, Detección, Segmentación, Clasificación, Estimación de Pose, Marco de IA, Tareas de Visión por Computadora +--- + +# Tareas de Ultralytics YOLOv8 + +
+Tareas soportadas por Ultralytics YOLO + +YOLOv8 es un marco de trabajo de IA que soporta múltiples **tareas** de visión por computadora. El marco puede usarse para realizar [detección](detect.md), [segmentación](segment.md), [clasificación](classify.md) y estimación de [pose](pose.md). Cada una de estas tareas tiene un objetivo y caso de uso diferente. + +!!! note + + 🚧 Nuestra documentación multilenguaje está actualmente en construcción y estamos trabajando arduamente para mejorarla. ¡Gracias por su paciencia! 🙏 + +

+
+ +
+ Mire: Explore las Tareas de Ultralytics YOLO: Detección de Objetos, Segmentación, Seguimiento y Estimación de Pose. +

+ +## [Detección](detect.md) + +La detección es la tarea principal soportada por YOLOv8. Implica detectar objetos en una imagen o cuadro de video y dibujar cuadros delimitadores alrededor de ellos. Los objetos detectados se clasifican en diferentes categorías basadas en sus características. YOLOv8 puede detectar múltiples objetos en una sola imagen o cuadro de video con alta precisión y velocidad. + +[Ejemplos de Detección](detect.md){ .md-button .md-button--primary} + +## [Segmentación](segment.md) + +La segmentación es una tarea que implica segmentar una imagen en diferentes regiones basadas en el contenido de la imagen. A cada región se le asigna una etiqueta basada en su contenido. Esta tarea es útil en aplicaciones tales como segmentación de imágenes y imágenes médicas. YOLOv8 utiliza una variante de la arquitectura U-Net para realizar la segmentación. + +[Ejemplos de Segmentación](segment.md){ .md-button .md-button--primary} + +## [Clasificación](classify.md) + +La clasificación es una tarea que implica clasificar una imagen en diferentes categorías. YOLOv8 puede usarse para clasificar imágenes basadas en su contenido. Utiliza una variante de la arquitectura EfficientNet para realizar la clasificación. + +[Ejemplos de Clasificación](classify.md){ .md-button .md-button--primary} + +## [Pose](pose.md) + +La detección de pose/puntos clave es una tarea que implica detectar puntos específicos en una imagen o cuadro de video. Estos puntos se conocen como puntos clave y se utilizan para rastrear el movimiento o la estimación de la pose. YOLOv8 puede detectar puntos clave en una imagen o cuadro de video con alta precisión y velocidad. + +[Ejemplos de Pose](pose.md){ .md-button .md-button--primary} + +## Conclusión + +YOLOv8 soporta múltiples tareas, incluyendo detección, segmentación, clasificación y detección de puntos clave. Cada una de estas tareas tiene diferentes objetivos y casos de uso. Al entender las diferencias entre estas tareas, puede elegir la tarea adecuada para su aplicación de visión por computadora. diff --git a/docs/es/tasks/pose.md b/docs/es/tasks/pose.md new file mode 100644 index 00000000..6ef59e6d --- /dev/null +++ b/docs/es/tasks/pose.md @@ -0,0 +1,185 @@ +--- +comments: true +description: Aprende a utilizar Ultralytics YOLOv8 para tareas de estimación de pose. Encuentra modelos preentrenados, aprende a entrenar, validar, predecir y exportar tus propios modelos. +keywords: Ultralytics, YOLO, YOLOv8, estimación de pose, detección de puntos clave, detección de objetos, modelos preentrenados, aprendizaje automático, inteligencia artificial +--- + +# Estimación de Pose + +Ejemplos de estimación de pose + +La estimación de pose es una tarea que implica identificar la ubicación de puntos específicos en una imagen, comúnmente referidos como puntos clave. Estos puntos clave pueden representar varias partes del objeto, como articulaciones, puntos de referencia u otras características distintivas. La ubicación de los puntos clave generalmente se representa como un conjunto de coordenadas 2D `[x, y]` o 3D `[x, y, visible]`. + +La salida de un modelo de estimación de pose es un conjunto de puntos que representan los puntos clave en un objeto de la imagen, generalmente junto con las puntuaciones de confianza para cada punto. La estimación de pose es una buena opción cuando se necesita identificar partes específicas de un objeto en una escena y su ubicación relativa entre ellas. + +

+
+ +
+ Ver: Estimación de Pose con Ultralytics YOLOv8. +

+ +!!! tip "Consejo" + + Los modelos _pose_ YOLOv8 utilizan el sufijo `-pose`, por ejemplo, `yolov8n-pose.pt`. Estos modelos están entrenados en el conjunto de datos [COCO keypoints](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco-pose.yaml) y son adecuados para una variedad de tareas de estimación de pose. + +## [Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8) + +Aquí se muestran los modelos preentrenados de YOLOv8 Pose. Los modelos Detect, Segment y Pose están preentrenados en el conjunto de datos [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), mientras que los modelos Classify están preentrenados en el conjunto de datos [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml). + +Los [modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) se descargan automáticamente desde el último lanzamiento de Ultralytics [release](https://github.com/ultralytics/assets/releases) en el primer uso. + +| Modelo | tamaño
(píxeles) | mAPpose
50-95 | mAPpose
50 | Velocidad
CPU ONNX
(ms) | Velocidad
A100 TensorRT
(ms) | parámetros
(M) | FLOPs
(B) | +|------------------------------------------------------------------------------------------------------|--------------------------|-----------------------|--------------------|------------------------------------|-----------------------------------------|------------------------|-------------------| +| [YOLOv8n-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-pose.pt) | 640 | 50.4 | 80.1 | 131.8 | 1.18 | 3.3 | 9.2 | +| [YOLOv8s-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-pose.pt) | 640 | 60.0 | 86.2 | 233.2 | 1.42 | 11.6 | 30.2 | +| [YOLOv8m-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-pose.pt) | 640 | 65.0 | 88.8 | 456.3 | 2.00 | 26.4 | 81.0 | +| [YOLOv8l-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-pose.pt) | 640 | 67.6 | 90.0 | 784.5 | 2.59 | 44.4 | 168.6 | +| [YOLOv8x-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose.pt) | 640 | 69.2 | 90.2 | 1607.1 | 3.73 | 69.4 | 263.2 | +| [YOLOv8x-pose-p6](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose-p6.pt) | 1280 | 71.6 | 91.2 | 4088.7 | 10.04 | 99.1 | 1066.4 | + +- Los valores de **mAPval** son para un solo modelo a una sola escala en el conjunto de datos [COCO Keypoints val2017](http://cocodataset.org). +
Reproducir con `yolo val pose data=coco-pose.yaml device=0` +- **Velocidad** promediada sobre imágenes COCO val usando una instancia [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/). +
Reproducir con `yolo val pose data=coco8-pose.yaml batch=1 device=0|cpu` + +## Entrenar + +Entrena un modelo YOLOv8-pose en el conjunto de datos COCO128-pose. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Cargar un modelo + model = YOLO('yolov8n-pose.yaml') # construir un nuevo modelo desde YAML + model = YOLO('yolov8n-pose.pt') # cargar un modelo preentrenado (recomendado para entrenar) + model = YOLO('yolov8n-pose.yaml').load('yolov8n-pose.pt') # construir desde YAML y transferir los pesos + + # Entrenar el modelo + results = model.train(data='coco8-pose.yaml', epochs=100, imgsz=640) + ``` + === "CLI" + + ```bash + # Construir un nuevo modelo desde YAML y comenzar entrenamiento desde cero + yolo pose train data=coco8-pose.yaml model=yolov8n-pose.yaml epochs=100 imgsz=640 + + # Empezar entrenamiento desde un modelo *.pt preentrenado + yolo pose train data=coco8-pose.yaml model=yolov8n-pose.pt epochs=100 imgsz=640 + + # Construir un nuevo modelo desde YAML, transferir pesos preentrenados y comenzar entrenamiento + yolo pose train data=coco8-pose.yaml model=yolov8n-pose.yaml pretrained=yolov8n-pose.pt epochs=100 imgsz=640 + ``` + +### Formato del conjunto de datos + +El formato del conjunto de datos de pose de YOLO se puede encontrar en detalle en la [Guía de Conjuntos de Datos](../../datasets/pose/index.md). Para convertir tu conjunto de datos existente de otros formatos (como COCO, etc.) al formato de YOLO, usa la herramienta [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) de Ultralytics. + +## Validar + +Valida la precisión del modelo YOLOv8n-pose entrenado en el conjunto de datos COCO128-pose. No es necesario pasar ningún argumento ya que el `modelo` mantiene sus `datos` de entrenamiento y argumentos como atributos del modelo. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Cargar un modelo + model = YOLO('yolov8n-pose.pt') # cargar un modelo oficial + model = YOLO('path/to/best.pt') # cargar un modelo personalizado + + # Validar el modelo + metrics = model.val() # no se necesitan argumentos, el conjunto de datos y configuraciones se recuerdan + metrics.box.map # map50-95 + metrics.box.map50 # map50 + metrics.box.map75 # map75 + metrics.box.maps # una lista contiene map50-95 de cada categoría + ``` + === "CLI" + + ```bash + yolo pose val model=yolov8n-pose.pt # modelo oficial de val + yolo pose val model=path/to/best.pt # modelo personalizado de val + ``` + +## Predecir + +Usa un modelo YOLOv8n-pose entrenado para realizar predicciones en imágenes. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Cargar un modelo + model = YOLO('yolov8n-pose.pt') # cargar un modelo oficial + model = YOLO('path/to/best.pt') # cargar un modelo personalizado + + # Predecir con el modelo + results = model('https://ultralytics.com/images/bus.jpg') # predecir en una imagen + ``` + === "CLI" + + ```bash + yolo pose predict model=yolov8n-pose.pt source='https://ultralytics.com/images/bus.jpg' # predecir con modelo oficial + yolo pose predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # predecir con modelo personalizado + ``` + +Consulta los detalles completos del modo `predict` en la página de [Predicción](https://docs.ultralytics.com/modes/predict/). + +## Exportar + +Exporta un modelo YOLOv8n Pose a un formato diferente como ONNX, CoreML, etc. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Cargar un modelo + model = YOLO('yolov8n-pose.pt') # cargar un modelo oficial + model = YOLO('path/to/best.pt') # cargar un modelo entrenado personalizado + + # Exportar el modelo + model.export(format='onnx') + ``` + === "CLI" + + ```bash + yolo export model=yolov8n-pose.pt format=onnx # exportar modelo oficial + yolo export model=path/to/best.pt format=onnx # exportar modelo entrenado personalizado + ``` + +Los formatos de exportación de YOLOv8-pose disponibles se muestran en la tabla a continuación. Puedes predecir o validar directamente en modelos exportados, por ejemplo, `yolo predict model=yolov8n-pose.onnx`. Los ejemplos de uso se muestran para tu modelo después de que la exportación se completa. + +| Formato | Argumento `format` | Modelo | Metadatos | Argumentos | +|--------------------------------------------------------------------|--------------------|--------------------------------|-----------|---------------------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n-pose.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-pose.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-pose.onnx` | ✅ | `imgsz`, `half`, `dinámico`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-pose_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-pose.engine` | ✅ | `imgsz`, `half`, `dinámico`, `simplify`, `espacio de trabajo` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-pose.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-pose_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-pose.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-pose.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-pose_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-pose_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-pose_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-pose_ncnn_model/` | ✅ | `imgsz`, `half` | + +Consulta los detalles completos del modo `export` en la página de [Exportación](https://docs.ultralytics.com/modes/export/). diff --git a/docs/es/tasks/segment.md b/docs/es/tasks/segment.md new file mode 100644 index 00000000..4b80382a --- /dev/null +++ b/docs/es/tasks/segment.md @@ -0,0 +1,188 @@ +--- +comments: true +description: Aprende a utilizar modelos de segmentación de instancias con Ultralytics YOLO. Instrucciones sobre entrenamiento, validación, predicción de imágenes y exportación de modelos. +keywords: yolov8, segmentación de instancias, Ultralytics, conjunto de datos COCO, segmentación de imágenes, detección de objetos, entrenamiento de modelos, validación de modelos, predicción de imágenes, exportación de modelos. +--- + +# Segmentación de Instancias + +Ejemplos de segmentación de instancias + +La segmentación de instancias va un paso más allá de la detección de objetos e implica identificar objetos individuales en una imagen y segmentarlos del resto de la imagen. + +La salida de un modelo de segmentación de instancias es un conjunto de máscaras o contornos que delimitan cada objeto en la imagen, junto con etiquetas de clase y puntajes de confianza para cada objeto. La segmentación de instancias es útil cuando necesitas saber no solo dónde están los objetos en una imagen, sino también cuál es su forma exacta. + +

+
+ +
+ Mira: Ejecuta la Segmentación con el Modelo Ultralytics YOLOv8 Preentrenado en Python. +

+ +!!! tip "Consejo" + + Los modelos YOLOv8 Segment utilizan el sufijo `-seg`, es decir, `yolov8n-seg.pt` y están preentrenados en el [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml). + +## [Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8) + +Aquí se muestran los modelos Segment preentrenados YOLOv8. Los modelos Detect, Segment y Pose están preentrenados en el conjunto de datos [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), mientras que los modelos Classify están preentrenados en el conjunto de datos [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml). + +Los [Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) se descargan automáticamente desde el último lanzamiento de Ultralytics [release](https://github.com/ultralytics/assets/releases) en su primer uso. + +| Modelo | Tamaño
(píxeles) | mAPcaja
50-95 | mAPmáscara
50-95 | Velocidad
CPU ONNX
(ms) | Velocidad
A100 TensorRT
(ms) | Parámetros
(M) | FLOPs
(B) | +|----------------------------------------------------------------------------------------------|--------------------------|-----------------------|--------------------------|------------------------------------|-----------------------------------------|------------------------|-------------------| +| [YOLOv8n-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-seg.pt) | 640 | 36.7 | 30.5 | 96.1 | 1.21 | 3.4 | 12.6 | +| [YOLOv8s-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-seg.pt) | 640 | 44.6 | 36.8 | 155.7 | 1.47 | 11.8 | 42.6 | +| [YOLOv8m-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-seg.pt) | 640 | 49.9 | 40.8 | 317.0 | 2.18 | 27.3 | 110.2 | +| [YOLOv8l-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-seg.pt) | 640 | 52.3 | 42.6 | 572.4 | 2.79 | 46.0 | 220.5 | +| [YOLOv8x-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-seg.pt) | 640 | 53.4 | 43.4 | 712.1 | 4.02 | 71.8 | 344.1 | + +- Los valores **mAPval** son para un único modelo a una única escala en el conjunto de datos [COCO val2017](http://cocodataset.org). +
Reproducir utilizando `yolo val segment data=coco.yaml device=0` +- La **Velocidad** promediada sobre imágenes de COCO val utilizando una instancia de [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/). +
Reproducir utilizando `yolo val segment data=coco128-seg.yaml batch=1 device=0|cpu` + +## Entrenamiento + +Entrena el modelo YOLOv8n-seg en el conjunto de datos COCO128-seg durante 100 épocas con tamaño de imagen de 640. Para una lista completa de argumentos disponibles, consulta la página de [Configuración](../../usage/cfg.md). + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Cargar un modelo + model = YOLO('yolov8n-seg.yaml') # construir un nuevo modelo desde YAML + model = YOLO('yolov8n-seg.pt') # cargar un modelo preentrenado (recomendado para entrenamiento) + model = YOLO('yolov8n-seg.yaml').load('yolov8n.pt') # construir desde YAML y transferir pesos + + # Entrenar el modelo + results = model.train(data='coco128-seg.yaml', epochs=100, imgsz=640) + ``` + === "CLI" + + ```bash + # Construir un nuevo modelo desde YAML y comenzar a entrenar desde cero + yolo segment train data=coco128-seg.yaml model=yolov8n-seg.yaml epochs=100 imgsz=640 + + # Comenzar a entrenar desde un modelo *.pt preentrenado + yolo segment train data=coco128-seg.yaml model=yolov8n-seg.pt epochs=100 imgsz=640 + + # Construir un nuevo modelo desde YAML, transferir pesos preentrenados y comenzar a entrenar + yolo segment train data=coco128-seg.yaml model=yolov8n-seg.yaml pretrained=yolov8n-seg.pt epochs=100 imgsz=640 + ``` + +### Formato del conjunto de datos + +El formato del conjunto de datos de segmentación YOLO puede encontrarse detallado en la [Guía de Conjuntos de Datos](../../datasets/segment/index.md). Para convertir tu conjunto de datos existente de otros formatos (como COCO, etc.) al formato YOLO, utiliza la herramienta [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) de Ultralytics. + +## Validación + +Valida la precisión del modelo YOLOv8n-seg entrenado en el conjunto de datos COCO128-seg. No es necesario pasar ningún argumento ya que el `modelo` retiene sus `datos` de entrenamiento y argumentos como atributos del modelo. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Cargar un modelo + model = YOLO('yolov8n-seg.pt') # cargar un modelo oficial + model = YOLO('ruta/a/mejor.pt') # cargar un modelo personalizado + + # Validar el modelo + metrics = model.val() # no se necesitan argumentos, el conjunto de datos y configuraciones se recuerdan + metrics.box.map # map50-95(B) + metrics.box.map50 # map50(B) + metrics.box.map75 # map75(B) + metrics.box.maps # una lista contiene map50-95(B) de cada categoría + metrics.seg.map # map50-95(M) + metrics.seg.map50 # map50(M) + metrics.seg.map75 # map75(M) + metrics.seg.maps # una lista contiene map50-95(M) de cada categoría + ``` + === "CLI" + + ```bash + yolo segment val model=yolov8n-seg.pt # validar el modelo oficial + yolo segment val model=ruta/a/mejor.pt # validar el modelo personalizado + ``` + +## Predicción + +Usa un modelo YOLOv8n-seg entrenado para realizar predicciones en imágenes. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Cargar un modelo + model = YOLO('yolov8n-seg.pt') # cargar un modelo oficial + model = YOLO('ruta/a/mejor.pt') # cargar un modelo personalizado + + # Predecir con el modelo + results = model('https://ultralytics.com/images/bus.jpg') # predecir en una imagen + ``` + === "CLI" + + ```bash + yolo segment predict model=yolov8n-seg.pt source='https://ultralytics.com/images/bus.jpg' # predecir con el modelo oficial + yolo segment predict model=ruta/a/mejor.pt source='https://ultralytics.com/images/bus.jpg' # predecir con el modelo personalizado + ``` + +Consulta todos los detalles del modo `predict` en la página de [Predicción](https://docs.ultralytics.com/modes/predict/). + +## Exportación + +Exporta un modelo YOLOv8n-seg a un formato diferente como ONNX, CoreML, etc. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Cargar un modelo + model = YOLO('yolov8n-seg.pt') # cargar un modelo oficial + model = YOLO('ruta/a/mejor.pt') # cargar un modelo entrenado personalizado + + # Exportar el modelo + model.export(format='onnx') + ``` + === "CLI" + + ```bash + yolo export model=yolov8n-seg.pt format=onnx # exportar el modelo oficial + yolo export model=ruta/a/mejor.pt format=onnx # exportar el modelo entrenado personalizado + ``` + +Los formatos disponibles para exportar YOLOv8-seg se muestran en la tabla a continuación. Puedes predecir o validar directamente en modelos exportados, es decir, `yolo predict model=yolov8n-seg.onnx`. Se muestran ejemplos de uso para tu modelo después de que se completa la exportación. + +| Formato | Argumento `format` | Modelo | Metadatos | Argumentos | +|--------------------------------------------------------------------|--------------------|-------------------------------|-----------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n-seg.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-seg.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-seg.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-seg_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-seg.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-seg.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-seg_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-seg.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-seg.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-seg_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-seg_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-seg_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-seg_ncnn_model/` | ✅ | `imgsz`, `half` | + +Consulta todos los detalles del modo `export` en la página de [Exportación](https://docs.ultralytics.com/modes/export/). diff --git a/docs/fr/datasets/index.md b/docs/fr/datasets/index.md new file mode 100644 index 00000000..9ac5643f --- /dev/null +++ b/docs/fr/datasets/index.md @@ -0,0 +1,127 @@ +--- +comments: true +description: Explorez divers ensembles de données de vision par ordinateur pris en charge par Ultralytics pour la détection d'objets, la segmentation, l'estimation de la pose, la classification d'images et le suivi multi-objets. +keywords: vision par ordinateur, ensembles de données, Ultralytics, YOLO, détection d'objets, segmentation d'instance, estimation de la pose, classification d'images, suivi multi-objets +--- + +# Aperçu des ensembles de données + +Ultralytics fournit un soutien pour divers ensembles de données pour faciliter les tâches de vision par ordinateur telles que la détection, la segmentation d'instance, l'estimation de la pose, la classification et le suivi multi-objets. Ci-dessous se trouve une liste des principaux ensembles de données Ultralytics, suivie d'un résumé de chaque tâche de vision par ordinateur et des ensembles de données respectifs. + +!!! note + + 🚧 Notre documentation multilingue est actuellement en cours de construction et nous travaillons dur pour l'améliorer. Merci de votre patience ! 🙏 + +## [Ensembles de données de détection](../../datasets/detect/index.md) + +La détection d'objets par boîte englobante est une technique de vision par ordinateur qui consiste à détecter et localiser des objets dans une image en dessinant une boîte englobante autour de chaque objet. + +- [Argoverse](../../datasets/detect/argoverse.md) : Un ensemble de données contenant des données de suivi 3D et de prévision de mouvement dans des environnements urbains avec des annotations détaillées. +- [COCO](../../datasets/detect/coco.md) : Un ensemble de données de grande échelle conçu pour la détection d'objets, la segmentation et l'annotation avec plus de 200K images étiquetées. +- [COCO8](../../datasets/detect/coco8.md) : Contient les 4 premières images de COCO train et COCO val, adaptées pour des tests rapides. +- [Global Wheat 2020](../../datasets/detect/globalwheat2020.md) : Un ensemble de données d'images de têtes de blé recueillies dans le monde entier pour les tâches de détection et de localisation d'objets. +- [Objects365](../../datasets/detect/objects365.md) : Un ensemble de données de grande qualité et à grande échelle pour la détection d'objets avec 365 catégories d'objets et plus de 600K images annotées. +- [OpenImagesV7](../../datasets/detect/open-images-v7.md) : Un ensemble de données complet de Google avec 1.7M d'images d'entraînement et 42k images de validation. +- [SKU-110K](../../datasets/detect/sku-110k.md) : Un ensemble de données mettant en vedette la détection d'objets denses dans les environnements de vente au détail avec plus de 11K images et 1.7 million de boîtes englobantes. +- [VisDrone](../../datasets/detect/visdrone.md) : Un ensemble de données contenant des données de détection d'objets et de suivi multi-objets à partir d'images capturées par drone avec plus de 10K images et séquences vidéo. +- [VOC](../../datasets/detect/voc.md) : L'ensemble de données de classes d'objets visuels Pascal (VOC) pour la détection d'objets et la segmentation avec 20 classes d'objets et plus de 11K images. +- [xView](../../datasets/detect/xview.md) : Un ensemble de données pour la détection d'objets dans l'imagerie aérienne avec 60 catégories d'objets et plus d'un million d'objets annotés. + +## [Ensembles de données de segmentation d'instance](../../datasets/segment/index.md) + +La segmentation d'instance est une technique de vision par ordinateur qui consiste à identifier et localiser des objets dans une image au niveau des pixels. + +- [COCO](../../datasets/segment/coco.md) : Un ensemble de données de grande échelle conçu pour la détection d'objets, la segmentation et les tâches d'annotation avec plus de 200K images étiquetées. +- [COCO8-seg](../../datasets/segment/coco8-seg.md) : Un ensemble de données plus petit pour les tâches de segmentation d'instance, contenant un sous-ensemble de 8 images COCO avec des annotations de segmentation. + +## [Estimation de pose](../../datasets/pose/index.md) + +L'estimation de la pose est une technique utilisée pour déterminer la pose de l'objet par rapport à la caméra ou au système de coordonnées mondial. + +- [COCO](../../datasets/pose/coco.md) : Un ensemble de données de grande échelle avec des annotations de poses humaines conçu pour les tâches d'estimation de la pose. +- [COCO8-pose](../../datasets/pose/coco8-pose.md) : Un ensemble de données plus petit pour les tâches d'estimation de la pose, contenant un sous-ensemble de 8 images COCO avec des annotations de pose humaine. +- [Tiger-pose](../../datasets/pose/tiger-pose.md) : Un ensemble de données compact composé de 263 images centrées sur les tigres, annotées avec 12 points par tigre pour les tâches d'estimation de la pose. + +## [Classification](../../datasets/classify/index.md) + +La classification d'images est une tâche de vision par ordinateur qui implique de catégoriser une image dans une ou plusieurs classes ou catégories prédéfinies en fonction de son contenu visuel. + +- [Caltech 101](../../datasets/classify/caltech101.md) : Un ensemble de données contenant des images de 101 catégories d'objets pour les tâches de classification d'images. +- [Caltech 256](../../datasets/classify/caltech256.md) : Une version étendue de Caltech 101 avec 256 catégories d'objets et des images plus complexes. +- [CIFAR-10](../../datasets/classify/cifar10.md) : Un ensemble de données de 60K images couleur 32x32 réparties en 10 classes, avec 6K images par classe. +- [CIFAR-100](../../datasets/classify/cifar100.md) : Une version étendue de CIFAR-10 avec 100 catégories d'objets et 600 images par classe. +- [Fashion-MNIST](../../datasets/classify/fashion-mnist.md) : Un ensemble de données composé de 70 000 images en niveaux de gris de 10 catégories de mode pour les tâches de classification d'images. +- [ImageNet](../../datasets/classify/imagenet.md) : Un ensemble de données à grande échelle pour la détection d'objets et la classification d'images avec plus de 14 millions d'images et 20 000 catégories. +- [ImageNet-10](../../datasets/classify/imagenet10.md) : Un sous-ensemble plus petit d'ImageNet avec 10 catégories pour des expériences et des tests plus rapides. +- [Imagenette](../../datasets/classify/imagenette.md) : Un sous-ensemble plus petit d'ImageNet qui contient 10 classes facilement distinctes pour un entraînement et des tests plus rapides. +- [Imagewoof](../../datasets/classify/imagewoof.md) : Un sous-ensemble d'ImageNet plus difficile contenant 10 catégories de races de chiens pour les tâches de classification d'images. +- [MNIST](../../datasets/classify/mnist.md) : Un ensemble de données de 70 000 images en niveaux de gris de chiffres manuscrits pour les tâches de classification d'images. + +## [Boîtes Englobantes Orientées (OBB)](../../datasets/obb/index.md) + +Les Boîtes Englobantes Orientées (OBB) sont une méthode en vision par ordinateur pour détecter des objets inclinés dans les images en utilisant des boîtes englobantes rotatives, souvent appliquée à l'imagerie aérienne et satellite. + +- [DOTAv2](../../datasets/obb/dota-v2.md) : Un ensemble de données d'imagerie aérienne populaire avec 1.7 million d'instances et 11 268 images. + +## [Suivi Multi-Objets](../../datasets/track/index.md) + +Le suivi multi-objets est une technique de vision par ordinateur qui consiste à détecter et suivre plusieurs objets dans le temps dans une séquence vidéo. + +- [Argoverse](../../datasets/detect/argoverse.md) : Un ensemble de données contenant des données de suivi 3D et de prévision de mouvement dans des environnements urbains avec des annotations détaillées pour les tâches de suivi multi-objets. +- [VisDrone](../../datasets/detect/visdrone.md) : Un ensemble de données contenant des données de détection d'objets et de suivi multi-objets à partir d'images capturées par drone avec plus de 10K images et séquences vidéo. + +## Contribuer de Nouveaux Ensembles de Données + +Contribuer un nouvel ensemble de données implique plusieurs étapes pour s'assurer qu'il s'aligne bien avec l'infrastructure existante. Voici les étapes nécessaires : + +### Étapes pour Contribuer un Nouvel Ensemble de Données + +1. **Collecter des Images** : Rassemblez les images qui appartiennent à l'ensemble de données. Celles-ci pourraient être collectées à partir de différentes sources, telles que des bases de données publiques ou votre propre collection. + +2. **Annoter des Images** : Annotez ces images avec des boîtes englobantes, des segments ou des points clés, en fonction de la tâche. + +3. **Exporter des Annotations** : Convertissez ces annotations au format de fichier YOLO *.txt pris en charge par Ultralytics. + +4. **Organiser l'Ensemble de Données** : Rangez votre ensemble de données dans la bonne structure de dossiers. Vous devriez avoir des répertoires de niveau supérieur `train/` et `val/`, et à l'intérieur de chacun, un sous-répertoire `images/` et `labels/`. + + ``` + dataset/ + ├── train/ + │ ├── images/ + │ └── labels/ + └── val/ + ├── images/ + └── labels/ + ``` + +5. **Créer un Fichier `data.yaml`** : Dans le répertoire racine de votre ensemble de données, créez un fichier `data.yaml` qui décrit l'ensemble de données, les classes et les autres informations nécessaires. + +6. **Optimiser les Images (Optionnel)** : Si vous souhaitez réduire la taille de l'ensemble de données pour un traitement plus efficace, vous pouvez optimiser les images en utilisant le code ci-dessous. Ceci n'est pas requis, mais recommandé pour des tailles d'ensemble de données plus petites et des vitesses de téléchargement plus rapides. + +7. **Zipper l'Ensemble de Données** : Compressez le dossier complet de l'ensemble de données dans un fichier zip. + +8. **Documenter et PR** : Créez une page de documentation décrivant votre ensemble de données et comment il s'intègre dans le cadre existant. Après cela, soumettez une Pull Request (PR). Référez-vous aux [lignes directrices de contribution Ultralytics](https://docs.ultralytics.com/help/contributing) pour plus de détails sur la manière de soumettre une PR. + +### Exemple de Code pour Optimiser et Zipper un Ensemble de Données + +!!! exemple "Optimiser et Zipper un Ensemble de Données" + + === "Python" + + ```python + from pathlib import Path + from ultralytics.data.utils import compress_one_image + from ultralytics.utils.downloads import zip_directory + + # Définir le répertoire de l'ensemble de données + path = Path('chemin/vers/ensemble-de-données') + + # Optimiser les images dans l'ensemble de données (optionnel) + for f in path.rglob('*.jpg'): + compress_one_image(f) + + # Zipper l'ensemble de données dans 'chemin/vers/ensemble-de-données.zip' + zip_directory(path) + ``` + +En suivant ces étapes, vous pouvez contribuer un nouvel ensemble de données qui s'intègre bien avec la structure existante d'Ultralytics. diff --git a/docs/fr/index.md b/docs/fr/index.md new file mode 100644 index 00000000..f4aa6a9c --- /dev/null +++ b/docs/fr/index.md @@ -0,0 +1,82 @@ +--- +comments: true +description: Découvrez un guide complet du modèle Ultralytics YOLOv8, un modèle de détection d'objets et de segmentation d'images à haute vitesse et haute précision. Tutoriels d'installation, de prédiction, d'entraînement et plus encore. +keywords: Ultralytics, YOLOv8, détection d'objets, segmentation d'images, apprentissage automatique, apprentissage profond, vision par ordinateur, installation de YOLOv8, prédiction avec YOLOv8, entraînement de YOLOv8, histoire de YOLO, licences de YOLO +--- + +
+

+ + Bannière Ultralytics YOLO +

+ GitHub Ultralytics + + LinkedIn Ultralytics + + Twitter Ultralytics + + YouTube Ultralytics + + TikTok Ultralytics + + Instagram Ultralytics + + Discord Ultralytics +
+
+ Intégration continue Ultralytics + Couverture de code Ultralytics + Citation YOLOv8 + Téléchargements Docker +
+ Exécuter sur Gradient + Ouvrir dans Colab + Ouvrir dans Kaggle +
+ +Présentation d'[Ultralytics](https://ultralytics.com) [YOLOv8](https://github.com/ultralytics/ultralytics), la dernière version du modèle réputé de détection d'objets en temps réel et de segmentation d'images. YOLOv8 est construit sur des avancées de pointe en apprentissage profond et vision par ordinateur, offrant des performances inégalées en termes de vitesse et de précision. Sa conception épurée le rend adapté à diverses applications et facilement adaptable à différentes plateformes matérielles, des appareils de bord aux API cloud. + +Explorez les Docs YOLOv8, une ressource complète conçue pour vous aider à comprendre et à utiliser ses fonctionnalités et capacités. Que vous soyez un praticien chevronné de l'apprentissage automatique ou nouveau dans le domaine, ce hub vise à maximiser le potentiel de YOLOv8 dans vos projets. + +!!! note + + 🚧 Notre documentation multilingue est actuellement en construction et nous travaillons dur pour l'améliorer. Merci de votre patience ! 🙏 + +## Par où commencer + +- **Installer** `ultralytics` avec pip et démarrer en quelques minutes   [:material-clock-fast: Commencer](quickstart.md){ .md-button } +- **Prédire** de nouvelles images et vidéos avec YOLOv8   [:octicons-image-16: Prédire sur Images](modes/predict.md){ .md-button } +- **Entraîner** un nouveau modèle YOLOv8 sur votre propre ensemble de données customisé   [:fontawesome-solid-brain: Entraîner un modèle](modes/train.md){ .md-button } +- **Explorer** les tâches YOLOv8 comme la segmentation, la classification, l'estimation de pose et le suivi   [:material-magnify-expand: Explorer les tâches](tasks/index.md){ .md-button } + +

+
+ +
+ Regarder : Comment entraîner un modèle YOLOv8 sur votre ensemble de données customisé dans Google Colab. +

+ +## YOLO : Un bref historique + +[YOLO](https://arxiv.org/abs/1506.02640) (You Only Look Once), un modèle populaire de détection d'objets et de segmentation d'images, a été développé par Joseph Redmon et Ali Farhadi à l'Université de Washington. Lancé en 2015, YOLO a rapidement gagné en popularité pour sa vitesse et sa précision élevées. + +- [YOLOv2](https://arxiv.org/abs/1612.08242), publié en 2016, a amélioré le modèle original en intégrant la normalisation par lots, les boîtes d'ancrage et les clusters de dimensions. +- [YOLOv3](https://pjreddie.com/media/files/papers/YOLOv3.pdf), lancé en 2018, a davantage amélioré la performance du modèle en utilisant un réseau dorsal plus efficace, des ancres multiples et un pool pyramidal spatial. +- [YOLOv4](https://arxiv.org/abs/2004.10934) a été publié en 2020, introduisant des innovations telles que l'augmentation de données Mosaic, une nouvelle tête de détection sans ancre et une nouvelle fonction de perte. +- [YOLOv5](https://github.com/ultralytics/yolov5) a encore amélioré la performance du modèle et a ajouté des fonctionnalités nouvelles telles que l'optimisation des hyperparamètres, le suivi intégré des expériences et l'export automatique vers des formats d'exportation populaires. +- [YOLOv6](https://github.com/meituan/YOLOv6) a été rendu open-source par [Meituan](https://about.meituan.com/) en 2022 et est utilisé dans de nombreux robots de livraison autonomes de l'entreprise. +- [YOLOv7](https://github.com/WongKinYiu/yolov7) a ajouté des tâches supplémentaires telles que l'estimation de pose sur le jeu de données de points clés COCO. +- [YOLOv8](https://github.com/ultralytics/ultralytics) est la dernière version de YOLO par Ultralytics. En tant que modèle de pointe et dernier cri (state-of-the-art, SOTA), YOLOv8 s'appuie sur le succès des versions précédentes, introduisant de nouvelles fonctionnalités et améliorations pour des performances, une flexibilité et une efficacité renforcées. YOLOv8 prend en charge une gamme complète de tâches d'intelligence artificielle visuelle, y compris la [détection](tasks/detect.md), la [segmentation](tasks/segment.md), l'[estimation de pose](tasks/pose.md), le [suivi](modes/track.md) et la [classification](tasks/classify.md). Cette polyvalence permet aux utilisateurs de tirer parti des capacités de YOLOv8 dans diverses applications et domaines. + +## Licences YOLO : Comment est licencié Ultralytics YOLO ? + +Ultralytics offre deux options de licence pour répondre aux différents cas d'utilisation : + +- **Licence AGPL-3.0** : Cette licence open source [approuvée par OSI](https://opensource.org/licenses/) est idéale pour les étudiants et les passionnés, favorisant la collaboration ouverte et le partage des connaissances. Voir le fichier [LICENSE](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) pour plus de détails. +- **Licence Enterprise** : Conçue pour un usage commercial, cette licence permet l'intégration transparente des logiciels et modèles d'IA Ultralytics dans des biens et services commerciaux, en contournant les exigences open source de l'AGPL-3.0. Si votre scénario implique l'incorporation de nos solutions dans une offre commerciale, n'hésitez pas à contacter [Ultralytics Licensing](https://ultralytics.com/license). + +Notre stratégie de licence est conçue pour garantir que toute amélioration de nos projets open source soit restituée à la communauté. Nous tenons les principes de l'open source à cœur ❤️, et notre mission est de garantir que nos contributions puissent être utilisées et développées de manière bénéfique pour tous. diff --git a/docs/fr/models/index.md b/docs/fr/models/index.md new file mode 100644 index 00000000..9e43374a --- /dev/null +++ b/docs/fr/models/index.md @@ -0,0 +1,94 @@ +--- +comments: true +description: Explorez la diversité des modèles YOLO, SAM, MobileSAM, FastSAM, YOLO-NAS et RT-DETR pris en charge par Ultralytics. Commencez avec des exemples d'utilisation pour CLI et Python. +keywords: Ultralytics, documentation, YOLO, SAM, MobileSAM, FastSAM, YOLO-NAS, RT-DETR, modèles, architectures, Python, CLI +--- + +# Modèles pris en charge par Ultralytics + +Bienvenue dans la documentation des modèles d'Ultralytics ! Nous proposons une prise en charge d'une large gamme de modèles, chacun adapté à des tâches spécifiques comme [la détection d'objets](../tasks/detect.md), [la segmentation d'instances](../tasks/segment.md), [la classification d'images](../tasks/classify.md), [l'estimation de posture](../tasks/pose.md) et [le suivi multi-objets](../modes/track.md). Si vous souhaitez contribuer avec votre architecture de modèle à Ultralytics, consultez notre [Guide de Contribution](../../help/contributing.md). + +!!! note + + 🚧 Notre documentation multilingue est actuellement en construction et nous travaillons activement à l'améliorer. Merci de votre patience ! 🙏 + +## Modèles en vedette + +Voici quelques-uns des modèles clés pris en charge : + +1. **[YOLOv3](../../models/yolov3.md)** : La troisième itération de la famille de modèles YOLO, originellement par Joseph Redmon, reconnue pour ses capacités de détection d'objets en temps réel efficaces. +2. **[YOLOv4](../../models/yolov4.md)** : Une mise à jour de YOLOv3 native de darknet, publiée par Alexey Bochkovskiy en 2020. +3. **[YOLOv5](../../models/yolov5.md)** : Une version améliorée de l'architecture YOLO par Ultralytics, offrant de meilleurs compromis de performance et de vitesse par rapport aux versions précédentes. +4. **[YOLOv6](../../models/yolov6.md)** : Publié par [Meituan](https://about.meituan.com/) en 2022, et utilisé dans de nombreux robots de livraison autonomes de l'entreprise. +5. **[YOLOv7](../../models/yolov7.md)** : Modèles YOLO mis à jour et sortis en 2022 par les auteurs de YOLOv4. +6. **[YOLOv8](../../models/yolov8.md)** : La dernière version de la famille YOLO, avec des capacités améliorées telles que la segmentation d’instances, l'estimation de pose/points clés, et la classification. +7. **[Segment Anything Model (SAM)](../../models/sam.md)** : Le modèle Segment Anything Model (SAM) de Meta. +8. **[Mobile Segment Anything Model (MobileSAM)](../../models/mobile-sam.md)** : MobileSAM pour les applications mobiles, par l'Université de Kyung Hee. +9. **[Fast Segment Anything Model (FastSAM)](../../models/fast-sam.md)** : FastSAM par le groupe d’Analyse Image et Vidéo, Institut d'Automatisation, Académie Chinoise des Sciences. +10. **[YOLO-NAS](../../models/yolo-nas.md)** : Modèles YOLO Neural Architecture Search (NAS). +11. **[Realtime Detection Transformers (RT-DETR)](../../models/rtdetr.md)** : Modèles de Realtime Detection Transformer (RT-DETR) de Baidu's PaddlePaddle. + +

+
+ +
+ Regardez : Exécutez les modèles YOLO d'Ultralytics en seulement quelques lignes de code. +

+ +## Pour commencer : Exemples d'utilisation + +!!! example "" + + === "Python" + + Les modèles préentrainés `*.pt` ainsi que les fichiers de configuration `*.yaml` peuvent être passés aux classes `YOLO()`, `SAM()`, `NAS()` et `RTDETR()` pour créer une instance du modèle en Python : + + ```python + from ultralytics import YOLO + + # Charger un modèle YOLOv8n préentrainé sur COCO + model = YOLO('yolov8n.pt') + + # Afficher les informations du modèle (optionnel) + model.info() + + # Entraîner le modèle sur l'exemple de jeu de données COCO8 pendant 100 époques + results = model.train(data='coco8.yaml', epochs=100, imgsz=640) + + # Exécuter l'inférence avec le modèle YOLOv8n sur l'image 'bus.jpg' + results = model('path/to/bus.jpg') + ``` + + === "CLI" + + Des commandes CLI sont disponibles pour exécuter directement les modèles : + + ```bash + # Charger un modèle YOLOv8n préentrainé sur COCO et l'entraîner sur l'exemple de jeu de données COCO8 pendant 100 époques + yolo train model=yolov8n.pt data=coco8.yaml epochs=100 imgsz=640 + + # Charger un modèle YOLOv8n préentrainé sur COCO et exécuter l'inférence sur l'image 'bus.jpg' + yolo predict model=yolov8n.pt source=path/to/bus.jpg + ``` + +## Contribuer de nouveaux modèles + +Intéressé à contribuer votre modèle à Ultralytics ? Super ! Nous sommes toujours ouverts à l'expansion de notre portefeuille de modèles. + +1. **Forker le Répertoire** : Commencez par forker le [répertoire GitHub d'Ultralytics](https://github.com/ultralytics/ultralytics). + +2. **Cloner Votre Fork** : Clonez votre fork sur votre machine locale et créez une nouvelle branche pour travailler dessus. + +3. **Implémenter Votre Modèle** : Ajoutez votre modèle en suivant les standards et directives de codage fournis dans notre [Guide de Contribution](../../help/contributing.md). + +4. **Tester Rigoureusement** : Assurez-vous de tester votre modèle de manière rigoureuse, à la fois isolément et en tant que partie du pipeline. + +5. **Créer une Pull Request** : Une fois que vous êtes satisfait de votre modèle, créez une demandе de tirage (pull request) vers le répertoire principal pour examen. + +6. **Revue de Code & Fusion** : Après la revue, si votre modèle répond à nos critères, il sera fusionné dans le répertoire principal. + +Pour des étapes détaillées, consultez notre [Guide de Contribution](../../help/contributing.md). diff --git a/docs/fr/modes/benchmark.md b/docs/fr/modes/benchmark.md new file mode 100644 index 00000000..671830a0 --- /dev/null +++ b/docs/fr/modes/benchmark.md @@ -0,0 +1,94 @@ +--- +comments: true +description: Apprenez comment profiler la vitesse et l'exactitude de YOLOv8 à travers divers formats d'exportation ; obtenez des insights sur les métriques mAP50-95, accuracy_top5 et plus. +keywords: Ultralytics, YOLOv8, benchmarking, profilage de vitesse, profilage de précision, mAP50-95, accuracy_top5, ONNX, OpenVINO, TensorRT, formats d'exportation YOLO +--- + +# Benchmarking de Modèles avec Ultralytics YOLO + +Écosystème Ultralytics YOLO et intégrations + +## Introduction + +Une fois votre modèle entraîné et validé, l'étape logique suivante est d'évaluer ses performances dans divers scénarios du monde réel. Le mode benchmark dans Ultralytics YOLOv8 répond à cet objectif en fournissant un cadre robuste pour évaluer la vitesse et l'exactitude de votre modèle sur une gamme de formats d'exportation. + +## Pourquoi le Benchmarking est-il Crucial ? + +- **Décisions Éclairées :** Obtenez des insights sur les arbitrages entre la vitesse et l'exactitude. +- **Allocation des Ressources :** Comprenez comment les différents formats d'exportation se comportent sur différents matériels. +- **Optimisation :** Découvrez quel format d'exportation offre la meilleure performance pour votre cas d'utilisation spécifique. +- **Efficacité des Coûts :** Utilisez les ressources matérielles plus efficacement en vous basant sur les résultats des benchmarks. + +### Mesures Clés en Mode Benchmark + +- **mAP50-95 :** Pour la détection d'objets, la segmentation et l'estimation de pose. +- **accuracy_top5 :** Pour la classification d'images. +- **Temps d'Inférence :** Temps pris pour chaque image en millisecondes. + +### Formats d'Exportation Supportés + +- **ONNX :** Pour une performance optimale sur CPU. +- **TensorRT :** Pour une efficacité maximale sur GPU. +- **OpenVINO :** Pour l'optimisation du matériel Intel. +- **CoreML, TensorFlow SavedModel, et Plus :** Pour des besoins variés de déploiement. + +!!! astuce "Conseil" + + * Exportez vers ONNX ou OpenVINO pour un gain de vitesse CPU jusqu'à 3x. + * Exportez vers TensorRT pour un gain de vitesse GPU jusqu'à 5x. + +## Exemples d'Utilisation + +Exécutez les benchmarks YOLOv8n sur tous les formats d'exportation supportés, y compris ONNX, TensorRT, etc. Consultez la section Arguments ci-dessous pour une liste complète des arguments d'exportation. + +!!! exemple "" + + === "Python" + + ```python + from ultralytics.utils.benchmarks import benchmark + + # Benchmark sur GPU + benchmark(model='yolov8n.pt', data='coco8.yaml', imgsz=640, half=False, device=0) + ``` + === "CLI" + + ```bash + yolo benchmark model=yolov8n.pt data='coco8.yaml' imgsz=640 half=False device=0 + ``` + +## Arguments + +Des arguments tels que `model`, `data`, `imgsz`, `half`, `device` et `verbose` offrent aux utilisateurs la flexibilité d'ajuster précisément les benchmarks à leurs besoins spécifiques et de comparer facilement les performances de différents formats d'exportation. + +| Clé | Valeur | Description | +|-----------|---------|---------------------------------------------------------------------------------------| +| `model` | `None` | chemin vers le fichier modèle, par ex. yolov8n.pt, yolov8n.yaml | +| `data` | `None` | chemin vers le YAML référençant le dataset de benchmarking (sous l'étiquette `val`) | +| `imgsz` | `640` | taille de l'image comme scalaire ou liste (h, w), par ex. (640, 480) | +| `half` | `False` | quantification FP16 | +| `int8` | `False` | quantification INT8 | +| `device` | `None` | appareil sur lequel exécuter, par ex. appareil cuda=0 ou device=0,1,2,3 ou device=cpu | +| `verbose` | `False` | ne pas continuer en cas d'erreur (bool), ou seuil de plancher val (float) | + +## Formats d'Exportation + +Les benchmarks tenteront de s'exécuter automatiquement sur tous les formats d'exportation possibles ci-dessous. + +| Format | Argument `format` | Modèle | Métadonnées | Arguments | +|--------------------------------------------------------------------|-------------------|---------------------------|-------------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | ✅ | `imgsz`, `half` | + +Consultez les détails complets sur `export` dans la page [Export](https://docs.ultralytics.com/modes/export/). diff --git a/docs/fr/modes/export.md b/docs/fr/modes/export.md new file mode 100644 index 00000000..79c1788e --- /dev/null +++ b/docs/fr/modes/export.md @@ -0,0 +1,108 @@ +--- +comments: true +description: Guide étape par étape sur l'exportation de vos modèles YOLOv8 vers divers formats tels que ONNX, TensorRT, CoreML et plus encore pour le déploiement. Explorez maintenant !. +keywords: YOLO, YOLOv8, Ultralytics, Exportation de modèle, ONNX, TensorRT, CoreML, TensorFlow SavedModel, OpenVINO, PyTorch, exporter un modèle +--- + +# Exportation de modèle avec Ultralytics YOLO + +Écosystème et intégrations Ultralytics YOLO + +## Introduction + +L'objectif ultime de l'entraînement d'un modèle est de le déployer pour des applications dans le monde réel. Le mode d'exportation de Ultralytics YOLOv8 offre une large gamme d'options pour exporter votre modèle entraîné dans différents formats, le rendant déployable sur diverses plateformes et appareils. Ce guide complet vise à vous guider à travers les nuances de l'exportation de modèles, en montrant comment atteindre une compatibilité et des performances maximales. + +

+
+ +
+ Regardez : Comment exporter un modèle Ultralytics YOLOv8 entraîné personnalisé et effectuer une inférence en direct sur webcam. +

+ +## Pourquoi choisir le mode d'exportation YOLOv8 ? + +- **Polyvalence :** Exportation vers plusieurs formats, y compris ONNX, TensorRT, CoreML et plus encore. +- **Performance :** Gagnez jusqu'à 5 fois la vitesse d'une GPU avec TensorRT et 3 fois la vitesse d'une CPU avec ONNX ou OpenVINO. +- **Compatibilité :** Rendez votre modèle universellement déployable sur de nombreux environnements matériels et logiciels. +- **Facilité d'utilisation :** Interface en ligne de commande (CLI) et API Python simples pour une exportation rapide et directe du modèle. + +### Caractéristiques clés du mode d'exportation + +Voici quelques-unes des fonctionnalités remarquables : + +- **Exportation en un clic :** Commandes simples pour exporter vers différents formats. +- **Exportation groupée :** Exportez des modèles capables d'inférence par lot. +- **Inférence optimisée :** Les modèles exportés sont optimisés pour des temps d'inférence plus rapides. +- **Vidéos tutorielles :** Guides détaillés et tutoriels pour une expérience d'exportation fluide. + +!!! astuce "Conseil" + + * Exportez vers ONNX ou OpenVINO pour une accélération de la CPU jusqu'à 3 fois. + * Exportez vers TensorRT pour une accélération de la GPU jusqu'à 5 fois. + +## Exemples d'utilisation + +Exportez un modèle YOLOv8n vers un format différent tel que ONNX ou TensorRT. Voir la section Arguments ci-dessous pour une liste complète des arguments d'exportation. + +!!! exemple "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Charger un modèle + model = YOLO('yolov8n.pt') # chargez un modèle officiel + model = YOLO('path/to/best.pt') # chargez un modèle entraîné personnalisé + + # Exporter le modèle + model.export(format='onnx') + ``` + === "CLI" + + ```bash + yolo export model=yolov8n.pt format=onnx # exporter modèle officiel + yolo export model=path/to/best.pt format=onnx # exporter modèle entraîné personnalisé + ``` + +## Arguments + +Les paramètres d'exportation pour les modèles YOLO se réfèrent aux diverses configurations et options utilisées pour sauvegarder ou exporter le modèle pour utilisation dans d'autres environnements ou plateformes. Ces paramètres peuvent affecter la performance, la taille et la compatibilité du modèle avec différents systèmes. Certains paramètres d'exportation YOLO courants incluent le format du fichier modèle exporté (par exemple, ONNX, TensorFlow SavedModel), le dispositif sur lequel le modèle sera exécuté (par exemple, CPU, GPU), et la présence de fonctionnalités supplémentaires telles que des masques ou des étiquettes multiples par boîte. D'autres facteurs qui peuvent affecter le processus d'exportation incluent la tâche spécifique pour laquelle le modèle est utilisé et les exigences ou contraintes de l'environnement ou de la plateforme cible. Il est important de considérer et de configurer ces paramètres avec soin pour s'assurer que le modèle exporté est optimisé pour le cas d'utilisation visé et peut être utilisé efficacement dans l'environnement cible. + +| Clé | Valeur | Description | +|-------------|-----------------|----------------------------------------------------------------------------------| +| `format` | `'torchscript'` | format vers lequel exporter | +| `imgsz` | `640` | taille d'image sous forme scalaire ou liste (h, w), par ex. (640, 480) | +| `keras` | `False` | utilisez Keras pour l'exportation TensorFlow SavedModel | +| `optimize` | `False` | TorchScript : optimisation pour mobile | +| `half` | `False` | quantification FP16 | +| `int8` | `False` | quantification INT8 | +| `dynamic` | `False` | ONNX/TensorRT : axes dynamiques | +| `simplify` | `False` | ONNX/TensorRT : simplifier le modèle | +| `opset` | `None` | ONNX : version de l'ensemble d'opérations (facultatif, par défaut à la dernière) | +| `workspace` | `4` | TensorRT : taille de l'espace de travail (GB) | +| `nms` | `False` | CoreML : ajout de la NMS | + +## Formats d'exportation + +Les formats d'exportation disponibles pour YOLOv8 sont dans le tableau ci-dessous. Vous pouvez exporter vers n'importe quel format en utilisant l'argument `format`, par ex. `format='onnx'` ou `format='engine'`. + +| Format | Argument `format` | Modèle | Métadonnées | Arguments | +|--------------------------------------------------------------------|-------------------|---------------------------|-------------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | ✅ | `imgsz`, `half` | diff --git a/docs/fr/modes/index.md b/docs/fr/modes/index.md new file mode 100644 index 00000000..46a47ae4 --- /dev/null +++ b/docs/fr/modes/index.md @@ -0,0 +1,73 @@ +--- +comments: true +description: De l'entraînement au suivi, exploitez au mieux YOLOv8 d'Ultralytics. Obtenez des aperçus et des exemples pour chaque mode pris en charge, y compris la validation, l'exportation et le benchmarking. +keywords: Ultralytics, YOLOv8, Machine Learning, Détection d'objets, Entraînement, Validation, Prédiction, Exportation, Suivi, Benchmarking +--- + +# Modes Ultralytics YOLOv8 + +Écosystème Ultralytics YOLO et intégrations + +## Introduction + +Ultralytics YOLOv8 n'est pas simplement un autre modèle de détection d'objets ; c'est un cadre polyvalent conçu pour couvrir l'intégralité du cycle de vie des modèles d'apprentissage automatique — de l'ingestion de données et l'entraînement des modèles à la validation, le déploiement et le suivi en conditions réelles. Chaque mode remplit un objectif spécifique et est conçu pour vous offrir la flexibilité et l'efficacité nécessaires pour différentes tâches et cas d'utilisation. + +

+
+ +
+ Regardez : Tutoriel sur les modes Ultralytics : Entraînement, Validation, Prédiction, Exportation & Benchmark. +

+ +### Aperçu des Modes + +Comprendre les différents **modes** pris en charge par Ultralytics YOLOv8 est crucial pour tirer le maximum de vos modèles : + +- **Mode d'entraînement (Train)** : Affinez votre modèle sur des jeux de données personnalisés ou préchargés. +- **Mode de validation (Val)** : Un contrôle post-entraînement pour évaluer la performance du modèle. +- **Mode de prédiction (Predict)** : Déployez la puissance prédictive de votre modèle sur des données du monde réel. +- **Mode d'exportation (Export)** : Préparez votre modèle au déploiement dans différents formats. +- **Mode de suivi (Track)** : Étendez votre modèle de détection d'objets à des applications de suivi en temps réel. +- **Mode benchmark (Benchmark)** : Analysez la vitesse et la précision de votre modèle dans divers environnements de déploiement. + +Ce guide complet vise à vous donner un aperçu et des informations pratiques sur chaque mode, en vous aidant à exploiter tout le potentiel de YOLOv8. + +## [Entraînement (Train)](train.md) + +Le mode d'entraînement est utilisé pour entraîner un modèle YOLOv8 sur un jeu de données personnalisé. Dans ce mode, le modèle est entraîné en utilisant le jeu de données et les hyperparamètres spécifiés. Le processus d'entraînement implique l'optimisation des paramètres du modèle afin qu'il puisse prédire avec précision les classes et les emplacements des objets dans une image. + +[Exemples d'entraînement](train.md){ .md-button .md-button--primary} + +## [Validation (Val)](val.md) + +Le mode de validation est utilisé pour valider un modèle YOLOv8 après qu'il ait été entraîné. Dans ce mode, le modèle est évalué sur un ensemble de validation pour mesurer sa précision et sa capacité de généralisation. Ce mode peut être utilisé pour ajuster les hyperparamètres du modèle afin d'améliorer ses performances. + +[Exemples de validation](val.md){ .md-button .md-button--primary} + +## [Prédiction (Predict)](predict.md) + +Le mode de prédiction est utilisé pour faire des prédictions à l'aide d'un modèle YOLOv8 entraîné sur de nouvelles images ou vidéos. Dans ce mode, le modèle est chargé à partir d'un fichier de checkpoint, et l'utilisateur peut fournir des images ou vidéos pour effectuer l'inférence. Le modèle prédit les classes et les emplacements des objets dans les images ou vidéos fournies. + +[Exemples de prédiction](predict.md){ .md-button .md-button--primary} + +## [Exportation (Export)](export.md) + +Le mode d'exportation est utilisé pour exporter un modèle YOLOv8 dans un format pouvant être utilisé pour le déploiement. Dans ce mode, le modèle est converti dans un format pouvant être utilisé par d'autres applications logicielles ou dispositifs matériels. Ce mode est pratique pour déployer le modèle dans des environnements de production. + +[Exemples d'exportation](export.md){ .md-button .md-button--primary} + +## [Suivi (Track)](track.md) + +Le mode de suivi est utilisé pour suivre des objets en temps réel à l'aide d'un modèle YOLOv8. Dans ce mode, le modèle est chargé à partir d'un fichier de checkpoint, et l'utilisateur peut fournir un flux vidéo en direct pour effectuer le suivi d'objets en temps réel. Ce mode est utile pour des applications telles que les systèmes de surveillance ou les voitures autonomes. + +[Exemples de suivi](track.md){ .md-button .md-button--primary} + +## [Benchmark (Benchmark)](benchmark.md) + +Le mode benchmark est utilisé pour profiler la vitesse et la précision de divers formats d'exportation pour YOLOv8. Les benchmarks fournissent des informations sur la taille du format exporté, ses métriques `mAP50-95` (pour la détection d'objets, la segmentation et la pose) ou `accuracy_top5` (pour la classification), et le temps d'inférence en millisecondes par image pour différents formats d'exportation comme ONNX, OpenVINO, TensorRT et autres. Ces informations peuvent aider les utilisateurs à choisir le format d'export optimal pour leur cas d'utilisation spécifique en fonction de leurs exigences de vitesse et de précision. + +[Exemples de benchmark](benchmark.md){ .md-button .md-button--primary} diff --git a/docs/fr/modes/predict.md b/docs/fr/modes/predict.md new file mode 100644 index 00000000..c1bd7e1f --- /dev/null +++ b/docs/fr/modes/predict.md @@ -0,0 +1,226 @@ +--- +comments: true +description: Découvrez comment utiliser le mode de prédiction YOLOv8 pour diverses tâches. Apprenez sur différentes sources d'inférence comme des images, vidéos et formats de données. +keywords: Ultralytics, YOLOv8, mode de prédiction, sources d'inférence, tâches de prédiction, mode streaming, traitement d'images, traitement vidéo, apprentissage automatique, IA +--- + +# Prédiction de Modèle avec Ultralytics YOLO + +Écosystème et intégrations Ultralytics YOLO + +## Introduction + +Dans l'univers de l'apprentissage automatique et de la vision par ordinateur, le processus de donner du sens aux données visuelles est appelé 'inférence' ou 'prédiction'. Ultralytics YOLOv8 propose une fonctionnalité puissante connue sous le nom de **mode de prédiction** adapté pour l'inférence en temps réel et haute performance sur une large gamme de sources de données. + +

+
+ +
+ Regardez : Comment Extraire les Sorties du Modèle Ultralytics YOLOv8 pour des Projets Personnalisés. +

+ +## Applications Réelles + +| Fabrication | Sports | Sécurité | +|:---------------------------------------------------------------------------------------------------------------------------------------:|:---------------------------------------------------------------------------------------------------------------------------------------:|:--------------------------------------------------------------------------------------------------------------------------------------:| +| ![Détection des Pièces de Véhicules](https://github.com/RizwanMunawar/ultralytics/assets/62513924/a0f802a8-0776-44cf-8f17-93974a4a28a1) | ![Détection des Joueurs de Football](https://github.com/RizwanMunawar/ultralytics/assets/62513924/7d320e1f-fc57-4d7f-a691-78ee579c3442) | ![Détection de Chutes de Personnes](https://github.com/RizwanMunawar/ultralytics/assets/62513924/86437c4a-3227-4eee-90ef-9efb697bdb43) | +| Détection des Pièces de Véhicules | Détection des Joueurs de Football | Détection de Chutes de Personnes | + +## Pourquoi Utiliser Ultralytics YOLO pour l'Inférence ? + +Voici pourquoi vous devriez considérer le mode de prédiction YOLOv8 pour vos besoins variés en inférence : + +- **Polyvalence :** Capable de faire des inférences sur des images, des vidéos et même des flux en direct. +- **Performance :** Conçu pour le traitement en temps réel à grande vitesse sans sacrifier la précision. +- **Facilité d'Utilisation :** Interfaces Python et CLI intuitives pour un déploiement et des tests rapides. +- **Très Personnalisable :** Divers paramètres et réglages pour ajuster le comportement d'inférence du modèle selon vos besoins spécifiques. + +### Caractéristiques Clés du Mode de Prédiction + +Le mode de prédiction YOLOv8 est conçu pour être robuste et polyvalent, avec des fonctionnalités telles que : + +- **Compatibilité avec Plusieurs Sources de Données :** Que vos données soient sous forme d'images individuelles, d'une collection d'images, de fichiers vidéo ou de flux vidéo en temps réel, le mode de prédiction répond à vos besoins. +- **Mode Streaming :** Utilisez la fonctionnalité de streaming pour générer un générateur efficace en termes de mémoire d'objets `Results`. Activez-le en réglant `stream=True` dans la méthode d'appel du prédicteur. +- **Traitement par Lots :** La capacité de traiter plusieurs images ou trames vidéo dans un seul lot, accélérant ainsi le temps d'inférence. +- **Facile à Intégrer :** S'intègre facilement dans les pipelines de données existants et autres composants logiciels, grâce à son API souple. + +Les modèles YOLO d'Ultralytics renvoient soit une liste d'objets `Results` Python, soit un générateur Python efficace en termes de mémoire d'objets `Results` lorsque `stream=True` est passé au modèle pendant l'inférence : + +!!! exemple "Prédire" + + === "Renvoie une liste avec `stream=False`" + ```python + from ultralytics import YOLO + + # Charger un modèle + model = YOLO('yolov8n.pt') # modèle YOLOv8n pré-entraîné + + # Exécuter une inférence par lots sur une liste d'images + results = model(['im1.jpg', 'im2.jpg']) # renvoie une liste d'objets Results + + # Traiter la liste des résultats + for result in results: + boxes = result.boxes # Objet Boxes pour les sorties bbox + masks = result.masks # Objet Masks pour les masques de segmentation + keypoints = result.keypoints # Objet Keypoints pour les sorties de pose + probs = result.probs # Objet Probs pour les sorties de classification + ``` + + === "Renvoie un générateur avec `stream=True`" + ```python + from ultralytics import YOLO + + # Charger un modèle + model = YOLO('yolov8n.pt') # modèle YOLOv8n pré-entraîné + + # Exécuter une inférence par lots sur une liste d'images + results = model(['im1.jpg', 'im2.jpg'], stream=True) # renvoie un générateur d'objets Results + + # Traiter le générateur de résultats + for result in results: + boxes = result.boxes # Objet Boxes pour les sorties bbox + masks = result.masks # Objet Masks pour les masques de segmentation + keypoints = result.keypoints # Objet Keypoints pour les sorties de pose + probs = result.probs # Objet Probs pour les sorties de classification + ``` + +## Sources d'Inférence + +YOLOv8 peut traiter différents types de sources d'entrée pour l'inférence, comme illustré dans le tableau ci-dessous. Les sources incluent des images statiques, des flux vidéos et divers formats de données. Le tableau indique également si chaque source peut être utilisée en mode streaming avec l'argument `stream=True` ✅. Le mode streaming est bénéfique pour traiter des vidéos ou des flux en direct car il crée un générateur de résultats au lieu de charger tous les cadres en mémoire. + +!!! astuce "Astuce" + + Utilisez `stream=True` pour traiter des vidéos longues ou des jeux de données volumineux afin de gérer efficacement la mémoire. Quand `stream=False`, les résultats pour tous les cadres ou points de données sont stockés en mémoire, ce qui peut rapidement s'accumuler et provoquer des erreurs de mémoire insuffisante pour de grandes entrées. En revanche, `stream=True` utilise un générateur, qui ne garde que les résultats du cadre ou point de données actuel en mémoire, réduisant considérablement la consommation de mémoire et prévenant les problèmes de mémoire insuffisante. + +| Source | Argument | Type | Notes | +|-----------------|--------------------------------------------|-----------------|------------------------------------------------------------------------------------------------------------------------------| +| image | `'image.jpg'` | `str` ou `Path` | Fichier image unique. | +| URL | `'https://ultralytics.com/images/bus.jpg'` | `str` | URL vers une image. | +| capture d'écran | `'screen'` | `str` | Prendre une capture d'écran. | +| PIL | `Image.open('im.jpg')` | `PIL.Image` | Format HWC avec canaux RGB. | +| OpenCV | `cv2.imread('im.jpg')` | `np.ndarray` | Format HWC avec canaux BGR `uint8 (0-255)`. | +| numpy | `np.zeros((640,1280,3))` | `np.ndarray` | Format HWC avec canaux BGR `uint8 (0-255)`. | +| torch | `torch.zeros(16,3,320,640)` | `torch.Tensor` | Format BCHW avec canaux RGB `float32 (0.0-1.0)`. | +| CSV | `'sources.csv'` | `str` ou `Path` | Fichier CSV contenant des chemins vers des images, vidéos ou répertoires. | +| vidéo ✅ | `'video.mp4'` | `str` ou `Path` | Fichier vidéo dans des formats comme MP4, AVI, etc. | +| répertoire ✅ | `'chemin/'` | `str` ou `Path` | Chemin vers un répertoire contenant des images ou des vidéos. | +| motif global ✅ | `'chemin/*.jpg'` | `str` | Motif glob pour faire correspondre plusieurs fichiers. Utilisez le caractère `*` comme joker. | +| YouTube ✅ | `'https://youtu.be/LNwODJXcvt4'` | `str` | URL vers une vidéo YouTube. | +| flux ✅ | `'rtsp://exemple.com/media.mp4'` | `str` | URL pour des protocoles de streaming comme RTSP, RTMP, TCP, ou une adresse IP. | +| multi-flux ✅ | `'liste.streams'` | `str` ou `Path` | Fichier texte `*.streams` avec une URL de flux par ligne, c'est-à-dire que 8 flux s'exécuteront avec une taille de lot de 8. | + +Ci-dessous des exemples de code pour utiliser chaque type de source : + +!!! exemple "Sources de prédiction" + + === "image" + Exécutez une inférence sur un fichier image. + ```python + from ultralytics import YOLO + + # Charger un modèle YOLOv8n pré-entraîné + model = YOLO('yolov8n.pt') + + # Définir le chemin vers le fichier image + source = 'chemin/vers/image.jpg' + + # Exécuter une inférence sur la source + results = model(source) # liste d'objets Results + ``` + + === "capture d'écran" + Exécutez une inférence sur le contenu actuel de l'écran sous forme de capture d'écran. + ```python + from ultralytics import YOLO + + # Charger un modèle YOLOv8n pré-entraîné + model = YOLO('yolov8n.pt') + + # Définir la capture d'écran actuelle comme source + source = 'screen' + + # Exécuter une inférence sur la source + results = model(source) # liste d'objets Results + ``` + + === "URL" + Exécutez une inférence sur une image ou vidéo hébergée à distance via URL. + ```python + from ultralytics import YOLO + + # Charger un modèle YOLOv8n pré-entraîné + model = YOLO('yolov8n.pt') + + # Définir l'URL d'une image ou vidéo distante + source = 'https://ultralytics.com/images/bus.jpg' + + # Exécuter une inférence sur la source + results = model(source) # liste d'objets Results + ``` + + === "PIL" + Exécutez une inférence sur une image ouverte avec la bibliothèque Python Imaging Library (PIL). + ```python + from PIL import Image + from ultralytics import YOLO + + # Charger un modèle YOLOv8n pré-entraîné + model = YOLO('yolov8n.pt') + + # Ouvrir une image avec PIL + source = Image.open('chemin/vers/image.jpg') + + # Exécuter une inférence sur la source + results = model(source) # liste d'objets Results + ``` + + === "OpenCV" + Exécutez une inférence sur une image lue avec OpenCV. + ```python + import cv2 + from ultralytics import YOLO + + # Charger un modèle YOLOv8n pré-entraîné + model = YOLO('yolov8n.pt') + + # Lire une image avec OpenCV + source = cv2.imread('chemin/vers/image.jpg') + + # Exécuter une inférence sur la source + results = model(source) # liste d'objets Results + ``` + + === "numpy" + Exécutez une inférence sur une image représentée sous forme de tableau numpy. + ```python + import numpy as np + from ultralytics import YOLO + + # Charger un modèle YOLOv8n pré-entraîné + model = YOLO('yolov8n.pt') + + # Créer un tableau numpy aléatoire de forme HWC (640, 640, 3) avec des valeurs dans l'intervalle [0, 255] et de type uint8 + source = np.random.randint(low=0, high=255, size=(640, 640, 3), dtype='uint8') + + # Exécuter une inférence sur la source + results = model(source) # liste d'objets Results + ``` + + === "torch" + Exécutez une inférence sur une image représentée sous forme de tenseur PyTorch. + ```python + import torch + from ultralytics import YOLO + + # Charger un modèle YOLOv8n pré-entraîné + model = YOLO('yolov8n.pt') + + # Créer un tenseur aléatoire torch de forme BCHW (1, 3, 640, 640) avec des valeurs dans l'intervalle [0, 1] et de type float32 + source = torch.rand(1, 3, 640, 640, dtype=torch.float32) + + # Exécuter une inférence sur la source + results = model(source) # liste d'objets Results diff --git a/docs/fr/modes/track.md b/docs/fr/modes/track.md new file mode 100644 index 00000000..5adf6517 --- /dev/null +++ b/docs/fr/modes/track.md @@ -0,0 +1,200 @@ +--- +comments: true +description: Apprenez à utiliser Ultralytics YOLO pour le suivi d'objets dans les flux vidéo. Guides pour utiliser différents traceurs et personnaliser les configurations de traceurs. +keywords: Ultralytics, YOLO, suivi d'objets, flux vidéo, BoT-SORT, ByteTrack, guide Python, guide CLI +--- + +# Suivi Multi-Objets avec Ultralytics YOLO + +Exemples de suivi multi-objets + +Le suivi d'objets dans le domaine de l'analyse vidéo est une tâche essentielle qui non seulement identifie l'emplacement et la classe des objets à l'intérieur de l'image, mais maintient également un identifiant unique pour chaque objet détecté au fur et à mesure que la vidéo progresse. Les applications sont illimitées, allant de la surveillance et de la sécurité à l'analytique sportive en temps réel. + +## Pourquoi Choisir Ultralytics YOLO pour le Suivi d'Objet ? + +La sortie des traceurs Ultralytics est cohérente avec la détection standard d'objets mais apporte la valeur ajoutée des identifiants d'objets. Cela facilite le suivi des objets dans les flux vidéo et effectue des analyses subséquentes. Voici pourquoi vous devriez envisager d'utiliser Ultralytics YOLO pour vos besoins de suivi d'objet : + +- **Efficacité :** Traitez les flux vidéo en temps réel sans compromettre la précision. +- **Flexibilité :** Prend en charge de multiples algorithmes de suivi et configurations. +- **Facilité d'Utilisation :** API Python simple et options CLI pour une intégration et un déploiement rapides. +- **Personnalisabilité :** Facile à utiliser avec des modèles YOLO entraînés sur mesure, permettant une intégration dans des applications spécifiques au domaine. + +

+
+ +
+ Regardez : Détection et suivi d'objets avec Ultralytics YOLOv8. +

+ +## Applications dans le Monde Réel + +| Transport | Distribution | Aquaculture | +|:------------------------------------------------------------------------------------------------------------------------:|:------------------------------------------------------------------------------------------------------------------------:|:-----------------------------------------------------------------------------------------------------------------------:| +| ![Suivi de véhicules](https://github.com/RizwanMunawar/ultralytics/assets/62513924/ee6e6038-383b-4f21-ac29-b2a1c7d386ab) | ![Suivi de personnes](https://github.com/RizwanMunawar/ultralytics/assets/62513924/93bb4ee2-77a0-4e4e-8eb6-eb8f527f0527) | ![Suivi de poissons](https://github.com/RizwanMunawar/ultralytics/assets/62513924/a5146d0f-bfa8-4e0a-b7df-3c1446cd8142) | +| Suivi de Véhicules | Suivi de Personnes | Suivi de Poissons | + +## Caractéristiques en Bref + +Ultralytics YOLO étend ses fonctionnalités de détection d'objets pour fournir un suivi d'objets robuste et polyvalent : + +- **Suivi en Temps Réel :** Suivi fluide d'objets dans des vidéos à fréquence d'images élevée. +- **Prise en Charge de Multiples Traceurs :** Choisissez parmi une variété d'algorithmes de suivi éprouvés. +- **Configurations de Traceurs Personnalisables :** Adaptez l'algorithme de suivi pour répondre à des exigences spécifiques en réglant divers paramètres. + +## Traceurs Disponibles + +Ultralytics YOLO prend en charge les algorithmes de suivi suivants. Ils peuvent être activés en passant le fichier de configuration YAML correspondant tel que `tracker=tracker_type.yaml` : + +* [BoT-SORT](https://github.com/NirAharon/BoT-SORT) - Utilisez `botsort.yaml` pour activer ce traceur. +* [ByteTrack](https://github.com/ifzhang/ByteTrack) - Utilisez `bytetrack.yaml` pour activer ce traceur. + +Le traceur par défaut est BoT-SORT. + +## Suivi + +Pour exécuter le traceur sur des flux vidéo, utilisez un modèle Detect, Segment ou Pose formé tel que YOLOv8n, YOLOv8n-seg et YOLOv8n-pose. + +!!! exemple "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Charger un modèle officiel ou personnalisé + model = YOLO('yolov8n.pt') # Charger un modèle Detect officiel + model = YOLO('yolov8n-seg.pt') # Charger un modèle Segment officiel + model = YOLO('yolov8n-pose.pt') # Charger un modèle Pose officiel + model = YOLO('chemin/vers/best.pt') # Charger un modèle entraîné personnalisé + + # Effectuer le suivi avec le modèle + results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True) # Suivi avec le traceur par défaut + results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml") # Suivi avec le traceur ByteTrack + ``` + + === "CLI" + + ```bash + # Effectuer le suivi avec divers modèles en utilisant l'interface en ligne de commande + yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" # Modèle Detect officiel + yolo track model=yolov8n-seg.pt source="https://youtu.be/LNwODJXcvt4" # Modèle Segment officiel + yolo track model=yolov8n-pose.pt source="https://youtu.be/LNwODJXcvt4" # Modèle Pose officiel + yolo track model=chemin/vers/best.pt source="https://youtu.be/LNwODJXcvt4" # Modèle entraîné personnalisé + + # Suivi en utilisant le traceur ByteTrack + yolo track model=chemin/vers/best.pt tracker="bytetrack.yaml" + ``` + +Comme on peut le voir dans l'utilisation ci-dessus, le suivi est disponible pour tous les modèles Detect, Segment et Pose exécutés sur des vidéos ou des sources de diffusion. + +## Configuration + +### Arguments de Suivi + +La configuration du suivi partage des propriétés avec le mode Prédiction, telles que `conf`, `iou`, et `show`. Pour des configurations supplémentaires, référez-vous à la page [Predict](https://docs.ultralytics.com/modes/predict/) du modèle. + +!!! exemple "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Configurer les paramètres de suivi et exécuter le traceur + model = YOLO('yolov8n.pt') + results = model.track(source="https://youtu.be/LNwODJXcvt4", conf=0.3, iou=0.5, show=True) + ``` + + === "CLI" + + ```bash + # Configurer les paramètres de suivi et exécuter le traceur en utilisant l'interface en ligne de commande + yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" conf=0.3, iou=0.5 show + ``` + +### Sélection du Traceur + +Ultralytics vous permet également d'utiliser un fichier de configuration de traceur modifié. Pour cela, faites simplement une copie d'un fichier de configuration de traceur (par exemple, `custom_tracker.yaml`) à partir de [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers) et modifiez toute configuration (à l'exception du `tracker_type`) selon vos besoins. + +!!! exemple "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Charger le modèle et exécuter le traceur avec un fichier de configuration personnalisé + model = YOLO('yolov8n.pt') + results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker='custom_tracker.yaml') + ``` + + === "CLI" + + ```bash + # Charger le modèle et exécuter le traceur avec un fichier de configuration personnalisé en utilisant l'interface en ligne de commande + yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" tracker='custom_tracker.yaml' + ``` + +Pour une liste complète des arguments de suivi, référez-vous à la page [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers). + +## Exemples Python + +### Boucle de Persistance des Pistes + +Voici un script Python utilisant OpenCV (`cv2`) et YOLOv8 pour exécuter le suivi d'objet sur des images vidéo. Ce script suppose toujours que vous avez déjà installé les packages nécessaires (`opencv-python` et `ultralytics`). L'argument `persist=True` indique au traceur que l'image ou la trame actuelle est la suivante dans une séquence et s'attend à ce que les pistes de l'image précédente soient présentes dans l'image actuelle. + +!!! exemple "Boucle for streaming avec suivi" + + ```python + import cv2 + from ultralytics import YOLO + + # Charger le modèle YOLOv8 + model = YOLO('yolov8n.pt') + + # Ouvrir le fichier vidéo + video_path = "chemin/vers/video.mp4" + cap = cv2.VideoCapture(video_path) + + # Parcourir les images vidéo + while cap.isOpened(): + # Lire une image de la vidéo + success, frame = cap.read() + + if success: + # Exécuter le suivi YOLOv8 sur l'image, en persistant les pistes entre les images + results = model.track(frame, persist=True) + + # Visualiser les résultats sur l'image + annotated_frame = results[0].plot() + + # Afficher l'image annotée + cv2.imshow("Suivi YOLOv8", annotated_frame) + + # Interrompre la boucle si 'q' est pressée + if cv2.waitKey(1) & 0xFF == ord("q"): + break + else: + # Interrompre la boucle si la fin de la vidéo est atteinte + break + + # Relâcher l'objet de capture vidéo et fermer la fenêtre d'affichage + cap.release() + cv2.destroyAllWindows() + ``` + +Veuillez noter le changement de `model(frame)` à `model.track(frame)`, qui active le suivi d'objet à la place de la simple détection. Ce script modifié exécutera le traceur sur chaque image de la vidéo, visualisera les résultats et les affichera dans une fenêtre. La boucle peut être quittée en appuyant sur 'q'. + +## Contribuer de Nouveaux Traceurs + +Êtes-vous compétent en suivi multi-objets et avez-vous réussi à implémenter ou adapter un algorithme de suivi avec Ultralytics YOLO ? Nous vous invitons à contribuer à notre section Traceurs sur [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers) ! Vos applications et solutions dans le monde réel pourraient être inestimables pour les utilisateurs travaillant sur des tâches de suivi. + +En contribuant à cette section, vous aidez à élargir l'éventail des solutions de suivi disponibles au sein du cadre Ultralytics YOLO, ajoutant une autre couche de fonctionnalité et d'utilité pour la communauté. + +Pour initier votre contribution, veuillez vous référer à notre [Guide de Contribution](https://docs.ultralytics.com/help/contributing) pour des instructions complètes sur la soumission d'une Pull Request (PR) 🛠️. Nous sommes impatients de voir ce que vous apportez à la table ! + +Ensemble, améliorons les capacités de suivi de l'écosystème Ultralytics YOLO 🙏 ! diff --git a/docs/fr/modes/train.md b/docs/fr/modes/train.md new file mode 100644 index 00000000..56934b7d --- /dev/null +++ b/docs/fr/modes/train.md @@ -0,0 +1,206 @@ +--- +comments: true +description: Guide étape par étape pour entraîner des modèles YOLOv8 avec Ultralytics YOLO incluant des exemples d'entraînement mono-GPU et multi-GPU +keywords: Ultralytics, YOLOv8, YOLO, détection d'objet, mode entraînement, jeu de données personnalisé, entraînement GPU, multi-GPU, hyperparamètres, exemples CLI, exemples Python +--- + +# Entraînement de modèles avec Ultralytics YOLO + +Ultralytics YOLO écosystème et intégrations + +## Introduction + +L'entraînement d'un modèle d'apprentissage profond implique de lui fournir des données et d'ajuster ses paramètres afin qu'il puisse faire des prédictions précises. Le mode Entraînement de Ultralytics YOLOv8 est conçu pour un entraînement efficace et performant de modèles de détection d'objets, en utilisant pleinement les capacités du matériel moderne. Ce guide vise à couvrir tous les détails nécessaires pour commencer à entraîner vos propres modèles en utilisant l'ensemble robuste de fonctionnalités de YOLOv8. + +

+
+ +
+ Regardez : Comment entraîner un modèle YOLOv8 sur votre jeu de données personnalisé dans Google Colab. +

+ +## Pourquoi choisir Ultralytics YOLO pour l'entraînement ? + +Voici quelques raisons convaincantes de choisir le mode Entraînement de YOLOv8 : + +- **Efficacité :** Optimisez l'utilisation de votre matériel, que vous soyez sur une configuration mono-GPU ou que vous échelonnier sur plusieurs GPUs. +- **Polyvalence :** Entraînez sur des jeux de données personnalisés en plus de ceux déjà disponibles comme COCO, VOC et ImageNet. +- **Convivialité :** Interfaces CLI et Python simples mais puissantes pour une expérience d'entraînement directe. +- **Flexibilité des hyperparamètres :** Un large éventail d'hyperparamètres personnalisables pour peaufiner les performances du modèle. + +### Principales caractéristiques du mode Entraînement + +Voici quelques caractéristiques remarquables du mode Entraînement de YOLOv8 : + +- **Téléchargement automatique de jeux de données :** Les jeux de données standards comme COCO, VOC et ImageNet sont téléchargés automatiquement lors de la première utilisation. +- **Support multi-GPU :** Échelonnez vos efforts de formation de manière fluide sur plusieurs GPUs pour accélérer le processus. +- **Configuration des hyperparamètres :** La possibilité de modifier les hyperparamètres via des fichiers de configuration YAML ou des arguments CLI. +- **Visualisation et suivi :** Suivi en temps réel des métriques d'entraînement et visualisation du processus d'apprentissage pour de meilleures perspectives. + +!!! tip "Astuce" + + * Les jeux de données YOLOv8 comme COCO, VOC, ImageNet et bien d'autres se téléchargent automatiquement lors de la première utilisation, par exemple `yolo train data=coco.yaml` + +## Exemples d'utilisation + +Entraînez YOLOv8n sur le jeu de données COCO128 pendant 100 époques avec une taille d'image de 640. Le dispositif d'entraînement peut être spécifié à l'aide de l'argument `device`. Si aucun argument n'est passé, le GPU `device=0` sera utilisé s'il est disponible, sinon `device=cpu` sera utilisé. Consultez la section Arguments ci-dessous pour obtenir une liste complète des arguments d'entraînement. + +!!! example "Exemple d'entraînement mono-GPU et CPU" + + Le dispositif est déterminé automatiquement. Si un GPU est disponible, il sera utilisé, sinon l'entraînement commencera sur CPU. + + === "Python" + + ```python + from ultralytics import YOLO + + # Charger un modèle + model = YOLO('yolov8n.yaml') # construire un nouveau modèle à partir de YAML + model = YOLO('yolov8n.pt') # charger un modèle préentraîné (recommandé pour l'entraînement) + model = YOLO('yolov8n.yaml').load('yolov8n.pt') # construire à partir de YAML et transférer les poids + + # Entraîner le modèle + results = model.train(data='coco128.yaml', epochs=100, imgsz=640) + ``` + + === "CLI" + + ```bash + # Construire un nouveau modèle à partir de YAML et commencer l'entraînement à partir de zéro + yolo detect train data=coco128.yaml model=yolov8n.yaml epochs=100 imgsz=640 + + # Commencer l'entraînement à partir d'un modèle préentraîné *.pt + yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 + + # Construire un nouveau modèle à partir de YAML, transférer les poids préentraînés et commencer l'entraînement + yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640 + ``` + +### Entraînement multi-GPU + +L'entraînement multi-GPU permet une utilisation plus efficace des ressources matérielles disponibles en répartissant la charge d'entraînement sur plusieurs GPUs. Cette fonctionnalité est disponible via l'API Python et l'interface de ligne de commande. Pour activer l'entraînement multi-GPU, spécifiez les ID des dispositifs GPU que vous souhaitez utiliser. + +!!! example "Exemple d'entraînement multi-GPU" + + Pour s'entraîner avec 2 GPUs, les dispositifs CUDA 0 et 1, utilisez les commandes suivantes. Développez à des GPUs supplémentaires selon le besoin. + + === "Python" + + ```python + from ultralytics import YOLO + + # Charger un modèle + model = YOLO('yolov8n.pt') # charger un modèle préentraîné (recommandé pour l'entraînement) + + # Entraîner le modèle avec 2 GPUs + results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device=[0, 1]) + ``` + + === "CLI" + + ```bash + # Commencer l'entraînement à partir d'un modèle préentraîné *.pt en utilisant les GPUs 0 et 1 + yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=0,1 + ``` + +### Entraînement MPS avec Apple M1 et M2 + +Avec le support pour les puces Apple M1 et M2 intégré dans les modèles Ultralytics YOLO, il est maintenant possible d'entraîner vos modèles sur des dispositifs utilisant le puissant framework Metal Performance Shaders (MPS). Le MPS offre un moyen performant d'exécuter des tâches de calcul et de traitement d'image sur le silicium personnalisé d'Apple. + +Pour activer l'entraînement sur les puces Apple M1 et M2, vous devez spécifier 'mps' comme votre dispositif lors du lancement du processus d'entraînement. Voici un exemple de la manière dont vous pourriez le faire en Python et via la ligne de commande : + +!!! example "Exemple d'entraînement MPS" + + === "Python" + + ```python + from ultralytics import YOLO + + # Charger un modèle + model = YOLO('yolov8n.pt') # charger un modèle préentraîné (recommandé pour l'entraînement) + + # Entraîner le modèle avec MPS + results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device='mps') + ``` + + === "CLI" + + ```bash + # Commencer l'entraînement à partir d'un modèle préentraîné *.pt avec MPS + yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=mps + ``` + +Tout en exploitant la puissance de calcul des puces M1/M2, cela permet un traitement plus efficace des tâches d'entraînement. Pour des conseils plus détaillés et des options de configuration avancée, veuillez consulter la [documentation MPS de PyTorch](https://pytorch.org/docs/stable/notes/mps.html). + +## Journalisation + +Lors de l'entraînement d'un modèle YOLOv8, il peut être précieux de suivre la performance du modèle au fil du temps. C'est là que la journalisation entre en jeu. YOLO d'Ultralytics prend en charge trois types de journaux - Comet, ClearML et TensorBoard. + +Pour utiliser un journal, sélectionnez-le dans le menu déroulant ci-dessus et exécutez-le. Le journal choisi sera installé et initialisé. + +### Comet + +[Comet](https://www.comet.ml/site/) est une plateforme qui permet aux scientifiques de données et aux développeurs de suivre, comparer, expliquer et optimiser les expériences et les modèles. Elle offre des fonctionnalités telles que le suivi en temps réel des mesures, les différences de code et le suivi des hyperparamètres. + +Pour utiliser Comet : + +!!! example "" + + === "Python" + ```python + # pip install comet_ml + import comet_ml + + comet_ml.init() + ``` + +N'oubliez pas de vous connecter à votre compte Comet sur leur site web et d'obtenir votre clé API. Vous devrez ajouter cela à vos variables d'environnement ou à votre script pour enregistrer vos expériences. + +### ClearML + +[ClearML](https://www.clear.ml/) est une plateforme open source qui automatise le suivi des expériences et aide à partager efficacement les ressources. Elle est conçue pour aider les équipes à gérer, exécuter et reproduire leur travail en ML plus efficacement. + +Pour utiliser ClearML : + +!!! example "" + + === "Python" + ```python + # pip install clearml + import clearml + + clearml.browser_login() + ``` + +Après avoir exécuté ce script, vous devrez vous connecter à votre compte ClearML sur le navigateur et authentifier votre session. + +### TensorBoard + +[TensorBoard](https://www.tensorflow.org/tensorboard) est un ensemble d'outils de visualisation pour TensorFlow. Il vous permet de visualiser votre graphique TensorFlow, de tracer des mesures quantitatives sur l'exécution de votre graphique et de montrer des données supplémentaires comme des images qui le traversent. + +Pour utiliser TensorBoard dans [Google Colab](https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb) : + +!!! example "" + + === "CLI" + ```bash + load_ext tensorboard + tensorboard --logdir ultralytics/runs # remplacer par le répertoire 'runs' + ``` + +Pour utiliser TensorBoard localement, exécutez la commande ci-dessous et consultez les résultats à l'adresse http://localhost:6006/. + +!!! example "" + + === "CLI" + ```bash + tensorboard --logdir ultralytics/runs # remplacer par le répertoire 'runs' + ``` + +Cela chargera TensorBoard et le dirigera vers le répertoire où vos journaux d'entraînement sont sauvegardés. + +Après avoir configuré votre journal, vous pouvez ensuite poursuivre l'entraînement de votre modèle. Toutes les métriques d'entraînement seront automatiquement enregistrées sur votre plateforme choisie, et vous pourrez accéder à ces journaux pour surveiller les performances de votre modèle au fil du temps, comparer différents modèles et identifier les domaines d'amélioration. diff --git a/docs/fr/modes/val.md b/docs/fr/modes/val.md new file mode 100644 index 00000000..46f31e90 --- /dev/null +++ b/docs/fr/modes/val.md @@ -0,0 +1,86 @@ +--- +comments: true +description: Guide de validation des modèles YOLOv8. Apprenez à évaluer la performance de vos modèles YOLO en utilisant les paramètres de validation et les métriques avec des exemples en Python et en CLI. +keywords: Ultralytics, YOLO Docs, YOLOv8, validation, évaluation de modèle, hyperparamètres, précision, métriques, Python, CLI +--- + +# Validation des modèles avec Ultralytics YOLO + +Écosystème Ultralytics YOLO et intégrations + +## Introduction + +La validation est une étape cruciale dans le pipeline d'apprentissage automatique, vous permettant d'évaluer la qualité de vos modèles entraînés. Le mode Val dans Ultralytics YOLOv8 offre une gamme robuste d'outils et de métriques pour évaluer la performance de vos modèles de détection d'objets. Ce guide sert de ressource complète pour comprendre comment utiliser efficacement le mode Val pour assurer que vos modèles sont à la fois précis et fiables. + +## Pourquoi valider avec Ultralytics YOLO ? + +Voici pourquoi l'utilisation du mode Val de YOLOv8 est avantageuse : + +- **Précision :** Obtenez des métriques précises telles que mAP50, mAP75 et mAP50-95 pour évaluer de manière exhaustive votre modèle. +- **Convenance :** Utilisez des fonctionnalités intégrées qui se souviennent des paramètres d'entraînement, simplifiant ainsi le processus de validation. +- **Flexibilité :** Validez votre modèle avec les mêmes jeux de données ou des jeux différents et des tailles d'image variées. +- **Réglage des hyperparamètres :** Utilisez les métriques de validation pour peaufiner votre modèle pour de meilleures performances. + +### Caractéristiques clés du mode Val + +Voici les fonctionnalités notables offertes par le mode Val de YOLOv8 : + +- **Paramètres Automatisés :** Les modèles se souviennent de leurs configurations d'entraînement pour une validation simple. +- **Support Multi-métrique :** Évaluez votre modèle en fonction d'une gamme de métriques de précision. +- **CLI et API Python :** Choisissez entre l'interface en ligne de commande ou l'API Python en fonction de vos préférences pour la validation. +- **Compatibilité des Données :** Fonctionne de manière transparente avec les jeux de données utilisés pendant la phase d'entraînement ainsi qu'avec les jeux personnalisés. + +!!! tip "Conseil" + + * Les modèles YOLOv8 se souviennent automatiquement de leurs paramètres d'entraînement, vous pouvez donc facilement valider un modèle à la même taille d'image et sur le jeu de données original avec juste `yolo val model=yolov8n.pt` ou `model('yolov8n.pt').val()` + +## Exemples d'utilisation + +Validez la précision du modèle YOLOv8n entraîné sur le jeu de données COCO128. Aucun argument n'a besoin d'être passé car le `modèle` conserve ses `données` d'entraînement et arguments comme attributs du modèle. Consultez la section des arguments ci-dessous pour une liste complète des arguments d'exportation. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Charger un modèle + model = YOLO('yolov8n.pt') # charger un modèle officiel + model = YOLO('chemin/vers/meilleur.pt') # charger un modèle personnalisé + + # Valider le modèle + metrics = model.val() # pas besoin d'arguments, jeu de données et paramètres mémorisés + metrics.box.map # map50-95 + metrics.box.map50 # map50 + metrics.box.map75 # map75 + metrics.box.maps # une liste contenant map50-95 de chaque catégorie + ``` + === "CLI" + + ```bash + yolo detect val model=yolov8n.pt # val modèle officiel + yolo detect val model=chemin/vers/meilleur.pt # val modèle personnalisé + ``` + +## Arguments + +Les paramètres de validation pour les modèles YOLO font référence aux divers hyperparamètres et configurations utilisés pour évaluer la performance du modèle sur un jeu de données de validation. Ces paramètres peuvent affecter la performance, la vitesse et la précision du modèle. Certains paramètres de validation YOLO courants incluent la taille du lot, la fréquence à laquelle la validation est effectuée pendant l'entraînement et les métriques utilisées pour évaluer la performance du modèle. D'autres facteurs pouvant affecter le processus de validation incluent la taille et la composition du jeu de données de validation et la tâche spécifique pour laquelle le modèle est utilisé. Il est important de régler et d'expérimenter soigneusement ces paramètres pour s'assurer que le modèle fonctionne bien sur le jeu de données de validation et pour détecter et prévenir le surajustement. + +| Clé | Valeur | Description | +|---------------|---------|------------------------------------------------------------------------------------------------| +| `data` | `None` | chemin vers le fichier de données, par exemple coco128.yaml | +| `imgsz` | `640` | taille des images d'entrée en tant qu'entier | +| `batch` | `16` | nombre d'images par lot (-1 pour AutoBatch) | +| `save_json` | `False` | sauvegarder les résultats dans un fichier JSON | +| `save_hybrid` | `False` | sauvegarder la version hybride des étiquettes (étiquettes + prédictions supplémentaires) | +| `conf` | `0.001` | seuil de confiance de l'objet pour la détection | +| `iou` | `0.6` | seuil d'intersection sur union (IoU) pour la NMS | +| `max_det` | `300` | nombre maximum de détections par image | +| `half` | `True` | utiliser la précision moitié (FP16) | +| `device` | `None` | appareil sur lequel exécuter, par exemple cuda device=0/1/2/3 ou device=cpu | +| `dnn` | `False` | utiliser OpenCV DNN pour l'inférence ONNX | +| `plots` | `False` | afficher les graphiques lors de la formation | +| `rect` | `False` | val rectangulaire avec chaque lot regroupé pour un minimum de rembourrage | +| `split` | `val` | fraction du jeu de données à utiliser pour la validation, par exemple 'val', 'test' ou 'train' | +| diff --git a/docs/fr/quickstart.md b/docs/fr/quickstart.md new file mode 100644 index 00000000..2eac0dcb --- /dev/null +++ b/docs/fr/quickstart.md @@ -0,0 +1,187 @@ +--- +comments: true +description: Explorez diverses méthodes pour installer Ultralytics en utilisant pip, conda, git et Docker. Apprenez comment utiliser Ultralytics avec l'interface en ligne de commande ou au sein de vos projets Python. +keywords: installation d'Ultralytics, pip install Ultralytics, Docker install Ultralytics, interface en ligne de commande Ultralytics, interface Python Ultralytics +--- + +## Installer Ultralytics + +Ultralytics propose diverses méthodes d'installation, y compris pip, conda et Docker. Installez YOLOv8 via le package `ultralytics` avec pip pour obtenir la dernière version stable ou en clonant le [répertoire GitHub d'Ultralytics](https://github.com/ultralytics/ultralytics) pour la version la plus récente. Docker peut être utilisé pour exécuter le package dans un conteneur isolé, évitant l'installation locale. + +!!! exemple "Installer" + + === "Installation avec Pip (recommandé)" + Installez le package `ultralytics` en utilisant pip, ou mettez à jour une installation existante en exécutant `pip install -U ultralytics`. Visitez l'Index des Packages Python (PyPI) pour plus de détails sur le package `ultralytics` : [https://pypi.org/project/ultralytics/](https://pypi.org/project/ultralytics/). + + [![Version PyPI](https://badge.fury.io/py/ultralytics.svg)](https://badge.fury.io/py/ultralytics) [![Téléchargements](https://static.pepy.tech/badge/ultralytics)](https://pepy.tech/project/ultralytics) + + ```bash + # Installer le package ultralytics depuis PyPI + pip install ultralytics + ``` + + Vous pouvez également installer le package `ultralytics` directement depuis le [répertoire GitHub](https://github.com/ultralytics/ultralytics). Cela peut être utile si vous voulez la version de développement la plus récente. Assurez-vous d'avoir l'outil en ligne de commande Git installé sur votre système. La commande `@main` installe la branche `main` et peut être modifiée pour une autre branche, p. ex. `@my-branch`, ou supprimée entièrement pour revenir par défaut à la branche `main`. + + ```bash + # Installer le package ultralytics depuis GitHub + pip install git+https://github.com/ultralytics/ultralytics.git@main + ``` + + + === "Installation avec Conda" + Conda est un gestionnaire de packages alternatif à pip qui peut également être utilisé pour l'installation. Visitez Anaconda pour plus de détails à [https://anaconda.org/conda-forge/ultralytics](https://anaconda.org/conda-forge/ultralytics). Le répertoire feedstock d'Ultralytics pour la mise à jour du package conda est sur [https://github.com/conda-forge/ultralytics-feedstock/](https://github.com/conda-forge/ultralytics-feedstock/). + + + [![Recette Conda](https://img.shields.io/badge/recipe-ultralytics-green.svg)](https://anaconda.org/conda-forge/ultralytics) [![Téléchargements Conda](https://img.shields.io/conda/dn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics) [![Version Conda](https://img.shields.io/conda/vn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics) [![Plateformes Conda](https://img.shields.io/conda/pn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics) + + ```bash + # Installer le package ultralytics en utilisant conda + conda install -c conda-forge ultralytics + ``` + + !!! note + + Si vous installez dans un environnement CUDA, la meilleure pratique est d'installer `ultralytics`, `pytorch` et `pytorch-cuda` dans la même commande pour permettre au gestionnaire de package conda de résoudre les conflits, ou bien d'installer `pytorch-cuda` en dernier pour lui permettre de remplacer le package `pytorch` spécifique aux CPU si nécessaire. + ```bash + # Installer tous les packages ensemble en utilisant conda + conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics + ``` + + ### Image Docker Conda + + Les images Docker Conda d'Ultralytics sont également disponibles sur [DockerHub](https://hub.docker.com/r/ultralytics/ultralytics). Ces images sont basées sur [Miniconda3](https://docs.conda.io/projects/miniconda/en/latest/) et constituent un moyen simple de commencer à utiliser `ultralytics` dans un environnement Conda. + + ```bash + # Définir le nom de l'image comme variable + t=ultralytics/ultralytics:latest-conda + + # Télécharger la dernière image ultralytics de Docker Hub + sudo docker pull $t + + # Exécuter l'image ultralytics dans un conteneur avec support GPU + sudo docker run -it --ipc=host --gpus all $t # tous les GPUs + sudo docker run -it --ipc=host --gpus '"device=2,3"' $t # spécifier les GPUs + ``` + + === "Clone Git" + Clonez le répertoire `ultralytics` si vous êtes intéressé par la contribution au développement ou si vous souhaitez expérimenter avec le dernier code source. Après le clonage, naviguez dans le répertoire et installez le package en mode éditable `-e` en utilisant pip. + ```bash + # Cloner le répertoire ultralytics + git clone https://github.com/ultralytics/ultralytics + + # Naviguer vers le répertoire cloné + cd ultralytics + + # Installer le package en mode éditable pour le développement + pip install -e . + ``` + +Voir le fichier [requirements.txt](https://github.com/ultralytics/ultralytics/blob/main/requirements.txt) d'`ultralytics` pour une liste des dépendances. Notez que tous les exemples ci-dessus installent toutes les dépendances requises. + +!!! astuce "Conseil" + + Les prérequis de PyTorch varient selon le système d'exploitation et les exigences CUDA, donc il est recommandé d'installer PyTorch en premier en suivant les instructions sur [https://pytorch.org/get-started/locally](https://pytorch.org/get-started/locally). + + + Instructions d'installation de PyTorch + + +## Utiliser Ultralytics avec CLI + +L'interface en ligne de commande (CLI) d'Ultralytics permet l'utilisation de commandes simples en une seule ligne sans nécessiter d'environnement Python. La CLI ne requiert pas de personnalisation ou de code Python. Vous pouvez simplement exécuter toutes les tâches depuis le terminal avec la commande `yolo`. Consultez le [Guide CLI](../usage/cli.md) pour en savoir plus sur l'utilisation de YOLOv8 depuis la ligne de commande. + +!!! exemple + + === "Syntaxe" + + Les commandes `yolo` d'Ultralytics utilisent la syntaxe suivante : + ```bash + yolo TÂCHE MODE ARGS + + Où TÂCHE (facultatif) est l'une de [detect, segment, classify] + MODE (obligatoire) est l'un de [train, val, predict, export, track] + ARGS (facultatif) sont n'importe quel nombre de paires personnalisées 'arg=valeur' comme 'imgsz=320' qui remplacent les valeurs par défaut. + ``` + Voyez tous les ARGS dans le [Guide de Configuration](../usage/cfg.md) complet ou avec `yolo cfg` + + === "Entraînement" + + Entraînez un modèle de détection pour 10 epochs avec un learning_rate initial de 0.01 + ```bash + yolo train data=coco128.yaml model=yolov8n.pt epochs=10 lr0=0.01 + ``` + + === "Prédiction" + + Prédisez une vidéo YouTube en utilisant un modèle de segmentation pré-entraîné à une taille d'image de 320 : + ```bash + yolo predict model=yolov8n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320 + ``` + + === "Validation" + + Validez un modèle de détection pré-entraîné avec un batch-size de 1 et une taille d'image de 640 : + ```bash + yolo val model=yolov8n.pt data=coco128.yaml batch=1 imgsz=640 + ``` + + === "Exportation" + + Exportez un modèle de classification YOLOv8n au format ONNX à une taille d'image de 224 par 128 (pas de TÂCHE requise) + ```bash + yolo export model=yolov8n-cls.pt format=onnx imgsz=224,128 + ``` + + === "Spécial" + + Exécutez des commandes spéciales pour voir la version, afficher les paramètres, effectuer des vérifications et plus encore : + ```bash + yolo help + yolo checks + yolo version + yolo settings + yolo copy-cfg + yolo cfg + ``` + +!!! avertissement "Avertissement" + + Les arguments doivent être passés sous forme de paires `arg=val`, séparés par un signe égal `=` et délimités par des espaces ` ` entre les paires. N'utilisez pas de préfixes d'arguments `--` ou de virgules `,` entre les arguments. + + - `yolo predict model=yolov8n.pt imgsz=640 conf=0.25`   ✅ + - `yolo predict model yolov8n.pt imgsz 640 conf 0.25`   ❌ + - `yolo predict --model yolov8n.pt --imgsz 640 --conf 0.25`   ❌ + +[Guide CLI](../usage/cli.md){ .md-button .md-button--primary} + +## Utiliser Ultralytics avec Python + +L'interface Python de YOLOv8 permet une intégration transparente dans vos projets Python, facilitant le chargement, l'exécution et le traitement de la sortie du modèle. Conçue avec simplicité et facilité d'utilisation à l'esprit, l'interface Python permet aux utilisateurs de mettre en œuvre rapidement la détection d'objets, la segmentation et la classification dans leurs projets. Cela fait de l'interface Python de YOLOv8 un outil inestimable pour quiconque cherche à intégrer ces fonctionnalités dans ses projets Python. + +Par exemple, les utilisateurs peuvent charger un modèle, l'entraîner, évaluer ses performances sur un set de validation, et même l'exporter au format ONNX avec seulement quelques lignes de code. Consultez le [Guide Python](../usage/python.md) pour en savoir plus sur l'utilisation de YOLOv8 au sein de vos projets Python. + +!!! exemple + + ```python + from ultralytics import YOLO + + # Créer un nouveau modèle YOLO à partir de zéro + model = YOLO('yolov8n.yaml') + + # Charger un modèle YOLO pré-entraîné (recommandé pour l'entraînement) + model = YOLO('yolov8n.pt') + + # Entraîner le modèle en utilisant le jeu de données 'coco128.yaml' pour 3 epochs + résultats = model.train(data='coco128.yaml', epochs=3) + + # Évaluer la performance du modèle sur le set de validation + résultats = model.val() + + # Effectuer la détection d'objets sur une image en utilisant le modèle + résultats = model('https://ultralytics.com/images/bus.jpg') + + # Exporter le modèle au format ONNX + succès = model.export(format='onnx') + ``` + +[Guide Python](../usage/python.md){.md-button .md-button--primary} diff --git a/docs/fr/tasks/classify.md b/docs/fr/tasks/classify.md new file mode 100644 index 00000000..bbac0015 --- /dev/null +++ b/docs/fr/tasks/classify.md @@ -0,0 +1,172 @@ +--- +comments: true +description: Apprenez-en davantage sur les modèles de classification d'images YOLOv8 Classify. Obtenez des informations détaillées sur la liste des modèles pré-entraînés et comment entraîner, valider, prédire et exporter des modèles. +keywords: Ultralytics, YOLOv8, Classification d'images, Modèles pré-entraînés, YOLOv8n-cls, Entraînement, Validation, Prédiction, Exportation de modèles +--- + +# Classification d'images + +Exemples de classification d'images + +La classification d'images est la tâche la plus simple des trois et consiste à classer une image entière dans l'une d'un ensemble de classes prédéfinies. + +Le résultat d'un classificateur d'images est une étiquette de classe unique et un score de confiance. La classification d'images est utile lorsque vous avez besoin de savoir seulement à quelle classe appartient une image et que vous n'avez pas besoin de connaître l'emplacement des objets de cette classe ou leur forme exacte. + +!!! tip "Astuce" + + Les modèles YOLOv8 Classify utilisent le suffixe `-cls`, par exemple `yolov8n-cls.pt` et sont pré-entraînés sur [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml). + +## [Modèles](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8) + +Les modèles Classify pré-entraînés YOLOv8 sont présentés ici. Les modèles Detect, Segment et Pose sont pré-entraînés sur le dataset [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), tandis que les modèles Classify sont pré-entraînés sur le dataset [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml). + +Les [modèles](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) se téléchargent automatiquement depuis la dernière version Ultralytics [release](https://github.com/ultralytics/assets/releases) lors de la première utilisation. + +| Modèle | taille
(pixels) | acc
top1 | acc
top5 | Vitesse
CPU ONNX
(ms) | Vitesse
A100 TensorRT
(ms) | params
(M) | FLOPs
(B) à 640 | +|----------------------------------------------------------------------------------------------|-------------------------|------------------|------------------|----------------------------------|---------------------------------------|--------------------|-------------------------| +| [YOLOv8n-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-cls.pt) | 224 | 66.6 | 87.0 | 12.9 | 0.31 | 2.7 | 4.3 | +| [YOLOv8s-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-cls.pt) | 224 | 72.3 | 91.1 | 23.4 | 0.35 | 6.4 | 13.5 | +| [YOLOv8m-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-cls.pt) | 224 | 76.4 | 93.2 | 85.4 | 0.62 | 17.0 | 42.7 | +| [YOLOv8l-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-cls.pt) | 224 | 78.0 | 94.1 | 163.0 | 0.87 | 37.5 | 99.7 | +| [YOLOv8x-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-cls.pt) | 224 | 78.4 | 94.3 | 232.0 | 1.01 | 57.4 | 154.8 | + +- Les valeurs **acc** sont les précisions des modèles sur le jeu de données de validation d'[ImageNet](https://www.image-net.org/). +
Pour reproduire : `yolo val classify data=path/to/ImageNet device=0` +- Les **vitesses** sont calculées sur les images de validation d'ImageNet à l'aide d'une instance [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/). +
Pour reproduire : `yolo val classify data=path/to/ImageNet batch=1 device=0|cpu` + +## Entraînement + +Entraînez le modèle YOLOv8n-cls sur le dataset MNIST160 pendant 100 époques avec une taille d'image de 64. Pour une liste complète des arguments disponibles, consultez la page [Configuration](../../usage/cfg.md). + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Charger un modèle + model = YOLO('yolov8n-cls.yaml') # construire un nouveau modèle à partir du YAML + model = YOLO('yolov8n-cls.pt') # charger un modèle pré-entraîné (recommandé pour l'entraînement) + model = YOLO('yolov8n-cls.yaml').load('yolov8n-cls.pt') # construire à partir du YAML et transférer les poids + + # Entraîner le modèle + results = model.train(data='mnist160', epochs=100, imgsz=64) + ``` + + === "CLI" + + ```bash + # Construire un nouveau modèle à partir du YAML et commencer l'entraînement à partir de zéro + yolo classify train data=mnist160 model=yolov8n-cls.yaml epochs=100 imgsz=64 + + # Commencer l'entraînement à partir d'un modèle *.pt pré-entraîné + yolo classify train data=mnist160 model=yolov8n-cls.pt epochs=100 imgsz=64 + + # Construire un nouveau modèle à partir du YAML, transférer les poids pré-entraînés et commencer l'entraînement + yolo classify train data=mnist160 model=yolov8n-cls.yaml pretrained=yolov8n-cls.pt epochs=100 imgsz=64 + ``` + +### Format du dataset + +Le format du dataset de classification YOLO peut être trouvé en détails dans le [Guide des Datasets](../../datasets/classify/index.md). + +## Validation + +Validez la précision du modèle YOLOv8n-cls entraîné sur le dataset MNIST160. Aucun argument n'est nécessaire car le `modèle` conserve ses données d'entraînement et arguments en tant qu'attributs du modèle. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Charger un modèle + model = YOLO('yolov8n-cls.pt') # charger un modèle officiel + model = YOLO('path/to/best.pt') # charger un modèle personnalisé + + # Valider le modèle + metrics = model.val() # aucun argument nécessaire, les données et les paramètres sont mémorisés + metrics.top1 # précision top 1 + metrics.top5 # précision top 5 + ``` + === "CLI" + + ```bash + yolo classify val model=yolov8n-cls.pt # valider le modèle officiel + yolo classify val model=path/to/best.pt # valider le modèle personnalisé + ``` + +## Prédiction + +Utilisez un modèle YOLOv8n-cls entraîné pour exécuter des prédictions sur des images. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Charger un modèle + model = YOLO('yolov8n-cls.pt') # charger un modèle officiel + model = YOLO('path/to/best.pt') # charger un modèle personnalisé + + # Prédire avec le modèle + results = model('https://ultralytics.com/images/bus.jpg') # prédire sur une image + ``` + === "CLI" + + ```bash + yolo classify predict model=yolov8n-cls.pt source='https://ultralytics.com/images/bus.jpg' # prédiction avec le modèle officiel + yolo classify predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # prédiction avec le modèle personnalisé + ``` + +Voir les détails complets du mode `predict` sur la page [Prédire](https://docs.ultralytics.com/modes/predict/). + +## Exportation + +Exportez un modèle YOLOv8n-cls dans un format différent comme ONNX, CoreML, etc. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Charger un modèle + model = YOLO('yolov8n-cls.pt') # charger un modèle officiel + model = YOLO('path/to/best.pt') # charger un modèle entraîné personnalisé + + # Exporter le modèle + model.export(format='onnx') + ``` + === "CLI" + + ```bash + yolo export model=yolov8n-cls.pt format=onnx # exporter le modèle officiel + yolo export model=path/to/best.pt format=onnx # exporter le modèle entraîné personnalisé + ``` + +Les formats d'exportation disponibles pour YOLOv8-cls sont présentés dans le tableau ci-dessous. Vous pouvez prédire ou valider directement sur les modèles exportés, par exemple `yolo predict model=yolov8n-cls.onnx`. Des exemples d'utilisation sont présentés pour votre modèle une fois l'exportation terminée. + +| Format | Argument `format` | Modèle | Métadonnées | Arguments | +|--------------------------------------------------------------------|-------------------|-------------------------------|-------------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n-cls.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-cls.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-cls.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-cls_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-cls.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-cls.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-cls_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-cls.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-cls.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-into/) | `edgetpu` | `yolov8n-cls_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-cls_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-cls_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-cls_ncnn_model/` | ✅ | `imgsz`, `half` | + +Voir les détails complets de l'`exportation` sur la page [Export](https://docs.ultralytics.com/modes/export/). diff --git a/docs/fr/tasks/detect.md b/docs/fr/tasks/detect.md new file mode 100644 index 00000000..325a05b1 --- /dev/null +++ b/docs/fr/tasks/detect.md @@ -0,0 +1,184 @@ +--- +comments: true +description: Documentation officielle pour YOLOv8 par Ultralytics. Apprenez comment entraîner, valider, prédire et exporter des modèles dans différents formats. Incluant des statistiques de performances détaillées. +keywords: YOLOv8, Ultralytics, détection d'objets, modèles pré-entraînés, entraînement, validation, prédiction, exportation de modèles, COCO, ImageNet, PyTorch, ONNX, CoreML +--- + +# Détection d'Objets + +Exemples de détection d'objets + +La détection d'objets est une tâche qui implique l'identification de l'emplacement et de la classe des objets dans une image ou un flux vidéo. + +La sortie d'un détecteur d'objets est un ensemble de boîtes englobantes qui entourent les objets de l'image, accompagnées de libellés de classe et de scores de confiance pour chaque boîte. La détection d'objets est un bon choix lorsque vous avez besoin d'identifier des objets d'intérêt dans une scène, mais que vous n'avez pas besoin de connaître exactement où se trouve l'objet ou sa forme exacte. + +

+
+ +
+ Regardez : Détection d'Objets avec le Modèle Pré-entraîné Ultralytics YOLOv8. +

+ +!!! tip "Conseil" + + Les modèles Detect YOLOv8 sont les modèles YOLOv8 par défaut, c.-à-d. `yolov8n.pt` et sont pré-entraînés sur le jeu de données [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml). + +## [Modèles](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8) + +Les modèles pré-entraînés Detect YOLOv8 sont présentés ici. Les modèles Detect, Segment, et Pose sont pré-entraînés sur le jeu de données [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), tandis que les modèles Classify sont pré-entraînés sur le jeu de données [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml). + +[Les modèles](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) se téléchargent automatiquement à partir de la dernière [version](https://github.com/ultralytics/assets/releases) d'Ultralytics lors de la première utilisation. + +| Modèle | Taille
(pixels) | mAPval
50-95 | Vitesse
CPU ONNX
(ms) | Vitesse
A100 TensorRT
(ms) | Paramètres
(M) | FLOPs
(B) | +|--------------------------------------------------------------------------------------|-------------------------|----------------------|----------------------------------|---------------------------------------|------------------------|-------------------| +| [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n.pt) | 640 | 37.3 | 80.4 | 0.99 | 3.2 | 8.7 | +| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s.pt) | 640 | 44.9 | 128.4 | 1.20 | 11.2 | 28.6 | +| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m.pt) | 640 | 50.2 | 234.7 | 1.83 | 25.9 | 78.9 | +| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l.pt) | 640 | 52.9 | 375.2 | 2.39 | 43.7 | 165.2 | +| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x.pt) | 640 | 53.9 | 479.1 | 3.53 | 68.2 | 257.8 | + +- Les valeurs de **mAPval** sont pour un seul modèle à une seule échelle sur le jeu de données [COCO val2017](http://cocodataset.org). +
Reproductible avec `yolo val detect data=coco.yaml device=0` +- La **Vitesse** est moyennée sur les images COCO val en utilisant une instance [Amazon EC2 P4d](https://aws.amazon.com/fr/ec2/instance-types/p4/). +
Reproductible avec `yolo val detect data=coco128.yaml batch=1 device=0|cpu` + +## Entraînement + +Entraînez le modèle YOLOv8n sur le jeu de données COCO128 pendant 100 époques à la taille d'image de 640. Pour une liste complète des arguments disponibles, consultez la page [Configuration](../../usage/cfg.md). + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Charger un modèle + model = YOLO('yolov8n.yaml') # construire un nouveau modèle à partir de YAML + model = YOLO('yolov8n.pt') # charger un modèle pré-entraîné (recommandé pour l'entraînement) + model = YOLO('yolov8n.yaml').load('yolov8n.pt') # construire à partir de YAML et transférer les poids + + # Entraîner le modèle + results = model.train(data='coco128.yaml', epochs=100, imgsz=640) + ``` + === "CLI" + + ```bash + # Construire un nouveau modèle à partir de YAML et commencer l'entraînement à partir de zéro + yolo detect train data=coco128.yaml model=yolov8n.yaml epochs=100 imgsz=640 + + # Commencer l'entraînement à partir d'un modèle *.pt pré-entraîné + yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 + + # Construire un nouveau modèle à partir de YAML, transférer les poids pré-entraînés et commencer l'entraînement + yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640 + ``` + +### Format des données + +Le format des jeux de données de détection YOLO est détaillé dans le [Guide des Jeux de Données](../../datasets/detect/index.md). Pour convertir votre jeu de données existant depuis d'autres formats (comme COCO, etc.) vers le format YOLO, veuillez utiliser l'outil [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) par Ultralytics. + +## Validation + +Validez la précision du modèle YOLOv8n entraîné sur le jeu de données COCO128. Aucun argument n'est nécessaire puisque le `modèle` conserve ses `données` d'entraînement et arguments en tant qu'attributs du modèle. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Charger un modèle + model = YOLO('yolov8n.pt') # charger un modèle officiel + model = YOLO('chemin/vers/best.pt') # charger un modèle personnalisé + + # Valider le modèle + metrics = model.val() # pas d'arguments nécessaires, jeu de données et paramètres enregistrés + metrics.box.map # map50-95 + metrics.box.map50 # map50 + metrics.box.map75 # map75 + metrics.box.maps # une liste contenant map50-95 de chaque catégorie + ``` + === "CLI" + + ```bash + yolo detect val model=yolov8n.pt # valider le modèle officiel + yolo detect val model=chemin/vers/best.pt # valider le modèle personnalisé + ``` + +## Prédiction + +Utilisez un modèle YOLOv8n entraîné pour exécuter des prédictions sur des images. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Charger un modèle + model = YOLO('yolov8n.pt') # charger un modèle officiel + model = YOLO('chemin/vers/best.pt') # charger un modèle personnalisé + + # Prédire avec le modèle + results = model('https://ultralytics.com/images/bus.jpg') # prédire sur une image + ``` + === "CLI" + + ```bash + yolo detect predict model=yolov8n.pt source='https://ultralytics.com/images/bus.jpg' # prédire avec le modèle officiel + yolo detect predict model=chemin/vers/best.pt source='https://ultralytics.com/images/bus.jpg' # prédire avec le modèle personnalisé + ``` + +Consultez les détails complets du mode `predict` sur la page [Prédire](https://docs.ultralytics.com/modes/predict/). + +## Exportation + +Exportez un modèle YOLOv8n dans un format différent tel que ONNX, CoreML, etc. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Charger un modèle + model = YOLO('yolov8n.pt') # charger un modèle officiel + model = YOLO('chemin/vers/best.pt') # charger un modèle entraîné personnalisé + + # Exporter le modèle + model.export(format='onnx') + ``` + === "CLI" + + ```bash + yolo export model=yolov8n.pt format=onnx # exporter le modèle officiel + yolo export model=chemin/vers/best.pt format=onnx # exporter le modèle entraîné personnalisé + ``` + +Les formats d'exportation YOLOv8 disponibles sont présentés dans le tableau ci-dessous. Vous pouvez directement prédire ou valider sur des modèles exportés, c'est-à-dire `yolo predict model=yolov8n.onnx`. Des exemples d'utilisation sont présentés pour votre modèle après l'exportation complète. + +| Format | Argument `format` | Modèle | Métadonnées | Arguments | +|----------------------------------------------------------------------|-------------------|---------------------------|-------------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [Modèle TF Enregistré](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | ✅ | `imgsz`, `keras` | +| [GraphDef TF](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TPU Edge TF](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | ✅ | `imgsz`, `half` | + +Consultez tous les détails `export` sur la page [Exporter](https://docs.ultralytics.com/modes/export/). diff --git a/docs/fr/tasks/index.md b/docs/fr/tasks/index.md new file mode 100644 index 00000000..10ef4558 --- /dev/null +++ b/docs/fr/tasks/index.md @@ -0,0 +1,55 @@ +--- +comments: true +description: Découvrez les tâches fondamentales de vision par ordinateur que YOLOv8 peut effectuer, y compris la détection, la segmentation, la classification et l'estimation de la pose. Comprenez leur utilité dans vos projets d'IA. +keywords: Ultralytics, YOLOv8, Détection, Segmentation, Classification, Estimation de la Pose, Cadre IA, Tâches de Vision par Ordinateur +--- + +# Tâches d'Ultralytics YOLOv8 + +
+Tâches prises en charge par Ultralytics YOLO + +YOLOv8 est un cadre d'intelligence artificielle qui prend en charge de multiples tâches de **vision par ordinateur**. Le cadre peut être utilisé pour effectuer de la [détection](detect.md), de la [segmentation](segment.md), de la [classification](classify.md) et de l'estimation de la [pose](pose.md). Chacune de ces tâches a un objectif et un cas d'utilisation différents. + +!!! note + + 🚧 Notre documentation multilingue est actuellement en construction et nous travaillons dur pour l'améliorer. Merci de votre patience ! 🙏 + +

+
+ +
+ Regardez : Explorez les Tâches YOLO Ultralytics : Détection d'Objets, Segmentation, Suivi et Estimation de la Pose. +

+ +## [Détection](detect.md) + +La détection est la tâche principale prise en charge par YOLOv8. Elle implique de détecter des objets dans une image ou une trame vidéo et de dessiner des boîtes englobantes autour d'eux. Les objets détectés sont classés dans différentes catégories en fonction de leurs caractéristiques. YOLOv8 peut détecter plusieurs objets dans une seule image ou trame vidéo avec une grande précision et rapidité. + +[Exemples de Détection](detect.md){ .md-button .md-button--primary} + +## [Segmentation](segment.md) + +La segmentation est une tâche qui implique de segmenter une image en différentes régions en fonction du contenu de l'image. Chaque région se voit attribuer une étiquette en fonction de son contenu. Cette tâche est utile dans des applications telles que la segmentation d'image et l'imagerie médicale. YOLOv8 utilise une variante de l'architecture U-Net pour effectuer la segmentation. + +[Exemples de Segmentation](segment.md){ .md-button .md-button--primary} + +## [Classification](classify.md) + +La classification est une tâche qui implique de classer une image dans différentes catégories. YOLOv8 peut être utilisé pour classifier des images en fonction de leur contenu. Il utilise une variante de l'architecture EfficientNet pour effectuer la classification. + +[Exemples de Classification](classify.md){ .md-button .md-button--primary} + +## [Pose](pose.md) + +La détection de pose/points clés est une tâche qui implique de détecter des points spécifiques dans une image ou une trame vidéo. Ces points sont appelés points clés et sont utilisés pour suivre le mouvement ou pour l'estimation de la pose. YOLOv8 peut détecter des points clés dans une image ou une trame vidéo avec une grande précision et rapidité. + +[Exemples de Pose](pose.md){ .md-button .md-button--primary} + +## Conclusion + +YOLOv8 prend en charge de multiples tâches, y compris la détection, la segmentation, la classification et la détection de points clés. Chacune de ces tâches a des objectifs et des cas d'utilisation différents. En comprenant les différences entre ces tâches, vous pouvez choisir la tâche appropriée pour votre application de vision par ordinateur. diff --git a/docs/fr/tasks/pose.md b/docs/fr/tasks/pose.md new file mode 100644 index 00000000..99988c53 --- /dev/null +++ b/docs/fr/tasks/pose.md @@ -0,0 +1,176 @@ +--- +comments: true +description: Apprenez à utiliser Ultralytics YOLOv8 pour des tâches d'estimation de pose. Trouvez des modèles pré-entraînés, apprenez à entraîner, valider, prédire et exporter vos propres modèles. +keywords: Ultralytics, YOLO, YOLOv8, estimation de pose, détection de points clés, détection d'objet, modèles pré-entraînés, apprentissage automatique, intelligence artificielle +--- + +# Estimation de Pose + +![Estimation de pose exemples](https://user-images.githubusercontent.com/26833433/243418616-9811ac0b-a4a7-452a-8aba-484ba32bb4a8.png) + +L'estimation de pose est une tâche qui consiste à identifier l'emplacement de points spécifiques dans une image, souvent appelés points clés. Ces points clés peuvent représenter différentes parties de l'objet telles que les articulations, les repères ou d'autres caractéristiques distinctives. L'emplacement des points clés est généralement représenté par un ensemble de coordonnées 2D `[x, y]` ou 3D `[x, y, visible]`. + +La sortie d'un modèle d'estimation de pose est un ensemble de points représentant les points clés sur un objet dans l'image, généralement accompagnés des scores de confiance pour chaque point. L'estimation de pose est un bon choix lorsque vous avez besoin d'identifier des parties spécifiques d'un objet dans une scène, et leur emplacement les uns par rapport aux autres. + +![Regardez : Estimation de Pose avec Ultralytics YOLOv8](https://www.youtube.com/embed/Y28xXQmju64?si=pCY4ZwejZFu6Z4kZ) + +!!! astuce "Conseil" + + Les modèles YOLOv8 _pose_ utilisent le suffixe `-pose`, c'est-à-dire `yolov8n-pose.pt`. Ces modèles sont entraînés sur le jeu de données [COCO keypoints](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco-pose.yaml) et conviennent à une variété de tâches d'estimation de pose. + +## [Modèles](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8) + +Les modèles Pose pré-entraînés YOLOv8 sont montrés ici. Les modèles Detect, Segment et Pose sont pré-entraînés sur le jeu de données [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), tandis que les modèles Classify sont pré-entraînés sur le jeu de données [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml). + +Les [Modèles](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) se téléchargent automatiquement à partir de la dernière version d'Ultralytics [release](https://github.com/ultralytics/assets/releases) lors de la première utilisation. + +| Modèle | taille
(pixels) | mAPpose
50-95 | mAPpose
50 | Vitesse
CPU ONNX
(ms) | Vitesse
A100 TensorRT
(ms) | params
(M) | FLOPs
(B) | +|------------------------------------------------------------------------------------------------------|-------------------------|-----------------------|--------------------|----------------------------------|---------------------------------------|--------------------|-------------------| +| [YOLOv8n-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-pose.pt) | 640 | 50.4 | 80.1 | 131.8 | 1.18 | 3.3 | 9.2 | +| [YOLOv8s-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-pose.pt) | 640 | 60.0 | 86.2 | 233.2 | 1.42 | 11.6 | 30.2 | +| [YOLOv8m-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-pose.pt) | 640 | 65.0 | 88.8 | 456.3 | 2.00 | 26.4 | 81.0 | +| [YOLOv8l-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-pose.pt) | 640 | 67.6 | 90.0 | 784.5 | 2.59 | 44.4 | 168.6 | +| [YOLOv8x-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose.pt) | 640 | 69.2 | 90.2 | 1607.1 | 3.73 | 69.4 | 263.2 | +| [YOLOv8x-pose-p6](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose-p6.pt) | 1280 | 71.6 | 91.2 | 4088.7 | 10.04 | 99.1 | 1066.4 | + +- Les valeurs de **mAPval** sont pour un seul modèle à une seule échelle sur le jeu de données [COCO Keypoints val2017](http://cocodataset.org). +
Reproduire avec `yolo val pose data=coco-pose.yaml device=0` +- La **vitesse** moyenne sur les images de validation COCO en utilisant une instance [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/). +
Reproduire avec `yolo val pose data=coco8-pose.yaml batch=1 device=0|cpu` + +## Entraînement + +Entraînez un modèle YOLOv8-pose sur le jeu de données COCO128-pose. + +!!! exemple "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Charger un modèle + model = YOLO('yolov8n-pose.yaml') # construire un nouveau modèle à partir du YAML + model = YOLO('yolov8n-pose.pt') # charger un modèle pré-entraîné (recommandé pour l'entraînement) + model = YOLO('yolov8n-pose.yaml').load('yolov8n-pose.pt') # construire à partir du YAML et transférer les poids + + # Entraîner le modèle + résultats = model.train(data='coco8-pose.yaml', epochs=100, imgsz=640) + ``` + === "CLI" + + ```bash + # Construire un nouveau modèle à partir du YAML et commencer l'entraînement à partir de zéro + yolo pose train data=coco8-pose.yaml model=yolov8n-pose.yaml epochs=100 imgsz=640 + + # Commencer l'entraînement à partir d'un modèle *.pt pré-entraîné + yolo pose train data=coco8-pose.yaml model=yolov8n-pose.pt epochs=100 imgsz=640 + + # Construire un nouveau modèle à partir du YAML, transférer les poids pré-entraînés et commencer l'entraînement + yolo pose train data=coco8-pose.yaml model=yolov8n-pose.yaml pretrained=yolov8n-pose.pt epochs=100 imgsz=640 + ``` + +### Format du jeu de données + +Le format du jeu de données YOLO pose peut être trouvé en détail dans le [Guide des jeux de données](../../datasets/pose/index.md). Pour convertir votre jeu de données existant à partir d'autres formats (comme COCO, etc.) vers le format YOLO, veuillez utiliser l'outil [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) d'Ultralytics. + +## Val + +Validez la précision du modèle YOLOv8n-pose entraîné sur le jeu de données COCO128-pose. Aucun argument n'est nécessaire car le `modèle` conserve ses données d'entraînement et arguments en tant qu'attributs du modèle. + +!!! exemple "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Charger un modèle + model = YOLO('yolov8n-pose.pt') # charger un modèle officiel + model = YOLO('chemin/vers/best.pt') # charger un modèle personnalisé + + # Valider le modèle + métriques = model.val() # aucun argument nécessaire, jeu de données et paramètres mémorisés + métriques.box.map # map50-95 + métriques.box.map50 # map50 + métriques.box.map75 # map75 + métriques.box.maps # une liste contenant map50-95 de chaque catégorie + ``` + === "CLI" + + ```bash + yolo pose val model=yolov8n-pose.pt # val modèle officiel + yolo pose val model=chemin/vers/best.pt # val modèle personnalisé + ``` + +## Prédiction + +Utilisez un modèle YOLOv8n-pose entraîné pour exécuter des prédictions sur des images. + +!!! exemple "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Charger un modèle + model = YOLO('yolov8n-pose.pt') # charger un modèle officiel + model = YOLO('chemin/vers/best.pt') # charger un modèle personnalisé + + # Prédire avec le modèle + résultats = model('https://ultralytics.com/images/bus.jpg') # prédire sur une image + ``` + === "CLI" + + ```bash + yolo pose predict model=yolov8n-pose.pt source='https://ultralytics.com/images/bus.jpg' # prédire avec modèle officiel + yolo pose predict model=chemin/vers/best.pt source='https://ultralytics.com/images/bus.jpg' # prédire avec modèle personnalisé + ``` + +Consultez les détails complets du mode `predict` sur la page [Prédire](https://docs.ultralytics.com/modes/predict/). + +## Exportation + +Exportez un modèle YOLOv8n Pose dans un autre format tel que ONNX, CoreML, etc. + +!!! exemple "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Charger un modèle + model = YOLO('yolov8n-pose.pt') # charger un modèle officiel + model = YOLO('chemin/vers/best.pt') # charger un modèle personnalisé entraîné + + # Exporter le modèle + model.export(format='onnx') + ``` + === "CLI" + + ```bash + yolo export model=yolov8n-pose.pt format=onnx # exporter modèle officiel + yolo export model=chemin/vers/best.pt format=onnx # exporter modèle personnalisé entraîné + ``` + +Les formats d'exportation YOLOv8-pose disponibles sont dans le tableau ci-dessous. Vous pouvez prédire ou valider directement sur des modèles exportés, par exemple `yolo predict model=yolov8n-pose.onnx`. Des exemples d'utilisation sont montrés pour votre modèle après la fin de l'exportation. + +| Format | Argument `format` | Modèle | Métadonnées | Arguments | +|--------------------------------------------------------------------|-------------------|--------------------------------|-------------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n-pose.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-pose.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-pose.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-pose_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-pose.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-pose.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-pose_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-pose.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-pose.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-pose_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-pose_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-pose_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-pose_ncnn_model/` | ✅ | `imgsz`, `half` | + +Consultez les détails complets de `export` sur la page [Exporter](https://docs.ultralytics.com/modes/export/). diff --git a/docs/fr/tasks/segment.md b/docs/fr/tasks/segment.md new file mode 100644 index 00000000..89624539 --- /dev/null +++ b/docs/fr/tasks/segment.md @@ -0,0 +1,189 @@ +--- +comments: true +description: Apprenez à utiliser les modèles de segmentation d'instance avec Ultralytics YOLO. Instructions pour la formation, la validation, la prédiction d'image et l'exportation de modèle. +keywords: yolov8, segmentation d'instance, Ultralytics, jeu de données COCO, segmentation d'image, détection d'objet, formation de modèle, validation de modèle, prédiction d'image, exportation de modèle +--- + +# Segmentation d'Instance + +Exemples de segmentation d'instance + +La segmentation d'instance va plus loin que la détection d'objet et implique d'identifier des objets individuels dans une image et de les segmenter du reste de l'image. + +Le résultat d'un modèle de segmentation d'instance est un ensemble de masques ou de contours qui délimitent chaque objet dans l'image, accompagnés d'étiquettes de classe et de scores de confiance pour chaque objet. La segmentation d'instance est utile lorsque vous avez besoin de savoir non seulement où se trouvent les objets dans une image, mais aussi quelle est leur forme exacte. + +

+
+ +
+ Regarder : Exécutez la Segmentation avec le Modèle Ultralytics YOLOv8 Pré-Entraîné en Python. +

+ +!!! astuce "Astuce" + + Les modèles YOLOv8 Segment utilisent le suffixe `-seg`, par exemple `yolov8n-seg.pt` et sont pré-entraînés sur [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml). + +## [Modèles](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8) + +Les modèles Segment pré-entraînés YOLOv8 sont indiqués ici. Les modèles Detect, Segment et Pose sont pré-entraînés sur le jeu de données [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), tandis que les modèles Classify sont pré-entraînés sur le jeu de données [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml). + +Les [modèles](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) se téléchargent automatiquement depuis la dernière [version](https://github.com/ultralytics/assets/releases) Ultralytics lors de la première utilisation. + +| Modèle | Taille
(pixels) | mAPboîte
50-95 | mAPmasque
50-95 | Vitesse
CPU ONNX
(ms) | Vitesse
A100 TensorRT
(ms) | Paramètres
(M) | FLOPs
(B) | +|----------------------------------------------------------------------------------------------|-------------------------|------------------------|-------------------------|----------------------------------|---------------------------------------|------------------------|-------------------| +| [YOLOv8n-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-seg.pt) | 640 | 36.7 | 30.5 | 96.1 | 1.21 | 3.4 | 12.6 | +| [YOLOv8s-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-seg.pt) | 640 | 44.6 | 36.8 | 155.7 | 1.47 | 11.8 | 42.6 | +| [YOLOv8m-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-seg.pt) | 640 | 49.9 | 40.8 | 317.0 | 2.18 | 27.3 | 110.2 | +| [YOLOv8l-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-seg.pt) | 640 | 52.3 | 42.6 | 572.4 | 2.79 | 46.0 | 220.5 | +| [YOLOv8x-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-seg.pt) | 640 | 53.4 | 43.4 | 712.1 | 4.02 | 71.8 | 344.1 | + +- Les valeurs **mAPval** sont pour un seul modèle à une seule échelle sur le jeu de données [COCO val2017](http://cocodataset.org). +
Pour reproduire, utilisez `yolo val segment data=coco.yaml device=0` +- **Vitesse** moyennée sur les images COCO val en utilisant une instance [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/). +
Pour reproduire, utilisez `yolo val segment data=coco128-seg.yaml batch=1 device=0|cpu` + +## Formation + +Entraînez YOLOv8n-seg sur le jeu de données COCO128-seg pendant 100 époques à la taille d'image 640. Pour une liste complète des arguments disponibles, consultez la page [Configuration](../../usage/cfg.md). + +!!! exemple "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Charger un modèle + model = YOLO('yolov8n-seg.yaml') # construire un nouveau modèle à partir du YAML + model = YOLO('yolov8n-seg.pt') # charger un modèle pré-entraîné (recommandé pour la formation) + model = YOLO('yolov8n-seg.yaml').load('yolov8n.pt') # construire à partir du YAML et transférer les poids + + # Entraîner le modèle + résultats = model.train(data='coco128-seg.yaml', epochs=100, imgsz=640) + ``` + === "CLI" + + ```bash + # Construire un nouveau modèle à partir du YAML et commencer la formation à partir de zéro + yolo segment train data=coco128-seg.yaml model=yolov8n-seg.yaml epochs=100 imgsz=640 + + # Commencer la formation à partir d'un modèle *.pt pré-entraîné + yolo segment train data=coco128-seg.yaml model=yolov8n-seg.pt epochs=100 imgsz=640 + + # Construire un nouveau modèle à partir du YAML, transférer les poids pré-entraînés et commencer la formation + yolo segment train data=coco128-seg.yaml model=yolov8n-seg.yaml pretrained=yolov8n-seg.pt epochs=100 imgsz=640 + ``` + +### Format des données + +Le format des données de segmentation YOLO peut être trouvé en détail dans le [Guide du Jeu de Données](../../datasets/segment/index.md). Pour convertir votre jeu de données existant à partir d'autres formats (comme COCO, etc.) au format YOLO, veuillez utiliser l'outil [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) par Ultralytics. + +## Validation + +Validez la précision du modèle YOLOv8n-seg entraîné sur le jeu de données COCO128-seg. Aucun argument n'est nécessaire car le `modèle` +conserve ses données de formation et ses arguments comme attributs du modèle. + +!!! exemple "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Charger un modèle + model = YOLO('yolov8n-seg.pt') # charger un modèle officiel + model = YOLO('chemin/vers/le/meilleur.pt') # charger un modèle personnalisé + + # Valider le modèle + métriques = model.val() # aucun argument nécessaire, jeu de données et paramètres mémorisés + métriques.box.map # map50-95(B) + métriques.box.map50 # map50(B) + métriques.box.map75 # map75(B) + métriques.box.maps # une liste contient map50-95(B) de chaque catégorie + métriques.seg.map # map50-95(M) + métriques.seg.map50 # map50(M) + métriques.seg.map75 # map75(M) + métriques.seg.maps # une liste contient map50-95(M) de chaque catégorie + ``` + === "CLI" + + ```bash + yolo segment val model=yolov8n-seg.pt # valider le modèle officiel + yolo segment val model=chemin/vers/le/meilleur.pt # valider le modèle personnalisé + ``` + +## Prédiction + +Utilisez un modèle YOLOv8n-seg entraîné pour effectuer des prédictions sur des images. + +!!! exemple "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Charger un modèle + model = YOLO('yolov8n-seg.pt') # charger un modèle officiel + model = YOLO('chemin/vers/le/meilleur.pt') # charger un modèle personnalisé + + # Prédire avec le modèle + résultats = model('https://ultralytics.com/images/bus.jpg') # prédire sur une image + ``` + === "CLI" + + ```bash + yolo segment predict model=yolov8n-seg.pt source='https://ultralytics.com/images/bus.jpg' # prédire avec le modèle officiel + yolo segment predict model=chemin/vers/le/meilleur.pt source='https://ultralytics.com/images/bus.jpg' # prédire avec le modèle personnalisé + ``` + +Voir les détails complets du mode `predict` sur la page [Predict](https://docs.ultralytics.com/modes/predict/). + +## Exportation + +Exportez un modèle YOLOv8n-seg vers un format différent comme ONNX, CoreML, etc. + +!!! exemple "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Charger un modèle + model = YOLO('yolov8n-seg.pt') # charger un modèle officiel + model = YOLO('chemin/vers/le/meilleur.pt') # charger un modèle entraîné personnalisé + + # Exporter le modèle + model.export(format='onnx') + ``` + === "CLI" + + ```bash + yolo export model=yolov8n-seg.pt format=onnx # exporter le modèle officiel + yolo export model=chemin/vers/le/meilleur.pt format=onnx # exporter le modèle entraîné personnalisé + ``` + +Les formats d'exportation YOLOv8-seg disponibles sont dans le tableau ci-dessous. Vous pouvez prédire ou valider directement sur les modèles exportés, par exemple `yolo predict model=yolov8n-seg.onnx`. Des exemples d'utilisation sont présentés pour votre modèle après l'exportation. + +| Format | Argument `format` | Modèle | Métadonnées | Arguments | +|--------------------------------------------------------------------|-------------------|-------------------------------|-------------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n-seg.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-seg.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-seg.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-seg_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-seg.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-seg.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-seg_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-seg.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-seg.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-seg_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-seg_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-seg_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-seg_ncnn_model/` | ✅ | `imgsz`, `half` | + +Voir les détails complets d'`export` sur la page [Export](https://docs.ultralytics.com/modes/export/). diff --git a/docs/ja/datasets/index.md b/docs/ja/datasets/index.md new file mode 100644 index 00000000..4a2bf087 --- /dev/null +++ b/docs/ja/datasets/index.md @@ -0,0 +1,127 @@ +--- +comments: true +description: Ultralyticsがサポートするオブジェクト検出、セグメンテーション、ポーズ推定、画像分類、マルチオブジェクト追跡に対応した各種コンピュータビジョンデータセットを探求します。 +keywords: コンピュータビジョン, データセット, Ultralytics, YOLO, オブジェクト検出, インスタンスセグメンテーション, ポーズ推定, 画像分類, マルチオブジェクト追跡 +--- + +# データセット概要 + +Ultralyticsは、検出、インスタンスセグメンテーション、ポーズ推定、分類、マルチオブジェクト追跡などのコンピュータビジョンタスクを容易にするために、様々なデータセットをサポートしています。以下は主要なUltralyticsデータセットのリストであり、それに続いて各コンピュータビジョンタスクの概要と関連するデータセットが記載されています。 + +!!! note + + 🚧 当社の多言語ドキュメントは現在作成中であり、改善のため頑張って作業しています。ご理解いただいてありがとうございます！ 🙏 + +## [検出データセット](../../datasets/detect/index.md) + +バウンディングボックスオブジェクト検出は、画像内のオブジェクトを検出し、各オブジェクトの周りにバウンディングボックスを描くことによって局在化するコンピュータビジョン技術です。 + +- [Argoverse](../../datasets/detect/argoverse.md): 都市環境からの3D追跡と運動予測データを含むデータセットで、詳細なアノテーションが付けられています。 +- [COCO](../../datasets/detect/coco.md): オブジェクト検出、セグメンテーション、キャプショニング用に設計された大規模データセットで、20万以上のラベル付き画像が含まれています。 +- [COCO8](../../datasets/detect/coco8.md): COCO trainとCOCO valの最初の4画像を含み、クイックテストに適しています。 +- [Global Wheat 2020](../../datasets/detect/globalwheat2020.md): 世界中から収集された小麦頭画像のデータセットで、オブジェクト検出と局在化タスク用です。 +- [Objects365](../../datasets/detect/objects365.md): 365のオブジェクトカテゴリと60万以上のアノテート画像を含む高品質の大規模オブジェクト検出データセットです。 +- [OpenImagesV7](../../datasets/detect/open-images-v7.md): Googleによる総合的なデータセットで、170万のトレイン画像と42kのバリデーション画像を含んでいます。 +- [SKU-110K](../../datasets/detect/sku-110k.md): 小売環境での密集したオブジェクト検出を特徴とするデータセットで、11Kの画像と170万のバウンディングボックスがあります。 +- [VisDrone](../../datasets/detect/visdrone.md): ドローンがキャプチャした映像からのオブジェクト検出とマルチオブジェクト追跡データを含むデータセットで、1万以上の画像とビデオシーケンスがあります。 +- [VOC](../../datasets/detect/voc.md): パスカルビジュアルオブジェクトクラス（VOC）データセットで、オブジェクト検出とセグメンテーション用に、20のオブジェクトクラスと11K以上の画像が含まれています。 +- [xView](../../datasets/detect/xview.md): 上空画像でのオブジェクト検出用データセットで、60のオブジェクトカテゴリを含み、100万以上のアノテートオブジェクトが含まれています。 + +## [インスタンスセグメンテーションデータセット](../../datasets/segment/index.md) + +インスタンスセグメンテーションは、画像内のオブジェクトをピクセルレベルで識別し、局在化するコンピュータビジョン技術です。 + +- [COCO](../../datasets/segment/coco.md): オブジェクト検出、セグメンテーション、キャプショニングタスク用に設計された大規模データセットで、20万以上のラベル付き画像が含まれています。 +- [COCO8-seg](../../datasets/segment/coco8-seg.md): セグメンテーションアノテーションを含む8つのCOCO画像を含んだ、より小さなインスタンスセグメンテーションタスク用データセットです。 + +## [ポーズ推定](../../datasets/pose/index.md) + +ポーズ推定は、カメラや世界座標系に対するオブジェクトのポーズを決定するために使用される技術です。 + +- [COCO](../../datasets/pose/coco.md): ポーズ推定タスク用に設計された大規模データセットで、人間のポーズアノテーションが含まれています。 +- [COCO8-pose](../../datasets/pose/coco8-pose.md): 人間のポーズアノテーションを含む8つのCOCO画像を含んだ、小規模のポーズ推定タスク用データセットです。 +- [Tiger-pose](../../datasets/pose/tiger-pose.md): タイガーのポーズ推定タスク用に、263枚の画像で構成され、1匹のタイガーに対して12個のキーポイントがアノテートされたコンパクトなデータセットです。 + +## [分類](../../datasets/classify/index.md) + +画像分類は、そのビジュアルコンテンツに基づいて一つまたは複数の定義済みクラスやカテゴリに画像を分類するコンピュータビジョンタスクです。 + +- [Caltech 101](../../datasets/classify/caltech101.md): 101のオブジェクトカテゴリを含む画像で構成された、画像分類タスク用データセッ トです。 +- [Caltech 256](../../datasets/classify/caltech256.md): Caltech 101の拡張版で、256のオブジェクトカテゴリとより難易度の高い画像が含まれています。 +- [CIFAR-10](../../datasets/classify/cifar10.md): 10クラスに60Kの32x32カラー画像が含まれるデータセットで、クラスごとに6Kの画像があります。 +- [CIFAR-100](../../datasets/classify/cifar100.md): CIFAR-10の拡張版で、100のオブジェクトカテゴリとクラスごとに600の画像が含まれています。 +- [Fashion-MNIST](../../datasets/classify/fashion-mnist.md): 画像分類タスク用の70,000枚のグレースケールのファッションカテゴリ画像で構成されるデータセットです。 +- [ImageNet](../../datasets/classify/imagenet.md): オブジェクト検出および画像分類用の大規模データセットで、1400万枚を超える画像と20,000カテゴリが含まれています。 +- [ImageNet-10](../../datasets/classify/imagenet10.md): ImageNetのより小さなサブセットで、高速な実験とテストに適した10カテゴリが含まれています。 +- [Imagenette](../../datasets/classify/imagenette.md): ImageNetから抽出された10個の簡単に識別可能なクラスを含む、より小さなサブセットです。 +- [Imagewoof](../../datasets/classify/imagewoof.md): ImageNetから抽出された10の犬種カテゴリを含む、画像分類タスクにさらに挑戦的なサブセットです。 +- [MNIST](../../datasets/classify/mnist.md): 手書き数字の70,000枚のグレースケール画像で構成される画像分類タスク用データセットです。 + +## [指向性バウンディングボックス](../../datasets/obb/index.md) + +指向性バウンディングボックス（OBB）は、回転したバウンディングボックスを使用して画像内の斜めのオブジェクトを検出するためのコンピュータビジョン手法で、主に航空写真や衛星画像へ適用されます。 + +- [DOTAv2](../../datasets/obb/dota-v2.md): 170万インスタンスと11,268枚の画像を含む人気のOBB航空画像データセットです。 + +## [マルチオブジェクト追跡](../../datasets/track/index.md) + +マルチオブジェクト追跡は、複数オブジェクトをビデオシーケンスで時間を追って検出し、追跡するコンピュータビジョン技術です。 + +- [Argoverse](../../datasets/detect/argoverse.md): 都市環境からの3D追跡と運動予測データを含むデータセットで、マルチオブジェクト追跡タスクに富んだアノテーションがあります。 +- [VisDrone](../../datasets/detect/visdrone.md): ドローンがキャプチャした映像からのオブジェクト検出とマルチオブジェクト追跡データを含むデータセットで、1万以上の画像とビデオシーケンスがあります。 + +## 新しいデータセットの提供 + +新しいデータセットを提供するには、既存のインフラと適合するように複数のステップが必要です。以下が必要なステップです： + +### 新しいデータセットを提供する手順 + +1. **画像を収集**します：データセットに属する画像を収集します。これらは、公共データベースや自分のコレクションなど、さまざまなソースから収集することができます。 + +2. **画像をアノテート**します：これらの画像を、タスクに応じてバウンディングボックス、セグメント、またはキーポイントでアノテートします。 + +3. **アノテーションをエクスポート**します：これらのアノテーションを、UltralyticsがサポートしているYOLO *.txtファイルフォーマットに変換します。 + +4. **データセットを編成**します：データセットを正しいフォルダ構造に配置します。`train/` および `val/` のトップレベルディレクトリーを持ち、各ディレクトリー内に `images/` および `labels/` のサブディレクトリーがあるべきです。 + + ``` + dataset/ + ├── train/ + │ ├── images/ + │ └── labels/ + └── val/ + ├── images/ + └── labels/ + ``` + +5. **`data.yaml`ファイルを作成**します：データセットのルートディレクトリに、データセット、クラス、その他の必要な情報を記述する`data.yaml`ファイルを作成します。 + +6. **画像を最適化（オプショナル）**します：データセットのサイズを削減してより効率的な処理を行いたい場合は、以下のコードを使用して画像を最適化することができます。これは必須ではありませんが、データセットのサイズを小さくし、ダウンロード速度を上げるために推奨されます。 + +7. **データセットをZip**します：データセットフォルダ全体をzipファイルに圧縮します。 + +8. **ドキュメントとPRを作成**します：データセットに関するドキュメンテーションページを作成し、既存のフレームワークにどのように適合するかを説明します。その後、Pull Request (PR)を提出します。PRを提出する方法の詳細については、[Ultralyticsの貢献ガイドライン](https://docs.ultralytics.com/help/contributing)を参照してください。 + +### データセットを最適化してZipするためのサンプルコード + +!!! example "データセットを最適化してZipする" + + === "Python" + + ```python + from pathlib import Path + from ultralytics.data.utils import compress_one_image + from ultralytics.utils.downloads import zip_directory + + # データセットディレクトリを定義 + path = Path('path/to/dataset') + + # データセット内の画像を最適化 (オプショナル) + for f in path.rglob('*.jpg'): + compress_one_image(f) + + # 'path/to/dataset.zip'にデータセットをZip + zip_directory(path) + ``` + +これらのステップに従えば、Ultralyticsの既存の構造に適切に統合された新しいデータセットを提供することができます。 diff --git a/docs/ja/index.md b/docs/ja/index.md new file mode 100644 index 00000000..e8987836 --- /dev/null +++ b/docs/ja/index.md @@ -0,0 +1,82 @@ +--- +comments: true +description: Ultralytics YOLOv8に関する完全ガイド。高速で高精度なオブジェクト検出・画像セグメンテーションモデル。インストール、予測、トレーニングチュートリアルなど。 +keywords: Ultralytics, YOLOv8, オブジェクト検出, 画像セグメンテーション, 機械学習, ディープラーニング, コンピュータビジョン, YOLOv8 インストール, YOLOv8 予測, YOLOv8 トレーニング, YOLO 歴史, YOLO ライセンス +--- + +
+

+ + Ultralytics YOLOバナー +

+ Ultralytics GitHub + + Ultralytics LinkedIn + + Ultralytics Twitter + + Ultralytics YouTube + + Ultralytics TikTok + + Ultralytics Instagram + + Ultralytics Discord +
+
+ Ultralytics CI + Ultralytics コードカバレッジ + YOLOv8 引用情報 + Docker プル +
+ Gradient上で実行 + Colabで開く + Kaggleで開く +
+ +全く新しい[Ultralytics](https://ultralytics.com)の[YOLOv8](https://github.com/ultralytics/ultralytics)を紹介します。これは、実時間で動作するオブジェクト検出および画像セグメンテーションモデルの最新バージョンです。YOLOv8は、ディープラーニングとコンピュータビジョンの最先端の進歩に基づいており、速度と精度の面で比類のない性能を提供します。その合理化された設計により、エッジデバイスからクラウドAPIまで、さまざまなアプリケーションやハードウェアプラットフォームへの適応が容易です。 + +YOLOv8ドキュメントを探索し、その特徴と能力を理解し、活用するための包括的なリソースを提供します。機械学習の経験者であれ、分野の新入りであれ、このハブはあなたのプロジェクトでYOLOv8のポテンシャルを最大限に引き出すことを目指しています。 + +!!! note + + 🚧 多言語ドキュメントは現在作成中であり、改善に努めております。お待ちいただき、ありがとうございます！ 🙏 + +## はじめに + +- pipで`ultralytics`を**インストール**し、数分で稼働   [:material-clock-fast: はじめに](quickstart.md){ .md-button } +- YOLOv8で新しい画像やビデオに**予測**   [:octicons-image-16: 画像で予測](modes/predict.md){ .md-button } +- 独自のカスタムデータセットで新しいYOLOv8モデルを**トレーニング**   [:fontawesome-solid-brain: モデルをトレーニング](modes/train.md){ .md-button } +- セグメント、クラス分け、ポーズ、トラッキングなどのYOLOv8タスクを**探求**   [:material-magnify-expand: タスクを探求](tasks/index.md){ .md-button } + +

+
+ +
+ 視聴: Google ColabでカスタムデータセットにYOLOv8モデルをトレーニングする方法。 +

+ +## YOLO: 簡単な歴史 + +[YOLO](https://arxiv.org/abs/1506.02640)（You Only Look Once、一度だけ見る）は、ワシントン大学のJoseph RedmonとAli Farhadiによって開発された、流行のオブジェクト検出および画像セグメンテーションモデルです。2015年に発売されたYOLOは、その高速かつ正確さからすぐに人気を博しました。 + +- [YOLOv2](https://arxiv.org/abs/1612.08242)は、2016年にリリースされ、バッチ正規化、アンカーボックス、次元クラスタリングを導入し、オリジナルモデルを改善しました。 +- [YOLOv3](https://pjreddie.com/media/files/papers/YOLOv3.pdf)は、2018年により効率的なバックボーンネットワーク、複数のアンカー、空間ピラミッドプーリングを使用して、モデルの性能を一段と向上させました。 +- [YOLOv4](https://arxiv.org/abs/2004.10934)は2020年にリリースされ、モザイクデータオーギュメンテーション、新しいアンカーフリー検出ヘッド、新しい損失関数などの革新を導入しました。 +- [YOLOv5](https://github.com/ultralytics/yolov5)は、モデルの性能をさらに向上させ、ハイパーパラメータ最適化、統合実験トラッキング、一般的なエクスポート形式への自動エクスポートなどの新機能を追加しました。 +- [YOLOv6](https://github.com/meituan/YOLOv6)は、2022年に[Meituan](https://about.meituan.com/)によってオープンソース化され、同社の多くの自動配送ロボットで使用されています。 +- [YOLOv7](https://github.com/WongKinYiu/yolov7)は、COCOキーポイントデータセット上のポーズ推定などの追加タスクを追加しました。 +- [YOLOv8](https://github.com/ultralytics/ultralytics)は、UltralyticsによるYOLOの最新版です。最先端の最新モデルとして、YOLOv8は前バージョンの成功に基づき、性能、柔軟性、効率を向上させる新機能や改善を導入しています。YOLOv8は、[検出](tasks/detect.md)、[セグメンテーション](tasks/segment.md)、[ポーズ推定](tasks/pose.md)、[トラッキング](modes/track.md)、[分類](tasks/classify.md)など、視覚AIタスクの全範囲をサポートしています。この多才性により、ユーザーは多様なアプリケーションとドメインでYOLOv8の機能を活用することができます。 + +## YOLO ライセンス: UltralyticsのYOLOはどのようにライセンスされていますか？ + +Ultralyticsは、さまざまなユースケースに対応するために2種類のライセンスオプションを提供しています： + +- **AGPL-3.0 ライセンス**: この[OSI認定](https://opensource.org/licenses/)のオープンソースライセンスは、学生や愛好家に理想的であり、オープンなコラボレーションと知識共有を奨励しています。詳細は[ライセンス](https://github.com/ultralytics/ultralytics/blob/main/LICENSE)ファイルをご覧ください。 +- **エンタープライズ ライセンス**: 商業用途に設計されたこのライセンスは、UltralyticsのソフトウェアおよびAIモデルを商業商品やサービスにシームレスに統合することを許可し、AGPL-3.0のオープンソース要件をバイパスできます。商業的なオファリングへの組み込みを含むシナリオであれば、[Ultralytics ライセンス](https://ultralytics.com/license)を通じてお問い合わせください。 + +私たちのライセンス戦略は、オープンソースプロジェクトに対するあらゆる改善がコミュニティに還元されることを確実にするために設計されています。私たちはオープンソースの原則を大切にしており、私たちの貢献が全ての人にとって有益な方法で利用可能であり、さらに拡張されることを保証することを使命としています。❤️ diff --git a/docs/ja/models/index.md b/docs/ja/models/index.md new file mode 100644 index 00000000..9e8d7655 --- /dev/null +++ b/docs/ja/models/index.md @@ -0,0 +1,94 @@ +--- +comments: true +description: UltralyticsがサポートするYOLOファミリー、SAM、MobileSAM、FastSAM、YOLO-NAS、RT-DETRモデルの多様な範囲を探る。CLIとPythonの両方の使用例で始める。 +keywords: Ultralytics, ドキュメンテーション, YOLO, SAM, MobileSAM, FastSAM, YOLO-NAS, RT-DETR, モデル, アーキテクチャ, Python, CLI +--- + +# Ultralyticsによるサポートモデル + +Ultralyticsのモデルドキュメンテーションへようこそ！[オブジェクト検出](../tasks/detect.md)、[インスタンスセグメンテーション](../tasks/segment.md)、[画像分類](../tasks/classify.md)、[ポーズ推定](../tasks/pose.md)、[マルチオブジェクトトラッキング](../modes/track.md)など、特定のタスクに適した幅広いモデルをサポートしています。Ultralyticsにあなたのモデルアーキテクチャを寄稿したい場合は、[コントリビューティングガイド](../../help/contributing.md)を確認してください。 + +!!! note + + 🚧 弊社の多言語ドキュメンテーションは現在建設中で、改善に向けて努力しています。ご理解いただきありがとうございます！🙏 + +## 注目のモデル + +以下はサポートされる主要なモデルのいくつかです： + +1. **[YOLOv3](../../models/yolov3.md)**: ジョセフ・レッドモンによるYOLOモデルファミリーの第三世代で、効率的なリアルタイムオブジェクト検出能力があります。 +2. **[YOLOv4](../../models/yolov4.md)**: YOLOv3へのdarknet-nativeなアップデートで、2020年にアレクセイ・ボチコフスキーが公開しました。 +3. **[YOLOv5](../../models/yolov5.md)**: UltralyticsによるYOLOアーキテクチャの改良版で、以前のバージョンと比較してパフォーマンスとスピードのトレードオフが向上しています。 +4. **[YOLOv6](../../models/yolov6.md)**: 2022年に[美団](https://about.meituan.com/)によってリリースされ、同社の多くの自治配送ロボットで使用されています。 +5. **[YOLOv7](../../models/yolov7.md)**: YOLOv4の作者によって2022年にリリースされた更新されたYOLOモデル。 +6. **[YOLOv8](../../models/yolov8.md)**: YOLOファミリーの最新バージョンで、インスタンスセグメンテーション、ポーズ/キーポイント推定、分類などの機能が強化されています。 +7. **[Segment Anything Model (SAM)](../../models/sam.md)**: MetaのSegment Anything Model (SAM)です。 +8. **[Mobile Segment Anything Model (MobileSAM)](../../models/mobile-sam.md)**: 慶尚大学によるモバイルアプリケーション向けのMobileSAM。 +9. **[Fast Segment Anything Model (FastSAM)](../../models/fast-sam.md)**: 中国科学院自動化研究所の画像・映像分析グループによるFastSAM。 +10. **[YOLO-NAS](../../models/yolo-nas.md)**: YOLO Neural Architecture Search (NAS)モデル。 +11. **[Realtime Detection Transformers (RT-DETR)](../../models/rtdetr.md)**: BaiduのPaddlePaddle Realtime Detection Transformer (RT-DETR)モデル。 + +

+
+ +
+ 視聴： Ultralytics YOLOモデルを数行のコードで実行。 +

+ +## 入門：使用例 + +!!! example "" + + === "Python" + + PyTorchの事前訓練済み`*.pt`モデルや設定`*.yaml`ファイルを`YOLO()`, `SAM()`, `NAS()`, `RTDETR()`クラスに渡して、Pythonでモデルインスタンスを生成できます： + + ```python + from ultralytics import YOLO + + # COCO事前訓練済みのYOLOv8nモデルをロード + model = YOLO('yolov8n.pt') + + # モデル情報の表示（オプション） + model.info() + + # COCO8の例示データセットでモデルを100エポック訓練 + results = model.train(data='coco8.yaml', epochs=100, imgsz=640) + + # 'bus.jpg'画像上でYOLOv8nモデルによる推論実行 + results = model('path/to/bus.jpg') + ``` + + === "CLI" + + モデルを直接実行するためのCLIコマンドがあります： + + ```bash + # COCO事前訓練済みのYOLOv8nモデルをロードし、COCO8の例示データセットで100エポック訓練 + yolo train model=yolov8n.pt data=coco8.yaml epochs=100 imgsz=640 + + # COCO事前訓練済みのYOLOv8nモデルをロードし、'bus.jpg'画像上で推論実行 + yolo predict model=yolov8n.pt source=path/to/bus.jpg + ``` + +## 新しいモデルの提供 + +Ultralyticsにモデルを提供してみたいですか？素晴らしいことです！私たちは常にモデルのポートフォリオを拡大することに興味があります。 + +1. **リポジトリをフォークする**：[Ultralytics GitHubリポジトリ](https://github.com/ultralytics/ultralytics)をフォークして始めます。 + +2. **フォークをクローンする**：フォークをローカルマシンにクローンし、作業用の新しいブランチを作成します。 + +3. **モデルを実装する**：提供されているコーディング規格とガイドラインに従ってモデルを追加します。 + +4. **徹底的にテストする**：孤立してもパイプラインの一部としても、モデルを徹底的にテストしてください。 + +5. **プルリクエストを作成する**：モデルに満足したら、レビューのためにメインリポジトリへのプルリクエストを作成します。 + +6. **コードレビューとマージ**：レビュー後、モデルが私たちの基準を満たしている場合、メインリポジトリにマージされます。 + +詳細な手順については、[コントリビューティングガイド](../../help/contributing.md)を参照してください。 diff --git a/docs/ja/modes/benchmark.md b/docs/ja/modes/benchmark.md new file mode 100644 index 00000000..cf7d0407 --- /dev/null +++ b/docs/ja/modes/benchmark.md @@ -0,0 +1,94 @@ +--- +comments: true +description: YOLOv8を様々なエクスポート形式でスピードと精度をプロファイリングする方法を学び、mAP50-95、accuracy_top5のメトリクスなどの洞察を得る。 +keywords: Ultralytics, YOLOv8, ベンチマーク, スピードプロファイリング, 精度プロファイリング, mAP50-95, accuracy_top5, ONNX, OpenVINO, TensorRT, YOLOエクスポート形式 +--- + +# Ultralytics YOLO でのモデルベンチマーク + +Ultralytics YOLOエコシステムと統合 + +## はじめに + +モデルがトレーニングされ、検証された後、次の論理的なステップは、さまざまな現実世界のシナリオでのパフォーマンスを評価することです。Ultralytics YOLOv8 のベンチマークモードは、さまざまなエクスポート形式でモデルのスピードと精度を評価するための頑健なフレームワークを提供します。 + +## ベンチマークが重要な理由は？ + +- **情報に基づいた決定:** スピードと精度のトレードオフについての洞察を得る。 +- **リソース割り当て:** 異なるハードウェアで異なるエクスポート形式がどのように動作するかを理解する。 +- **最適化:** 特定のユースケースで最高のパフォーマンスを提供するエクスポート形式を学ぶ。 +- **コスト効率:** ベンチマーク結果に基づいてハードウェアリソースをより効率的に使用する。 + +### ベンチマークモードでの主要なメトリクス + +- **mAP50-95:** 物体検出、セグメンテーション、ポーズ推定に使用。 +- **accuracy_top5:** 画像分類に使用。 +- **推論時間:** 各画像に要する時間（ミリ秒）。 + +### サポートされるエクスポート形式 + +- **ONNX:** 最適なCPUパフォーマンスのために +- **TensorRT:** 最大限のGPU効率のために +- **OpenVINO:** Intelハードウェアの最適化のために +- **CoreML, TensorFlow SavedModel など:** 多様なデプロイメントニーズに。 + +!!! tip "ヒント" + + * CPUスピードアップのためにONNXまたはOpenVINOにエクスポートする。 + * GPUスピードアップのためにTensorRTにエクスポートする。 + +## 使用例 + +ONNX、TensorRTなど、すべてのサポートされるエクスポート形式でYOLOv8nベンチマークを実行します。完全なエクスポート引数のリストについては、以下のArgumentsセクションを参照してください。 + +!!! example "" + + === "Python" + + ```python + from ultralytics.utils.benchmarks import benchmark + + # GPUでベンチマーク + benchmark(model='yolov8n.pt', data='coco8.yaml', imgsz=640, half=False, device=0) + ``` + === "CLI" + + ```bash + yolo benchmark model=yolov8n.pt data='coco8.yaml' imgsz=640 half=False device=0 + ``` + +## 引数 + +`model`、`data`、`imgsz`、`half`、`device`、`verbose` などの引数は、特定のニーズに合わせてベンチマークを微調整し、さまざまなエクスポート形式のパフォーマンスを容易に比較するためにユーザーに柔軟性を提供します。 + +| キー | 値 | 説明 | +|-----------|---------|-----------------------------------------------------------| +| `model` | `None` | モデルファイルへのパス、例: yolov8n.pt, yolov8n.yaml | +| `data` | `None` | ベンチマークデータセットを参照するYAMLへのパス（`val`ラベルの下） | +| `imgsz` | `640` | 画像サイズをスカラーまたは(h, w)リストで、例: (640, 480) | +| `half` | `False` | FP16量子化 | +| `int8` | `False` | INT8量子化 | +| `device` | `None` | 実行デバイス、例: cuda device=0 または device=0,1,2,3 または device=cpu | +| `verbose` | `False` | エラー時に続行しない（bool）、またはval床しきい値（float） | + +## エクスポート形式 + +以下の可能なすべてのエクスポート形式で自動的にベンチマークを試みます。 + +| 形式 | `format` 引数 | モデル | メタデータ | 引数 | +|--------------------------------------------------------------------|---------------|---------------------------|-------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | ✅ | `imgsz`, `half` | + +[エクスポート](https://docs.ultralytics.com/modes/export/)ページでさらに詳しい`export`の詳細をご覧ください。 diff --git a/docs/ja/modes/export.md b/docs/ja/modes/export.md new file mode 100644 index 00000000..92b1cf7e --- /dev/null +++ b/docs/ja/modes/export.md @@ -0,0 +1,76 @@ +--- +comments: true +description: YOLOv8モデルをONNX, TensorRT, CoreMLなどの様々なフォーマットへエキスポートする手順についてのガイドです。今すぐ展開を探求してください！ +keywords: YOLO, YOLOv8, Ultralytics, モデルエキスポート, ONNX, TensorRT, CoreML, TensorFlow SavedModel, OpenVINO, PyTorch, モデルをエキスポート +--- + +# Ultralytics YOLO でのモデルエキスポート + +Ultralytics YOLO エコシステムと統合 + +## はじめに + +モデルのトレーニング終了後の最終目標は、実世界のアプリケーションに導入することです。Ultralytics YOLOv8のエキスポートモードは、トレーニング済みモデルを異なるフォーマットにエキスポートして、様々なプラットフォームやデバイスで展開可能にするための多様なオプションを提供します。この包括的なガイドは、モデルエキスポートのニュアンスをわかりやすく解説し、最大の互換性とパフォーマンスを達成する方法をご紹介します。 + +

+
+ +
+ 視聴: カスタムトレーニングしたUltralytics YOLOv8モデルをエキスポートして、ウェブカムでリアルタイム推論を実行する方法。 +

+ +## YOLOv8のエキスポートモードを選ぶ理由は？ + +- **汎用性:** ONNX, TensorRT, CoreMLなど複数のフォーマットへエキスポート。 +- **パフォーマンス:** TensorRTで最大5倍のGPU高速化、ONNXまたはOpenVINOで3倍のCPU高速化を実現。 +- **互換性:** 様々なハードウェアおよびソフトウェア環境でユニバーサルにモデルを展開。 +- **使いやすさ:** シンプルなCLIおよびPython APIで簡単かつ迅速なモデルエキスポート。 + +### エキスポートモードの主要機能 + +いくつかの注目すべき機能は以下の通りです: + +- **ワンクリックエキスポート:** 異なるフォーマットへのシンプルなコマンド。 +- **バッチエキスポート:** バッチ推論対応モデルをエキスポート。 +- **最適化推論:** より高速な推論のために最適化されたエキスポートモデル。 +- **チュートリアル動画:** スムーズなエキスポート体験のための詳細なガイドとチュートリアル。 + +!!! tip "ヒント" + + * ONNXまたはOpenVINOへのエキスポートで最大3倍のCPU速度アップ。 + * TensorRTへのエキスポートで最大5倍のGPU速度アップ。 + +## 使用例 + +YOLOv8nモデルをONNXやTensorRTなどの異なるフォーマットにエキスポートします。エキスポート引数のフルリストについては、以下のArgumentsセクションをご覧ください。 + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Load a model + model = YOLO('yolov8n.pt') # 公式モデルを読み込む + model = YOLO('path/to/best.pt') # カスタムトレーニングモデルを読み込む + + # モデルをエキスポート + model.export(format='onnx') + ``` + === "CLI" + + ```bash + yolo export model=yolov8n.pt format=onnx # 公式モデルをエキスポート + yolo export model=path/to/best.pt format=onnx # カスタムトレーニングモデルをエキスポート + ``` + +## 引数 + +YOLOモデルのエキスポート設定 + +[...content truncated for length...] diff --git a/docs/ja/modes/index.md b/docs/ja/modes/index.md new file mode 100644 index 00000000..484fa9cf --- /dev/null +++ b/docs/ja/modes/index.md @@ -0,0 +1,53 @@ +--- +comments: true +description: トレーニングからトラッキングまで、UltralyticsのYOLOv8を活用して最大限に活用します。検証、エクスポート、ベンチマーキングなど、各サポートモードの洞察と例を得る。 +keywords: Ultralytics, YOLOv8, 機械学習, オブジェクト検出, トレーニング, 検証, 予測, エクスポート, トラッキング, ベンチマーキング +--- + +# Ultralytics YOLOv8 モード + +Ultralytics YOLOエコシステムと統合 + +## はじめに + +Ultralytics YOLOv8は、単なるオブジェクト検出モデルではありません; これは、データ収集、モデルトレーニングから検証、デプロイメント、実際のトラッキングに至るまでの機械学習モデルのライフサイクル全体をカバーするように設計された多用途フレームワークです。各モードは特定の目的に役立ち、異なるタスクやユースケースに必要な柔軟性と効率を提供するように工夫されています。 + +

+
+ +
+ 視聴する: Ultralytics モードチュートリアル: トレーニ、検証、予測、エクスポート ＆ ベンチマーキング。 +

+ +### モードの概要 + +Ultralytics YOLOv8がサポートする異なる**モード**を理解することは、モデルから最大限に活用するためには欠かせません： + +- **トレーニング**モード：カスタムまたは事前読み込みされたデータセットでのモデルの微調整を行います。 +- **バリデーション**モード：トレーニング後のチェックポイントとして、モデルの性能を検証します。 +- **予測**モード：実世界のデータでモデルの予測能力を発揮します。 +- **エクスポート**モード：様々な形式でデプロイメント準備ができたモデルを作成します。 +- **トラッキング**モード：オブジェクト検出モデルをリアルタイム追跡アプリケーションに拡張します。 +- **ベンチマーキング**モード：様々なデプロイメント環境でモデルの速度と精度を分析します。 + +この包括的なガイドは、YOLOv8の全潜在能力を引き出すための概要と実践的な洞察を提供することを目指しています。 + +## [トレーニング](train.md) + +トレーニングモードは、カスタムデータセットでYOLOv8モデルのトレーニングを行うために使用されます。このモードでは、指定されたデータセットとハイパーパラメータを使用してモデルがトレーニングされます。トレーニングプロセスには、モデルのパラメータを最適化して、写真内のオブジェクトのクラスと位置を正確に予測できるようにする作業が含まれます。 + +[トレーニング例](train.md){ .md-button .md-button--primary} + +## [バリデーション](val.md) + +バリデーションモードは、トレーニングされたYOLOv8モデルを検証するために使用されます。このモードでは、モデルがバリデーションセットで評価され、その精度と一般化性能を測定します。このモードは、モデルのハイパーパラメータを調整し、そのパフォーマンスを向上させるために利用できます。 + +[バリデーション例](val.md){ .md-button .md-button--primary} + +## [予測](predict.md) + +予測モードは、新しい画像やビデオでトレーニングされたYOLOv8モデルを使用して予測を行うために使用されます。このモードでは、モデルがチェックポイントファイルから読み込まれ、ユーザーが推論を行うために画像やビデオを提供できます。モデルは、入力した画像やビデオ内のオブジェクトのクラスと位置を予測します。 diff --git a/docs/ja/modes/predict.md b/docs/ja/modes/predict.md new file mode 100644 index 00000000..cbf8bf06 --- /dev/null +++ b/docs/ja/modes/predict.md @@ -0,0 +1,211 @@ +--- +comments: true +description: YOLOv8予測モードの使用方法について学び、画像、動画、データフォーマットなどさまざまな推論ソースについて解説します。 +keywords: Ultralytics, YOLOv8, 予測モード, 推論ソース, 予測タスク, ストリーミングモード, 画像処理, 動画処理, 機械学習, AI +--- + +# Ultralytics YOLOによるモデル予測 + +Ultralytics YOLO ecosystem and integrations + +## イントロダクション + +機械学習やコンピュータビジョンの世界では、視覚データから意味を引き出すプロセスを「推論」または「予測」と呼ばれています。UltralyticsのYOLOv8は、幅広いデータソースに対して高性能でリアルタイムな推論を行うために特化した、「予測モード」と呼ばれる強力な機能を提供しています。 + +

+
+ +
+ 視聴: Ultralytics YOLOv8モデルの出力をカスタムプロジェクトに取り込む方法を学ぶ。 +

+ +## 実際の応用例 + +| 製造業 | スポーツ | 安全 | +|:-----------------------------------------------------------------------------------------------------------------------------------:|:-------------------------------------------------------------------------------------------------------------------------------:|:---------------------------------------------------------------------------------------------------------------------------:| +| ![Vehicle Spare Parts Detection](https://github.com/RizwanMunawar/ultralytics/assets/62513924/a0f802a8-0776-44cf-8f17-93974a4a28a1) | ![Football Player Detection](https://github.com/RizwanMunawar/ultralytics/assets/62513924/7d320e1f-fc57-4d7f-a691-78ee579c3442) | ![People Fall Detection](https://github.com/RizwanMunawar/ultralytics/assets/62513924/86437c4a-3227-4eee-90ef-9efb697bdb43) | +| 車両のスペアパーツ検出 | フットボール選手検出 | 人の転倒検出 | + +## 予測にUltralytics YOLOを使う理由 + +様々な推論ニーズにYOLOv8の予測モードを検討すべき理由です： + +- **柔軟性:** 画像、動画、さらにはライブストリームにおいて推論を行う能力があります。 +- **パフォーマンス:** 正確さを犠牲にすることなく、リアルタイムで高速な処理が行えるように設計されています。 +- **使いやすさ:** 迅速な展開とテストのための直感的なPythonおよびCLIインターフェース。 +- **高いカスタマイズ性:** 特定の要件に応じてモデルの推論動作を調整するためのさまざまな設定とパラメーター。 + +### 予測モードの主な特徴 + +YOLOv8の予測モードは、頑健で多様性があり、次の特徴を備えています： + +- **複数のデータソースとの互換性:** データが個々の画像、画像の集合、動画ファイル、またはリアルタイムの動画ストリームのいずれの形式であっても、予測モードが対応しています。 +- **ストリーミングモード:** `Results`オブジェクトのメモリ効率の良いジェネレータを生成するためにストリーミング機能を使用します。`stream=True`を予測器の呼び出しメソッドに設定することにより有効になります。 +- **バッチ処理:** 単一のバッチで複数の画像や動画フレームを処理する能力は、さらに推論時間を短縮します。 +- **統合が容易:** 柔軟なAPIのおかげで、既存のデータパイプラインや他のソフトウェアコンポーネントに簡単に統合できます。 + +UltralyticsのYOLOモデルは、`stream=True`が推論中にモデルに渡されると、Pythonの`Results`オブジェクトのリストまたは`Results`オブジェクトのメモリ効率の良いPythonジェネレータのいずれかを返します： + +!!! 例 "予測" + + === "`stream=False`でリストを返す" + ```python + from ultralytics import YOLO + + # モデルをロード + model = YOLO('yolov8n.pt') # 事前にトレーニングされたYOLOv8nモデル + + # 画像のリストに対してバッチ推論を実行 + results = model(['im1.jpg', 'im2.jpg']) # Resultsオブジェクトのリストを返す + + # 結果リストを処理 + for result in results: + boxes = result.boxes # バウンディングボックス出力用のBoxesオブジェクト + masks = result.masks # セグメンテーションマスク出力用のMasksオブジェクト + keypoints = result.keypoints # 姿勢出力用のKeypointsオブジェクト + probs = result.probs # 分類出力用のProbsオブジェクト + ``` + + === "`stream=True`でジェネレータを返す" + ```python + from ultralytics import YOLO + + # モデルをロード + model = YOLO('yolov8n.pt') # 事前にトレーニングされたYOLOv8nモデル + + # 画像のリストに対してバッチ推論を実行 + results = model(['im1.jpg', 'im2.jpg'], stream=True) # Resultsオブジェクトのジェネレータを返す + + # 結果ジェネレータを処理 + for result in results: + boxes = result.boxes # バウンディングボックス出力用のBoxesオブジェクト + masks = result.masks # セグメンテーションマスク出力用のMasksオブジェクト + keypoints = result.keypoints # 姿勢出力用のKeypointsオブジェクト + probs = result.probs # 分類出力用のProbsオブジェクト + ``` + +## 推論ソース + +YOLOv8は、以下の表に示されるように、異なるタイプの入力ソースを推論に処理できます。ソースには静止画像、動画ストリーム、およびさまざまなデータフォーマットが含まれます。表には、各ソースがストリーミングモードで使用できるかどうかも示されており、引数`stream=True`で✅が表示されています。ストリーミングモードは、動画やライブストリームを処理する場合に有利であり、すべてのフレームをメモリにロードする代わりに結果のジェネレータを作成します。 + +!!! ヒント "ヒント" + + 長い動画や大きなデータセットを効率的にメモリ管理するために`stream=True`を使用します。`stream=False`では、すべてのフレームまたはデータポイントの結果がメモリに格納されますが、大きな入力で迅速にメモリが積み上がり、メモリ不足のエラーを引き起こす可能性があります。対照的に、`stream=True`はジェネレータを利用し、現在のフレームまたはデータポイントの結果のみをメモリに保持し、メモリ消費を大幅に削減し、メモリ不足の問題を防ぎます。 + +| ソース | 引数 | タイプ | 備考 | +|------------|--------------------------------------------|------------------|------------------------------------------------------------------| +| 画像 | `'image.jpg'` | `str` または `Path` | 単一の画像ファイル。 | +| URL | `'https://ultralytics.com/images/bus.jpg'` | `str` | 画像へのURL。 | +| スクリーンショット | `'screen'` | `str` | スクリーンショットをキャプチャ。 | +| PIL | `Image.open('im.jpg')` | `PIL.Image` | HWCフォーマットでRGBチャンネル。 | +| OpenCV | `cv2.imread('im.jpg')` | `np.ndarray` | HWCフォーマットでBGRチャンネル `uint8 (0-255)`。 | +| numpy | `np.zeros((640,1280,3))` | `np.ndarray` | HWCフォーマットでBGRチャンネル `uint8 (0-255)`。 | +| torch | `torch.zeros(16,3,320,640)` | `torch.Tensor` | BCHWフォーマットでRGBチャンネル `float32 (0.0-1.0)`。 | +| CSV | `'sources.csv'` | `str` または `Path` | 画像、動画、ディレクトリへのパスを含むCSVファイル。 | +| 動画 ✅ | `'video.mp4'` | `str` または `Path` | MP4、AVIなどの形式の動画ファイル。 | +| ディレクトリ ✅ | `'path/'` | `str` または `Path` | 画像または動画を含むディレクトリへのパス。 | +| グロブ ✅ | `'path/*.jpg'` | `str` | 複数のファイルに一致するグロブパターン。ワイルドカードとして`*`文字を使用します。 | +| YouTube ✅ | `'https://youtu.be/LNwODJXcvt4'` | `str` | YouTube動画のURL。 | +| ストリーム ✅ | `'rtsp://example.com/media.mp4'` | `str` | RTSP、RTMP、TCP、IPアドレスなどのストリーミングプロトコルのためのURL。 | +| マルチストリーム ✅ | `'list.streams'` | `str` または `Path` | ストリームURLを行ごとに1つ含む`*.streams`テキストファイル。つまり、8つのストリームをバッチサイズ8で実行します。 | + +以下は、それぞれのソースタイプを使用するためのコード例です： + +!!! 例 "予測ソース" + + === "画像" + 画像ファイルに推論を実行します。 + ```python + from ultralytics import YOLO + + # 事前にトレーニングされたYOLOv8nモデルをロード + model = YOLO('yolov8n.pt') + + # 画像ファイルへのパスを定義 + source = 'path/to/image.jpg' + + # ソースに推論を実行 + results = model(source) # Resultsオブジェクトのリスト + ``` + + === "スクリーンショット" + 現在の画面内容のスクリーンショットに推論を実行します。 + ```python + from ultralytics import YOLO + + # 事前にトレーニングされたYOLOv8nモデルをロード + model = YOLO('yolov8n.pt') + + # 現在のスクリーンショットをソースとして定義 + source = 'screen' + + # ソースに推論を実行 + results = model(source) # Resultsオブジェクトのリスト + ``` + + === "URL" + リモートのURL経由でホストされている画像や動画に推論を実行します。 + ```python + from ultralytics import YOLO + + # 事前にトレーニングされたYOLOv8nモデルをロード + model = YOLO('yolov8n.pt') + + # リモート画像や動画のURLを定義 + source = 'https://ultralytics.com/images/bus.jpg' + + # ソースに推論を実行 + results = model(source) # Resultsオブジェクトのリスト + ``` + + === "PIL" + Python Imaging Library (PIL)を使用して開いた画像に推論を実行します。 + ```python + from PIL import Image + from ultralytics import YOLO + + # 事前にトレーニングされたYOLOv8nモデルをロード + model = YOLO('yolov8n.pt') + + # PILを使用して画像を開く + source = Image.open('path/to/image.jpg') + + # ソースに推論を実行 + results = model(source) # Resultsオブジェクトのリスト + ``` + + === "OpenCV" + OpenCVを使用して読み込んだ画像に推論を実行します。 + ```python + import cv2 + from ultralytics import YOLO + + # 事前にトレーニングされたYOLOv8nモデルをロード + model = YOLO('yolov8n.pt') + + # OpenCVを使用して画像を読み込む + source = cv2.imread('path/to/image.jpg') + + # ソースに推論を実行 + results = model(source) # Resultsオブジェクトのリスト + ``` + + === "numpy" + numpy配列として表される画像に推論を実行します。 + ```python + import numpy as np + from ultralytics import YOLO + + # 事前にトレーニングされたYOLOv8nモデルをロード + model = YOLO('yolov8n.pt') + + # HWC形状（640, 640, 3）、範囲[0, 255]、型`uint8`のランダムなnumpy配列を作成 + source = np.random.randint(low=0, high=255, size=(640,640,3), dtype='uint8') + + # ソースに推論を実行 + results = model(source) # Resultsオブジェクトのリスト + ``` diff --git a/docs/ja/modes/track.md b/docs/ja/modes/track.md new file mode 100644 index 00000000..a3dd779e --- /dev/null +++ b/docs/ja/modes/track.md @@ -0,0 +1,200 @@ +--- +comments: true +description: Ultralytics YOLOを使用したビデオストリームでのオブジェクトトラッキングの使用方法を学びます。異なるトラッカーの使用ガイドとトラッカー構成のカスタマイズについて。 +keywords: Ultralytics, YOLO, オブジェクトトラッキング, ビデオストリーム, BoT-SORT, ByteTrack, Pythonガイド, CLIガイド +--- + +# Ultralytics YOLOによる複数オブジェクトのトラッキング + +複数オブジェクトのトラッキング例 + +ビデオ分析の領域でのオブジェクトトラッキングは、フレーム内のオブジェクトの位置とクラスを特定するだけでなく、ビデオが進行するにつれてそれぞれの検出されたオブジェクトにユニークなIDを維持する重要なタスクです。その応用範囲は無限で、監視やセキュリティからリアルタイムスポーツ分析まで及びます。 + +## オブジェクトトラッキングにUltralytics YOLOを選ぶ理由は？ + +Ultralyticsのトラッカーからの出力は標準のオブジェクト検出と一致しており、さらにオブジェクトIDの付加価値があります。これにより、ビデオストリーム内のオブジェクトを追跡し、後続の分析を行うことが容易になります。Ultralytics YOLOをオブジェクトトラッキングのニーズに利用を検討する理由は以下の通りです： + +- **効率性:** 精度を損なうことなくリアルタイムでビデオストリームを処理します。 +- **柔軟性:** 複数のトラッキングアルゴリズムと構成をサポートしています。 +- **使いやすさ:** 簡単なPython APIとCLIオプションで迅速な統合と展開が可能です。 +- **カスタマイズ性:** カスタムトレーニング済みのYOLOモデルとの容易な使用により、ドメイン特有のアプリケーションへの統合が可能です。 + +

+
+ +
+ 視聴： Ultralytics YOLOv8によるオブジェクト検出とトラッキング。 +

+ +## 実世界での応用例 + +| 交通 | 小売 | 水産業 | +|:---------------------------------------------------------------------------------------------------------------:|:---------------------------------------------------------------------------------------------------------------:|:--------------------------------------------------------------------------------------------------------------:| +| ![車両のトラッキング](https://github.com/RizwanMunawar/ultralytics/assets/62513924/ee6e6038-383b-4f21-ac29-b2a1c7d386ab) | ![人々のトラッキング](https://github.com/RizwanMunawar/ultralytics/assets/62513924/93bb4ee2-77a0-4e4e-8eb6-eb8f527f0527) | ![魚のトラッキング](https://github.com/RizwanMunawar/ultralytics/assets/62513924/a5146d0f-bfa8-4e0a-b7df-3c1446cd8142) | +| 車両トラッキング | 人々のトラッキング | 魚のトラッキング | + +## 一目でわかる機能 + +Ultralytics YOLOは、オブジェクト検出機能を拡張して、堅牢で多機能なオブジェクトトラッキングを提供します： + +- **リアルタイムトラッキング：** 高フレームレートのビデオでオブジェクトをシームレスに追跡します。 +- **複数トラッカーサポート：** 確立されたトラッキングアルゴリズムから選択できます。 +- **カスタマイズ可能なトラッカー構成：** 様々なパラメーターを調整することで特定の要件に合わせてトラッキングアルゴリズムを調整します。 + +## 利用可能なトラッカー + +Ultralytics YOLOは、次のトラッキングアルゴリズムをサポートしています。それらは、関連するYAML構成ファイル（たとえば`tracker=tracker_type.yaml`）を渡すことで有効にすることができます： + +* [BoT-SORT](https://github.com/NirAharon/BoT-SORT) - このトラッカーを有効にするには`botsort.yaml`を使用します。 +* [ByteTrack](https://github.com/ifzhang/ByteTrack) - このトラッカーを有効にするには`bytetrack.yaml`を使用します。 + +デフォルトのトラッカーはBoT-SORTです。 + +## トラッキング + +ビデオストリームでトラッカーを実行するには、YOLOv8n、YOLOv8n-seg、YOLOv8n-poseなどのトレーニング済みのDetect、Segment、またはPoseモデルを使用します。 + +!!! 例 "" + + === "Python" + + ```python + from ultralytics import YOLO + + # 公式またはカスタムモデルをロード + model = YOLO('yolov8n.pt') # 公式のDetectモデルをロード + model = YOLO('yolov8n-seg.pt') # 公式のSegmentモデルをロード + model = YOLO('yolov8n-pose.pt') # 公式のPoseモデルをロード + model = YOLO('path/to/best.pt') # カスタムトレーニング済みモデルをロード + + # モデルでトラッキングを実行 + results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True) # デフォルトトラッカーでトラッキング + results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml") # ByteTrackトラッカーでトラッキング + ``` + + === "CLI" + + ```bash + # コマンドラインインターフェースを使用して、様々なモデルでトラッキングを実行 + yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" # 公式のDetectモデル + yolo track model=yolov8n-seg.pt source="https://youtu.be/LNwODJXcvt4" # 公式のSegmentモデル + yolo track model=yolov8n-pose.pt source="https://youtu.be/LNwODJXcvt4" # 公式のPoseモデル + yolo track model=path/to/best.pt source="https://youtu.be/LNwODJXcvt4" # カスタムトレーニング済みモデル + + # ByteTrackトラッカーを使用してトラッキング + yolo track model=path/to/best.pt tracker="bytetrack.yaml" + ``` + +上記の使用法に示されているように、トラッキングはビデオやストリーミングソースで実行されるすべてのDetect、Segment、およびPoseモデルで利用可能です。 + +## 構成 + +### トラッキング引数 + +トラッキング構成は、`conf`、`iou`、および`show`などのPredictモードと同じプロパティを共有します。さらなる構成については、[Predict](https://docs.ultralytics.com/modes/predict/)モデルページを参照してください。 + +!!! 例 "" + + === "Python" + + ```python + from ultralytics import YOLO + + # トラッキングパラメーターを構成し、トラッカーを実行 + model = YOLO('yolov8n.pt') + results = model.track(source="https://youtu.be/LNwODJXcvt4", conf=0.3, iou=0.5, show=True) + ``` + + === "CLI" + + ```bash + # コマンドラインインターフェースを使用してトラッキングパラメータを構成し、トラッカーを実行 + yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" conf=0.3, iou=0.5 show + ``` + +### トラッカーの選択 + +Ultralyticsは、変更されたトラッカー構成ファイルの使用も可能にします。これを行うには、[ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers)からトラッカー構成ファイル（たとえば`custom_tracker.yaml`）のコピーを作成し、必要に応じて任意の構成（`tracker_type`を除く）を変更します。 + +!!! 例 "" + + === "Python" + + ```python + from ultralytics import YOLO + + # モデルをロードし、カスタム構成ファイルでトラッカーを実行 + model = YOLO('yolov8n.pt') + results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker='custom_tracker.yaml') + ``` + + === "CLI" + + ```bash + # コマンドラインインターフェースを使用して、カスタム構成ファイルでモデルをロードし、トラッカーを実行 + yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" tracker='custom_tracker.yaml' + ``` + +トラッキング引数の包括的なリストについては、[ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers)ページを参照してください。 + +## Pythonの例 + +### トラックループの永続化 + +次は、OpenCV (`cv2`)とYOLOv8を使用してビデオフレームでオブジェクトトラッキングを実行するPythonスクリプトです。このスクリプトでは、必要なパッケージ（`opencv-python`および`ultralytics`）が既にインストールされていることが前提です。`persist=True`引数は、トラッカーに現在の画像またはフレームがシーケンスの次のものであり、現在の画像に前の画像からのトラックを期待することを伝えます。 + +!!! 例 "トラッキングを伴うストリーミングforループ" + + ```python + import cv2 + from ultralytics import YOLO + + # YOLOv8モデルをロード + model = YOLO('yolov8n.pt') + + # ビデオファイルを開く + video_path = "path/to/video.mp4" + cap = cv2.VideoCapture(video_path) + + # ビデオフレームをループする + while cap.isOpened(): + # ビデオからフレームを読み込む + success, frame = cap.read() + + if success: + # フレームでYOLOv8トラッキングを実行し、フレーム間でトラックを永続化 + results = model.track(frame, persist=True) + + # フレームに結果を可視化 + annotated_frame = results[0].plot() + + # 注釈付きのフレームを表示 + cv2.imshow("YOLOv8トラッキング", annotated_frame) + + # 'q'が押されたらループから抜ける + if cv2.waitKey(1) & 0xFF == ord("q"): + break + else: + # ビデオの終わりに到達したらループから抜ける + break + + # ビデオキャプチャオブジェクトを解放し、表示ウィンドウを閉じる + cap.release() + cv2.destroyAllWindows() + ``` + +ここでの変更は、単純な検出ではなくオブジェクトトラッキングを有効にする`model(frame)`から`model.track(frame)`への変更です。この変更されたスクリプトは、ビデオの各フレームでトラッカーを実行し、結果を視覚化し、ウィンドウに表示します。ループは'q'を押すことで終了できます。 + +## 新しいトラッカーの貢献 + +あなたはマルチオブジェクトトラッキングに精通しており、Ultralytics YOLOでトラッキングアルゴリズムをうまく実装または適応させたことがありますか？[ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers)セクションへの貢献を私たちは歓迎します！あなたの実世界での応用例とソリューションは、トラッキングタスクに取り組むユーザーにとって非常に有益かもしれません。 + +このセクションへの貢献により、Ultralytics YOLOフレームワーク内で利用可能なトラッキングソリューションの範囲が広がり、コミュニティにとっての機能性とユーティリティーに新たな層が加わります。 + +ご自身の貢献を開始するには、プルリクエスト（PR）の送信に関する総合的な指示について我々の[貢献ガイド](https://docs.ultralytics.com/help/contributing)をご参照ください 🛠️。あなたが何をもたらすか私たちは期待しています！ + +一緒に、Ultralytics YOLOエコシステムのトラッキング機能を高めましょう 🙏！ diff --git a/docs/ja/modes/train.md b/docs/ja/modes/train.md new file mode 100644 index 00000000..cc22b856 --- /dev/null +++ b/docs/ja/modes/train.md @@ -0,0 +1,206 @@ +--- +comments: true +description: YOLOv8モデルをUltralytics YOLOを使用してトレーニングする手順についてのガイドで、シングルGPUとマルチGPUトレーニングの例を含む +keywords: Ultralytics, YOLOv8, YOLO, 物体検出, トレーニングモード, カスタムデータセット, GPUトレーニング, マルチGPU, ハイパーパラメータ, CLI例, Python例 +--- + +# Ultralytics YOLOを使ったモデルトレーニング + +Ultralytics YOLOエコシステムと統合 + +## はじめに + +ディープラーニングモデルのトレーニングは、データを与えてパラメーターを調整し、正確な予測を行えるようにするプロセスを含みます。UltralyticsのYOLOv8のトレーニングモードは、現代のハードウェアの能力をフルに活用して物体検出モデルを効果的かつ効率的にトレーニングするために設計されています。このガイドは、YOLOv8 の豊富な機能セットを使用して自身のモデルをトレーニングするために必要なすべての詳細をカバーすることを目的としています。 + +

+
+ +
+ 視聴: Google Colab でカスタムデータセットにYOLOv8モデルをトレーニングする方法。 +

+ +## トレーニングにUltralyticsのYOLOを選ぶ理由 + +YOLOv8のトレーニングモードを選択するいくつかの魅力的な理由を以下に示します： + +- **効率性：** シングルGPUセットアップであろうと複数のGPUにスケールする場合であろうと、あなたのハードウェアを最大限に活用します。 +- **汎用性：** COCO、VOC、ImageNetのような既存のデータセットに加え、カスタムデータセットでのトレーニングが可能です。 +- **ユーザーフレンドリー：** 直感的でありながら強力なCLIとPythonインターフェースを備え、簡単なトレーニング体験を提供します。 +- **ハイパーパラメータの柔軟性：** モデルのパフォーマンスを微調整するための幅広いカスタマイズ可能なハイパーパラメータ。 + +### トレーニングモードの主な特徴 + +以下に、YOLOv8のトレーニングモードのいくつかの注目すべき特徴を挙げます： + +- **自動データセットダウンロード：** COCO、VOC、ImageNetのような標準データセットは最初の使用時に自動的にダウンロードされます。 +- **マルチGPUサポート：** 複数のGPUにわたってトレーニングをスケールし、プロセスを迅速に行います。 +- **ハイパーパラメータの設定：** YAML設定ファイルやCLI引数を通じてハイパーパラメータを変更するオプション。 +- **可視化とモニタリング：** トレーニング指標のリアルタイム追跡と学習プロセスの可視化により、より良い洞察を得ます。 + +!!! tip "ヒント" + + * YOLOv8のデータセット、例えばCOCO、VOC、ImageNetなどは、最初の使用時に自動的にダウンロードされます。例：`yolo train data=coco.yaml` + +## 使用例 + +COCO128データセットでYOLOv8nを100エポック、画像サイズ640でトレーニングする。トレーニングデバイスは、`device`引数を使って指定できます。引数が渡されない場合、利用可能であればGPU `device=0`が、そうでなければ`device=cpu`が利用されます。全てのトレーニング引数のリストは以下の引数セクションを参照してください。 + +!!! example "シングルGPUとCPUトレーニング例" + + デバイスは自動的に決定されます。GPUが利用可能であればそれが使用され、そうでなければCPUでトレーニングが開始されます。 + + === "Python" + + ```python + from ultralytics import YOLO + + # モデルをロード + model = YOLO('yolov8n.yaml') # YAMLから新しいモデルを作成 + model = YOLO('yolov8n.pt') # トレーニングにはおすすめの事前学習済みモデルをロード + model = YOLO('yolov8n.yaml').load('yolov8n.pt') # YAMLからモデルを作成し、重みを転送 + + # モデルをトレーニング + results = model.train(data='coco128.yaml', epochs=100, imgsz=640) + ``` + + === "CLI" + + ```bash + # YAMLから新しいモデルを作成し、最初からトレーニングを開始 + yolo detect train data=coco128.yaml model=yolov8n.yaml epochs=100 imgsz=640 + + # 事前学習済み*.ptモデルからトレーニングを開始 + yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 + + # YAMLから新しいモデルを作成し、事前学習済みの重みを転送してトレーニングを開始 + yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640 + ``` + +### マルチGPUトレーニング + +マルチGPUトレーニングは、利用可能なハードウェアリソースをより効率的に活用するために、トレーニングの負荷を複数のGPUに分散させることを可能にします。この機能はPython APIとコマンドラインインターフェィスの両方を通じて利用できます。マルチGPUトレーニングを有効にするには、使用したいGPUデバイスIDを指定します。 + +!!! example "マルチGPUトレーニング例" + + 2つのGPUを使ってトレーニングするには、CUDAデバイス0と1を使い以下のコマンドを使用します。必要に応じて追加のGPUに拡張します。 + + === "Python" + + ```python + from ultralytics import YOLO + + # モデルをロード + model = YOLO('yolov8n.pt') # トレーニングにはおすすめの事前学習済みモデルをロード + + # 2つのGPUでモデルをトレーニング + results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device=[0, 1]) + ``` + + === "CLI" + + ```bash + # 事前学習済み*.ptモデルからGPU 0と1を使ってトレーニングを開始 + yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=0,1 + ``` + +### Apple M1 および M2 MPSトレーニング + +AppleのM1およびM2チップに対するサポートがUltralyticsのYOLOモデルに統合されたことで、Appleの強力なMetal Performance Shaders（MPS）フレームワークを使用してデバイスでモデルをトレーニングすることが可能になりました。 MPSは、Appleのカスタムシリコン上での計算や画像処理タスクの高性能な実行方法を提供します。 + +AppleのM1およびM2チップでのトレーニングを有効にするには、トレーニングプロセスを開始する際に`mps`をデバイスとして指定する必要があります。以下はPythonおよびコマンドラインでこれを行う例です： + +!!! example "MPSトレーニング例" + + === "Python" + + ```python + from ultralytics import YOLO + + # モデルをロード + model = YOLO('yolov8n.pt') # トレーニングにはおすすめの事前学習済みモデルをロード + + # MPSを使ってモデルをトレーニング + results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device='mps') + ``` + + === "CLI" + + ```bash + # MPSを使って、事前学習済み*.ptモデルからトレーニングを開始 + yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=mps + ``` + +M1/M2チップの計算能力を利用しながら、これによりトレーニングタスクのより効率的な処理が可能になります。より詳細なガイダンスや高度な設定オプションについては、[PyTorch MPSのドキュメント](https://pytorch.org/docs/stable/notes/mps.html)を参照してください。 + +## ロギング + +YOLOv8モデルをトレーニングする際、モデルのパフォーマンスを時間とともに追跡することが価値あることであると考えられます。これがロギングの役割になります。UltralyticsのYOLOは、Comet、ClearML、TensorBoardの3種類のロガーをサポートしています。 + +ロガーを使用するには、上記のコードスニペットからドロップダウンメニューを選択し、実行します。選択したロガーがインストールされ、初期化されます。 + +### Comet + +[Comet](https://www.comet.ml/site/)は、データサイエンティストや開発者が実験やモデルを追跡、比較、説明、最適化するためのプラットフォームです。リアルタイムメトリクスやコード差分、ハイパーパラメータの追跡などの機能を提供しています。 + +Cometを使用するには： + +!!! example "" + + === "Python" + ```python + # pip install comet_ml + import comet_ml + + comet_ml.init() + ``` + +Cometアカウントにサインインし、APIキーを取得してください。このキーを環境変数またはスクリプトに追加して、実験をログに記録する必要があります。 + +### ClearML + +[ClearML](https://www.clear.ml/)は、実験の追跡を自動化し、資源の効率的な共有を支援するオープンソースプラットフォームです。チームがML作業をより効率的に管理、実行、再現するのに役立ちます。 + +ClearMLを使用するには： + +!!! example "" + + === "Python" + ```python + # pip install clearml + import clearml + + clearml.browser_login() + ``` + +このスクリプトを実行した後、ブラウザでClearMLアカウントにサインインし、セッションを認証する必要があります。 + +### TensorBoard + +[TensorBoard](https://www.tensorflow.org/tensorboard)は、TensorFlowの視覚化ツールキットです。TensorFlowグラフを可視化し、グラフの実行に関する定量的メトリックをプロットし、それを通過する画像などの追加データを表示することができます。 + +[Google Colab](https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb)でTensorBoardを使用するには： + +!!! example "" + + === "CLI" + ```bash + load_ext tensorboard + tensorboard --logdir ultralytics/runs # 'runs'ディレクトリと置き換えてください + ``` + +TensorBoardをローカルで使用する場合は、http://localhost:6006/ で結果を確認できます。 + +!!! example "" + + === "CLI" + ```bash + tensorboard --logdir ultralytics/runs # 'runs'ディレクトリと置き換えてください + ``` + +これでTensorBoardがロードされ、トレーニングログが保存されているディレクトリを指定します。 + +ログを設定した後、モデルのトレーニングを進めてください。すべてのトレーニングメトリクスが選択したプラットフォームに自動的に記録され、これらのログをアクセスして、時間とともにモデルのパフォーマンスを監視したり、さまざまなモデルを比較したり、改善の余地を特定したりすることができます。 diff --git a/docs/ja/modes/val.md b/docs/ja/modes/val.md new file mode 100644 index 00000000..f0acf3c0 --- /dev/null +++ b/docs/ja/modes/val.md @@ -0,0 +1,86 @@ +--- +comments: true +description: YOLOv8モデルのバリデーションガイド。バリデーション設定とメトリクスを使用してYOLOモデルのパフォーマンスを評価する方法をPythonとCLIの例で学びましょう。 +keywords: Ultralytics, YOLO ドキュメント, YOLOv8, バリデーション, モデル評価, ハイパーパラメータ, 正確性, メトリクス, Python, CLI +--- + +# Ultralytics YOLOによるモデルバリデーション + +Ultralytics YOLOのエコシステムと統合機能 + +## はじめに + +バリデーションは、訓練されたモデルの品質を評価するために機械学習パイプラインで重要なステップです。Ultralytics YOLOv8のValモードは、モデルのパフォーマンスを評価するための堅牢なツールとメトリクスを提供します。このガイドは、Valモードを効果的に使用して、モデルが正確で信頼できることを確認するための完全なリソースとなっています。 + +## Ultralytics YOLOでバリデーションを行う利点 + +YOLOv8のValモードを使用することの利点は以下の通りです： + +- **Precision（精度）：** mAP50、mAP75、mAP50-95といった正確なメトリクスを取得し、モデルを総合的に評価します。 +- **Convenience（便利さ）：** 訓練設定を記憶する組み込みの機能を利用して、バリデーションプロセスを簡素化します。 +- **Flexibility（柔軟性）：** 同じデータセットや異なるデータセット、画像サイズでモデルをバリデーションできます。 +- **Hyperparameter Tuning（ハイパーパラメータチューニング）：** バリデーションメトリクスを利用してモデルのパフォーマンスを向上させるためのチューニングを行います。 + +### Valモードの主要機能 + +YOLOv8のValモードにより提供される注目すべき機能は以下の通りです： + +- **Automated Settings（自動設定）：** 訓練時の設定をモデルが記憶しているため、バリデーションが直感的に行えます。 +- **Multi-Metric Support（複数メトリックのサポート）：** 精度メトリックの範囲に基づいてモデルを評価します。 +- **CLI and Python API：** バリデーションにコマンドラインインターフェイスもしくはPython APIのどちらかを選択できます。 +- **Data Compatibility（データ互換性）：** 訓練段階で使われたデータセットはもちろん、カスタムデータセットともシームレスに動作します。 + +!!! tip "Tip" + + * YOLOv8モデルは訓練設定を自動的に記憶しているので、`yolo val model=yolov8n.pt`や`model('yolov8n.pt').val()`だけで、元のデータセットと同じ画像サイズで簡単にバリデーション可能です。 + +## 使用例 + +COCO128データセット上で訓練済みのYOLOv8nモデルの精度を検証します。`model`はその訓練時の`data`及び引数をモデル属性として保持しているため、引数を渡す必要はありません。全てのエクスポート引数のリストについては、以下のArgumentsセクションをご覧ください。 + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # モデルをロードする + model = YOLO('yolov8n.pt') # 公式モデルをロード + model = YOLO('path/to/best.pt') # カスタムモデルをロード + + # モデルをバリデーションする + metrics = model.val() # 引数は必要なし、データセットと設定は記憶持ち + metrics.box.map # map50-95 + metrics.box.map50 # map50 + metrics.box.map75 # map75 + metrics.box.maps # 各カテゴリのmap50-95が含まれたリスト + ``` + === "CLI" + + ```bash + yolo detect val model=yolov8n.pt # 公式モデルをバリデーション + yolo detect val model=path/to/best.pt # カスタムモデルをバリデーション + ``` + +## 引数 + +YOLOモデルに対するバリデーション設定は、バリデーションデータセット上でのモデルのパフォーマンスを評価するために使用されるさまざまなハイパーパラメータと設定を指します。これらの設定は、モデルのパフォーマンス、スピード、そして精度に影響を与える可能性があります。一般的なYOLOのバリデーション設定には、バッチサイズや訓練中のバリデーション頻度、モデルのパフォーマンスを評価するために使用されるメトリックが含まれます。バリデーションプロセスに影響を与えるかもしれない他の要素には、バリデーションデータセットのサイズと構成、およびモデルが使用されている具体的なタスクなどがあります。モデルがバリデーションデータセット上でうまく動作していることを確認し、過学習を検出して防ぐために、これらの設定を慎重にチューニングして実験することが重要です。 + +| キー | 値 | 説明 | +|---------------|---------|--------------------------------------------------| +| `data` | `None` | データファイルへのパス、例: coco128.yaml | +| `imgsz` | `640` | 入力画像のサイズを整数で | +| `batch` | `16` | バッチごとの画像数（AutoBatchの場合は-1） | +| `save_json` | `False` | JSONファイルに結果を保存 | +| `save_hybrid` | `False` | ハイブリッドバージョンのラベルを保存（ラベル＋追加の予測） | +| `conf` | `0.001` | 検出のためのオブジェクト信頼度閾値 | +| `iou` | `0.6` | NMS用の交差オーバーユニオン（IoU）閾値 | +| `max_det` | `300` | 画像あたりの最大検出数 | +| `half` | `True` | 半精度（FP16）を使用する | +| `device` | `None` | 実行デバイス、例: cuda device=0/1/2/3やdevice=cpu | +| `dnn` | `False` | ONNX推論用のOpenCV DNNを使用 | +| `plots` | `False` | 訓練中にプロットを表示 | +| `rect` | `False` | 各バッチが最小限のパディングで整理された矩形バリデーション | +| `split` | `val` | バリデーションに使用するデータセットのスプリット、例: 'val'、'test'、'train' | +| | | | diff --git a/docs/ja/quickstart.md b/docs/ja/quickstart.md new file mode 100644 index 00000000..e39f1fe1 --- /dev/null +++ b/docs/ja/quickstart.md @@ -0,0 +1,187 @@ +--- +comments: true +description: Ultralyticsのpip、conda、git、Dockerを使用した様々なインストール方法を探索し、コマンドラインインターフェースまたはPythonプロジェクト内でのUltralyticsの使用方法を学びます。 +keywords: Ultralyticsインストール, pipインストールUltralytics, DockerインストールUltralytics, Ultralyticsコマンドラインインターフェース, Ultralytics Pythonインターフェース +--- + +## Ultralyticsのインストール + +Ultralyticsはpip、conda、Dockerを含むさまざまなインストール方法を提供しています。最新の安定版リリースである`ultralytics` pipパッケージを通じてYOLOv8をインストールするか、最新バージョンを取得するために[Ultralytics GitHubリポジトリ](https://github.com/ultralytics/ultralytics)をクローンします。Dockerは、ローカルインストールを回避し、孤立したコンテナ内でパッケージを実行するために使用できます。 + +!!! example "インストール" + + === "Pipでのインストール（推奨）" + pipを使用して`ultralytics`パッケージをインストールするか、`pip install -U ultralytics`を実行して既存のインストールをアップデートします。`ultralytics`パッケージの詳細については、Python Package Index（PyPI）を参照してください: [https://pypi.org/project/ultralytics/](https://pypi.org/project/ultralytics/)。 + + [![PyPI version](https://badge.fury.io/py/ultralytics.svg)](https://badge.fury.io/py/ultralytics) [![Downloads](https://static.pepy.tech/badge/ultralytics)](https://pepy.tech/project/ultralytics) + + ```bash + # PyPIからultralyticsパッケージをインストール + pip install ultralytics + ``` + + GitHubの[リポジトリ](https://github.com/ultralytics/ultralytics)から直接`ultralytics`パッケージをインストールすることもできます。これは、最新の開発版が必要な場合に便利かもしれません。システムにGitコマンドラインツールがインストールされている必要があります。`@main`コマンドは`main`ブランチをインストールし、別のブランチ、例えば`@my-branch`に変更したり、`main`ブランチにデフォルトするために完全に削除することができます。 + + ```bash + # GitHubからultralyticsパッケージをインストール + pip install git+https://github.com/ultralytics/ultralytics.git@main + ``` + + + === "Condaでのインストール" + Condaはpipの代わりのパッケージマネージャーで、インストールにも使用できます。より詳細はAnacondaを参照してください [https://anaconda.org/conda-forge/ultralytics](https://anaconda.org/conda-forge/ultralytics)。Condaパッケージを更新するためのUltralyticsフィードストックリポジトリはこちらです [https://github.com/conda-forge/ultralytics-feedstock/](https://github.com/conda-forge/ultralytics-feedstock/)。 + + + [![Conda Recipe](https://img.shields.io/badge/recipe-ultralytics-green.svg)](https://anaconda.org/conda-forge/ultralytics) [![Conda Downloads](https://img.shields.io/conda/dn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics) [![Conda Version](https://img.shields.io/conda/vn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics) [![Conda Platforms](https://img.shields.io/conda/pn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics) + + ```bash + # Condaを使用してultralyticsパッケージをインストール + conda install -c conda-forge ultralytics + ``` + + !!! note + + CUDA環境でインストールする場合、パッケージマネージャーが競合を解決できるようにするため、`ultralytics`、`pytorch`、`pytorch-cuda`を同じコマンドで一緒にインストールするのがベストプラクティスです。または、CPU専用の`pytorch`パッケージに必要な場合は上書きするように`pytorch-cuda`を最後にインストールします。 + ```bash + # Condaを使用して一緒にすべてのパッケージをインストール + conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics + ``` + + ### Conda Dockerイメージ + + UltralyticsのConda Dockerイメージも[DockerHub](https://hub.docker.com/r/ultralytics/ultralytics)から利用可能です。これらのイメージは[Miniconda3](https://docs.conda.io/projects/miniconda/en/latest/)に基づいており、Conda環境で`ultralytics`を使用する簡単な方法です。 + + ```bash + # イメージ名を変数として設定 + t=ultralytics/ultralytics:latest-conda + + # Docker Hubから最新のultralyticsイメージをプル + sudo docker pull $t + + # すべてのGPUを持つコンテナでultralyticsイメージを実行 + sudo docker run -it --ipc=host --gpus all $t # すべてのGPU + sudo docker run -it --ipc=host --gpus '"device=2,3"' $t # GPUを指定 + ``` + + === "Gitクローン" + 開発への貢献に興味がある場合や、最新のソースコードで実験したい場合は、`ultralytics`リポジトリをクローンしてください。クローンした後、ディレクトリに移動し、pipを使って編集可能モード`-e`でパッケージをインストールします。 + ```bash + # ultralyticsリポジトリをクローン + git clone https://github.com/ultralytics/ultralytics + + # クローンしたディレクトリに移動 + cd ultralytics + + # 開発用に編集可能モードでパッケージをインストール + pip install -e . + ``` + +必要な依存関係のリストについては、`ultralytics`の[requirements.txt](https://github.com/ultralytics/ultralytics/blob/main/requirements.txt)ファイルを参照してください。上記の全ての例では、必要な依存関係を全てインストールします。 + +!!! tip "ヒント" + + PyTorchの要件はオペレーティングシステムとCUDAの要件によって異なるため、[https://pytorch.org/get-started/locally](https://pytorch.org/get-started/locally)に従って最初にPyTorchをインストールすることをお勧めします。 + + + PyTorch Installation Instructions + + +## CLIでUltralyticsを使用 + +Ultralyticsコマンドラインインターフェース（CLI）を使用すると、Python環境がなくても単一の行のコマンドを簡単に実行できます。CLIはカスタマイズもPythonコードも必要ありません。単純にすべてのタスクを`yolo`コマンドでターミナルから実行することができます。コマンドラインからYOLOv8を使用する方法について詳しくは、[CLIガイド](../usage/cli.md)を参照してください。 + +!!! example + + === "構文" + + Ultralyticsの`yolo`コマンドは以下の構文を使用します： + ```bash + yolo TASK MODE ARGS + + ここで TASK（オプション）は[detect, segment, classify]のうちの1つ + MODE（必須）は[train, val, predict, export, track]のうちの1つ + ARGS（オプション）はデフォルトを上書きする任意の数のカスタム'arg=value'ペアです。 + ``` + full [Configuration Guide](../usage/cfg.md)または`yolo cfg`で全てのARGSを確認してください + + === "トレーニング" + + 10エポックにわたって初期学習率0.01で検出モデルをトレーニング + ```bash + yolo train data=coco128.yaml model=yolov8n.pt epochs=10 lr0=0.01 + ``` + + === "予測" + + 画像サイズ320で事前トレーニングされたセグメンテーションモデルを使用してYouTubeビデオを予測： + ```bash + yolo predict model=yolov8n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320 + ``` + + === "検証" + + バッチサイズ1および画像サイズ640で事前トレーニングされた検出モデルを検証する： + ```bash + yolo val model=yolov8n.pt data=coco128.yaml batch=1 imgsz=640 + ``` + + === "エクスポート" + + 画像サイズ224 x 128でYOLOv8n分類モデルをONNX形式にエクスポート（TASKは不要） + ```bash + yolo export model=yolov8n-cls.pt format=onnx imgsz=224,128 + ``` + + === "特殊" + + バージョンを確認したり、設定を表示したり、チェックを行ったりするための特別なコマンドを実行します： + ```bash + yolo help + yolo checks + yolo version + yolo settings + yolo copy-cfg + yolo cfg + ``` + +!!! warning "警告" + + 引数は`arg=val`ペアとして渡され、`=`記号で分割され、ペア間にスペース` `が必要です。引数のプレフィックスに`--`や引数間にカンマ`,`を使用しないでください。 + + - `yolo predict model=yolov8n.pt imgsz=640 conf=0.25`   ✅ + - `yolo predict model yolov8n.pt imgsz 640 conf 0.25`   ❌ + - `yolo predict --model yolov8n.pt --imgsz 640 --conf 0.25`   ❌ + +[CLIガイド](../usage/cli.md){ .md-button .md-button--primary} + +## PythonでUltralyticsを使用 + +YOLOv8のPythonインターフェースを使用すると、Pythonプロジェクトにシームレスに統合し、モデルをロード、実行、出力を処理することが可能です。簡単さと使いやすさを念頭に設計されたPythonインターフェースにより、ユーザーは素早くプロジェクトに物体検出、セグメンテーション、分類を実装することができます。このように、YOLOv8のPythonインターフェースは、これらの機能をPythonプロジェクトに取り入れたいと考えている方にとって貴重なツールです。 + +たとえば、ユーザーはモデルをロードして、トレーニングし、検証セットでのパフォーマンスを評価し、ONNX形式にエクスポートするまでの一連の処理を数行のコードで行うことができます。YOLOv8をPythonプロジェクトで使用する方法について詳しくは、[Pythonガイド](../usage/python.md)を参照してください。 + +!!! example + + ```python + from ultralytics import YOLO + + # スクラッチから新しいYOLOモデルを作成 + model = YOLO('yolov8n.yaml') + + # 事前トレーニドされたYOLOモデルをロード（トレーニングに推奨） + model = YOLO('yolov8n.pt') + + # 'coco128.yaml'データセットを使用して3エポックでモデルをトレーニング + results = model.train(data='coco128.yaml', epochs=3) + + # モデルのパフォーマンスを検証セットで評価 + results = model.val() + + # モデルを使用して画像で物体検出を実行 + results = model('https://ultralytics.com/images/bus.jpg') + + # モデルをONNX形式にエクスポート + success = model.export(format='onnx') + ``` + +[Pythonガイド](../usage/python.md){.md-button .md-button--primary} diff --git a/docs/ja/tasks/classify.md b/docs/ja/tasks/classify.md new file mode 100644 index 00000000..201f9dee --- /dev/null +++ b/docs/ja/tasks/classify.md @@ -0,0 +1,172 @@ +--- +comments: true +description: YOLOv8 分類モデルについての画像分類。事前トレーニングされたモデルのリストとモデルのトレーニング、検証、予測、エクスポート方法の詳細情報を学びます。 +keywords: Ultralytics, YOLOv8, 画像分類, 事前トレーニングされたモデル, YOLOv8n-cls, トレーニング, 検証, 予測, モデルエクスポート +--- + +# 画像分類 + +画像分類の例 + +画像分類は3つのタスクの中で最も単純で、1枚の画像をあらかじめ定義されたクラスのセットに分類します。 + +画像分類器の出力は単一のクラスラベルと信頼度スコアです。画像がどのクラスに属しているかのみを知る必要があり、クラスのオブジェクトがどこにあるか、その正確な形状は必要としない場合に画像分類が役立ちます。 + +!!! tip "ヒント" + + YOLOv8 分類モデルは `-cls` 接尾辞を使用します。例: `yolov8n-cls.pt` これらは [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml) で事前にトレーニングされています。 + +## [モデル](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8) + +ここに事前トレーニングされた YOLOv8 分類モデルが表示されています。検出、セグメンテーション、ポーズモデルは [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml) データセットで事前にトレーニングされていますが、分類モデルは [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml) で事前にトレーニングされています。 + +[モデル](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) は初回使用時に Ultralytics の最新 [リリース](https://github.com/ultralytics/assets/releases) から自動的にダウンロードされます。 + +| モデル | サイズ
(ピクセル) | 正確性
トップ1 | 正確性
トップ5 | スピード
CPU ONNX
(ms) | スピード
A100 TensorRT
(ms) | パラメータ
(M) | FLOPs
(B) at 640 | +|----------------------------------------------------------------------------------------------|--------------------|------------------|------------------|-------------------------------|------------------------------------|-------------------|--------------------------| +| [YOLOv8n-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-cls.pt) | 224 | 66.6 | 87.0 | 12.9 | 0.31 | 2.7 | 4.3 | +| [YOLOv8s-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-cls.pt) | 224 | 72.3 | 91.1 | 23.4 | 0.35 | 6.4 | 13.5 | +| [YOLOv8m-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-cls.pt) | 224 | 76.4 | 93.2 | 85.4 | 0.62 | 17.0 | 42.7 | +| [YOLOv8l-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-cls.pt) | 224 | 78.0 | 94.1 | 163.0 | 0.87 | 37.5 | 99.7 | +| [YOLOv8x-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-cls.pt) | 224 | 78.4 | 94.3 | 232.0 | 1.01 | 57.4 | 154.8 | + +- **正確性** の値は [ImageNet](https://www.image-net.org/) データセットの検証セットでのモデルの正確性です。 +
再現するには `yolo val classify data=path/to/ImageNet device=0` +- **スピード** は [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) インスタンスを使用して ImageNet 検証画像を平均化したものです。 +
再現するには `yolo val classify data=path/to/ImageNet batch=1 device=0|cpu` + +## トレーニング + +画像サイズ64で100エポックにわたってMNIST160データセットにYOLOv8n-clsをトレーニングします。利用可能な引数の完全なリストについては、[設定](../../usage/cfg.md) ページを参照してください。 + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # モデルをロードする + model = YOLO('yolov8n-cls.yaml') # YAMLから新しいモデルをビルド + model = YOLO('yolov8n-cls.pt') # 事前にトレーニングされたモデルをロード（トレーニングに推奨） + model = YOLO('yolov8n-cls.yaml').load('yolov8n-cls.pt') # YAMLからビルドしてウェイトを転送 + + # モデルをトレーニングする + results = model.train(data='mnist160', epochs=100, imgsz=64) + ``` + + === "CLI" + + ```bash + # YAMLから新しいモデルをビルドし、ゼロからトレーニングを開始 + yolo classify train data=mnist160 model=yolov8n-cls.yaml epochs=100 imgsz=64 + + # 事前にトレーニングされた *.pt モデルからトレーニングを開始 + yolo classify train data=mnist160 model=yolov8n-cls.pt epochs=100 imgsz=64 + + # YAMLから新しいモデルをビルドし、事前トレーニングされたウェイトを転送してトレーニングを開始 + yolo classify train data=mnist160 model=yolov8n-cls.yaml pretrained=yolov8n-cls.pt epochs=100 imgsz=64 + ``` + +### データセットフォーマット + +YOLO分類データセットのフォーマットの詳細は [データセットガイド](../../datasets/classify/index.md) にあります。 + +## 検証 + +MNIST160データセットでトレーニング済みのYOLOv8n-clsモデルの正確性を検証します。引数は必要ありません。`model` はトレーニング時の `data` および引数をモデル属性として保持しています。 + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # モデルをロードする + model = YOLO('yolov8n-cls.pt') # 公式モデルをロード + model = YOLO('path/to/best.pt') # カスタムモデルをロード + + # モデルを検証する + metrics = model.val() # 引数不要、データセットと設定は記憶されている + metrics.top1 # トップ1の正確性 + metrics.top5 # トップ5の正確性 + ``` + === "CLI" + + ```bash + yolo classify val model=yolov8n-cls.pt # 公式モデルを検証 + yolo classify val model=path/to/best.pt # カスタムモデルを検証 + ``` + +## 予測 + +トレーニング済みのYOLOv8n-clsモデルを使用して、画像に対する予測を実行します。 + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # モデルをロードする + model = YOLO('yolov8n-cls.pt') # 公式モデルをロード + model = YOLO('path/to/best.pt') # カスタムモデルをロード + + # モデルで予測する + results = model('https://ultralytics.com/images/bus.jpg') # 画像で予測 + ``` + === "CLI" + + ```bash + yolo classify predict model=yolov8n-cls.pt source='https://ultralytics.com/images/bus.jpg' # 公式モデルで予測 + yolo classify predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # カスタムモデルで予測 + ``` + +`predict` モードの完全な詳細は [予測](https://docs.ultralytics.com/modes/predict/) ページを参照してください。 + +## エクスポート + +YOLOv8n-clsモデルをONNX、CoreMLなどの異なる形式にエクスポートします。 + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # モデルをロードする + model = YOLO('yolov8n-cls.pt') # 公式モデルをロード + model = YOLO('path/to/best.pt') # カスタムトレーニングされたモデルをロード + + # モデルをエクスポートする + model.export(format='onnx') + ``` + === "CLI" + + ```bash + yolo export model=yolov8n-cls.pt format=onnx # 公式モデルをエクスポート + yolo export model=path/to/best.pt format=onnx # カスタムトレーニングされたモデルをエクスポート + ``` + +利用可能な YOLOv8-cls エクスポート形式は以下の表にあります。エクスポートされたモデルで直接予測または検証が可能です、例: `yolo predict model=yolov8n-cls.onnx`。エクスポート完了後、モデルの使用例が表示されます。 + +| 形式 | `format` 引数 | モデル | メタデータ | 引数 | +|--------------------------------------------------------------------|---------------|-------------------------------|-------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n-cls.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-cls.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-cls.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-cls_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-cls.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-cls.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-cls_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-cls.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-cls.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-cls_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-cls_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-cls_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-cls_ncnn_model/` | ✅ | `imgsz`, `half` | + +`export` の詳細は [エクスポート](https://docs.ultralytics.com/modes/export/) ページを参照してください。 diff --git a/docs/ja/tasks/detect.md b/docs/ja/tasks/detect.md new file mode 100644 index 00000000..9b4d4fe1 --- /dev/null +++ b/docs/ja/tasks/detect.md @@ -0,0 +1,184 @@ +--- +comments: true +description: Ultralyticsの公式ドキュメント YOLOv8。モデルのトレーニング、検証、予測、そして様々なフォーマットでのモデルエクスポート方法を学ぶ。詳細なパフォーマンス統計も含む。 +keywords: YOLOv8, Ultralytics, 物体検出, 事前訓練済みモデル, トレーニング, 検証, 予測, モデルエクスポート, COCO, ImageNet, PyTorch, ONNX, CoreML +--- + +# 物体検出 + +物体検出の例 + +物体検出とは、画像やビデオストリーム内の物体の位置とクラスを特定するタスクです。 + +物体検出器の出力は、画像内の物体を囲む一連のバウンディングボックスであり、各ボックスにはクラスラベルと信頼度スコアが付けられます。シーン内の関心対象を識別する必要があるが、その物体の正確な位置や形状までは必要ない場合に、物体検出が適しています。 + +

+
+ +
+ 視聴する: Ultralyticsの事前訓練済みYOLOv8モデルによる物体検出。 +

+ +!!! tip "ヒント" + + YOLOv8 Detectモデルは、デフォルトのYOLOv8モデル、つまり`yolov8n.pt`であり、[COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml)で事前訓練されています。 + +## [モデル](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8) + +事前訓練されたYOLOv8 Detectモデルがこちらに示されます。Detect, Segment, Poseモデルは[COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml)データセットで、Classifyモデルは[ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml)データセットで事前訓練されています。 + +[モデル](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models)は、最初の使用時にUltralyticsの最新の[リリース](https://github.com/ultralytics/assets/releases)から自動的にダウンロードされます。 + +| モデル | サイズ
(ピクセル) | mAPval
50-95 | 速度
CPU ONNX
(ms) | 速度
A100 TensorRT
(ms) | パラメータ数
(M) | FLOPs
(B) | +|--------------------------------------------------------------------------------------|--------------------|----------------------|-----------------------------|----------------------------------|--------------------|-------------------| +| [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n.pt) | 640 | 37.3 | 80.4 | 0.99 | 3.2 | 8.7 | +| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s.pt) | 640 | 44.9 | 128.4 | 1.20 | 11.2 | 28.6 | +| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m.pt) | 640 | 50.2 | 234.7 | 1.83 | 25.9 | 78.9 | +| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l.pt) | 640 | 52.9 | 375.2 | 2.39 | 43.7 | 165.2 | +| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x.pt) | 640 | 53.9 | 479.1 | 3.53 | 68.2 | 257.8 | + +- **mAPval** の値は[COCO val2017](http://cocodataset.org)データセットにおいて、単一モデル単一スケールでのものです。 +
再現方法: `yolo val detect data=coco.yaml device=0` +- **速度** は[Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/)インスタンスを使用してCOCO val画像に対して平均化されたものです。 +
再現方法: `yolo val detect data=coco128.yaml batch=1 device=0|cpu` + +## トレーニング + +YOLOv8nを画像サイズ640でCOCO128データセットに対して100エポックでトレーニングします。使用可能な引数の完全なリストについては、[設定](../../usage/cfg.md)ページをご覧ください。 + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # モデルをロードする + model = YOLO('yolov8n.yaml') # YAMLから新しいモデルを構築 + model = YOLO('yolov8n.pt') # 事前訓練済みモデルをロード（トレーニングに推奨） + model = YOLO('yolov8n.yaml').load('yolov8n.pt') # YAMLから構築し、重みを転送 + + # モデルをトレーニングする + results = model.train(data='coco128.yaml', epochs=100, imgsz=640) + ``` + === "CLI" + + ```bash + # YAMLから新しいモデルを作成し、ゼロからトレーニングを開始 + yolo detect train data=coco128.yaml model=yolov8n.yaml epochs=100 imgsz=640 + + # 事前訓練済みの*.ptモデルからトレーニングを開始 + yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 + + # YAMLから新しいモデルを作成し、事前訓練済みの重みを転送してトレーニングを開始 + yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640 + ``` + +### データセットの形式 + +YOLO検出データセットの形式の詳細は、[データセットガイド](../../datasets/detect/index.md)に記載されています。他の形式（COCO等）からYOLO形式に既存のデータセットを変換するには、Ultralyticsの[JSON2YOLO](https://github.com/ultralytics/JSON2YOLO)ツールをご利用ください。 + +## 検証 + +トレーニングされたYOLOv8nモデルの精度をCOCO128データセットで検証します。引数は不要で、モデルはトレーニングの`data`と引数をモデル属性として保持しています。 + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # モデルをロードする + model = YOLO('yolov8n.pt') # 公式モデルをロード + model = YOLO('パス/ベスト.pt') # カスタムモデルをロード + + # モデルを検証する + metrics = model.val() # 引数不要、データセットと設定は記憶されている + metrics.box.map # map50-95 + metrics.box.map50 # map50 + metrics.box.map75 # map75 + metrics.box.maps # 各カテゴリのmap50-95を含むリスト + ``` + === "CLI" + + ```bash + yolo detect val model=yolov8n.pt # 公式モデルを検証 + yolo detect val model=パス/ベスト.pt # カスタムモデルを検証 + ``` + +## 予測 + +トレーニングされたYOLOv8nモデルを使用して画像の予測を実行します。 + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # モデルをロードする + model = YOLO('yolov8n.pt') # 公式モデルをロード + model = YOLO('パス/ベスト.pt') # カスタムモデルをロード + + # モデルで予測 + results = model('https://ultralytics.com/images/bus.jpg') # 画像の予測実行 + ``` + === "CLI" + + ```bash + yolo detect predict model=yolov8n.pt source='https://ultralytics.com/images/bus.jpg' # 公式モデルで予測 + yolo detect predict model=パス/ベスト.pt source='https://ultralytics.com/images/bus.jpg' # カスタムモデルで予測 + ``` + +`predict`モードの詳細は、[Predict](https://docs.ultralytics.com/modes/predict/)ページで全て見ることができます。 + +## エクスポート + +YOLOv8nモデルをONNX、CoreMLなどの異なるフォーマットにエクスポートします。 + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # モデルをロード + model = YOLO('yolov8n.pt') # 公式モデルをロード + model = YOLO('パス/ベスト.pt') # カスタムトレーニングモデルをロード + + # モデルをエクスポート + model.export(format='onnx') + ``` + === "CLI" + + ```bash + yolo export model=yolov8n.pt format=onnx # 公式モデルをエクスポート + yolo export model=パス/ベスト.pt format=onnx # カスタムトレーニングモデルをエクスポート + ``` + +YOLOv8エクスポート可能なフォーマットのテーブルは以下です。エクスポート完了後に、エクスポートされたモデルで直接予測または検証が可能です。つまり、`yolo predict model=yolov8n.onnx` です。使用例はエクスポート完了後にモデルに表示されます。 + +| フォーマット | `format`引数 | モデル | メタデータ | 引数 | +|--------------------------------------------------------------------|---------------|---------------------------|-------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | ✅ | `imgsz`, `half` | + +`export`の詳細は、[Export](https://docs.ultralytics.com/modes/export/)ページで全て見ることができます。 diff --git a/docs/ja/tasks/index.md b/docs/ja/tasks/index.md new file mode 100644 index 00000000..4713c877 --- /dev/null +++ b/docs/ja/tasks/index.md @@ -0,0 +1,55 @@ +--- +comments: true +description: YOLOv8が実行できる基本的なコンピュータービジョンタスクについて学び、検出、セグメンテーション、分類、ポーズ認識がAIプロジェクトでどのように使用されるかを理解します。 +keywords: Ultralytics, YOLOv8, 検出, セグメンテーション, 分類, ポーズ推定, AIフレームワーク, コンピュータービジョンタスク +--- + +# Ultralytics YOLOv8タスク + +
+Ultralytics YOLOがサポートするタスク + +YOLOv8は、複数のコンピュータービジョン**タスク**をサポートするAIフレームワークです。このフレームワークは、[検出](detect.md)、[セグメンテーション](segment.md)、[分類](classify.md)、及び[ポーズ](pose.md)推定を実行するために使用できます。これらのタスクはそれぞれ異なる目的と用途を持っています。 + +!!! note + + 🚧 当社の多言語ドキュメントは現在建設中であり、改善のために一生懸命作業を行っています。ご理解いただきありがとうございます！🙏 + +

+
+ +
+ 視聴する: Ultralytics YOLOタスクの探索：オブジェクト検出、セグメンテーション、トラッキング、ポーズ推定。 +

+ +## [検出](detect.md) + +検出はYOLOv8がサポートする基本的なタスクです。それは画像やビデオフレーム内のオブジェクトを検出し、周囲に境界ボックスを描くことを含みます。検出されたオブジェクトはその特徴に基づいて異なるカテゴリーに分類されます。YOLOv8は一枚の画像やビデオフレームに複数のオブジェクトを高い精度と速度で検出することができます。 + +[検出例](detect.md){ .md-button .md-button--primary} + +## [セグメンテーション](segment.md) + +セグメンテーションは、画像の内容に基づいて画像を異なる領域に分割するタスクです。各領域はその内容に基づいてラベルが割り当てられます。このタスクは、画像分割や医療画像処理などのアプリケーションにおいて有用です。YOLOv8はU-Netアーキテクチャのバリエーションを使用してセグメンテーションを実行します。 + +[セグメンテーション例](segment.md){ .md-button .md-button--primary} + +## [分類](classify.md) + +分類は、画像を異なるカテゴリーに分類するタスクです。YOLOv8は画像の内容に基づいて画像を分類するために使用できます。それはEfficientNetアーキテクチャのバリエーションを使用して分類を実行します。 + +[分類例](classify.md){ .md-button .md-button--primary} + +## [ポーズ](pose.md) + +ポーズ/キーポイント検出は、画像やビデオフレーム内の特定の点を検出するタスクです。これらの点はキーポイントと呼ばれ、動きやポーズ推定を追跡するために使用されます。YOLOv8は高い精度と速度で画像やビデオフレーム内のキーポイントを検出することができます。 + +[ポーズ例](pose.md){ .md-button .md-button--primary} + +## 結論 + +YOLOv8は、検出、セグメンテーション、分類、キーポイント検出を含む複数のタスクをサポートしています。これらのタスクはそれぞれ異なる目的と用途を持っています。これらのタスクの違いを理解することにより、コンピュータービジョンアプリケーションに適切なタスクを選択することができます。 diff --git a/docs/ja/tasks/pose.md b/docs/ja/tasks/pose.md new file mode 100644 index 00000000..7ff74542 --- /dev/null +++ b/docs/ja/tasks/pose.md @@ -0,0 +1,185 @@ +--- +comments: true +description: Ultralytics YOLOv8を使用してポーズ推定タスクを行う方法を学びます。事前トレーニング済みのモデルを見つけ、トレーニング、検証、予測、独自のエクスポートを行います。 +keywords: Ultralytics, YOLO, YOLOv8, ポーズ推定, キーポイント検出, 物体検出, 事前トレーニング済みモデル, 機械学習, 人工知能 +--- + +# ポーズ推定 + +ポーズ推定例 + +ポーズ推定は、通常キーポイントとして参照される画像内の特定の点の位置を識別するタスクです。キーポイントは、関節、ランドマーク、またはその他の特徴的な特徴など、対象物のさまざまな部分を表すことができます。キーポイントの位置は、通常2Dの `[x, y]` または3D `[x, y, visible]` 座標のセットとして表されます。 + +ポーズ推定モデルの出力は、画像内のオブジェクト上のキーポイントを表す一連の点であり、通常は各点の信頼スコアを伴います。ポーズ推定は、シーン内のオブジェクトの特定の部分と、それらが互いに対して位置する場所を特定する必要がある場合に適しています。 + +

+
+ +
+ 視聴: Ultralytics YOLOv8によるポーズ推定。 +

+ +!!! tip "ヒント" + + YOLOv8 _pose_ モデルは `-pose` サフィックスを使用します。例：`yolov8n-pose.pt`。これらのモデルは [COCOキーポイント](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco-pose.yaml) データセットでトレーニングされ、多様なポーズ推定タスクに適しています。 + +## [モデル](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8) + +YOLOv8事前トレーニング済みポーズモデルはこちらです。Detect, Segment, Poseモデルは [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml) データセットで、Classifyモデルは [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml) データセットで事前トレーニングされています。 + +[モデル](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models)は最新のUltralytics [リリース](https://github.com/ultralytics/assets/releases)から最初の使用時に自動的にダウンロードされます。 + +| モデル | サイズ
(ピクセル) | mAPポーズ
50-95 | mAPポーズ
50 | 速度
CPU ONNX
(ミリ秒) | 速度
A100 TensorRT
(ミリ秒) | パラメータ
(M) | FLOPs
(B) | +|------------------------------------------------------------------------------------------------------|--------------------|----------------------|-------------------|------------------------------|-----------------------------------|-------------------|-------------------| +| [YOLOv8n-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-pose.pt) | 640 | 50.4 | 80.1 | 131.8 | 1.18 | 3.3 | 9.2 | +| [YOLOv8s-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-pose.pt) | 640 | 60.0 | 86.2 | 233.2 | 1.42 | 11.6 | 30.2 | +| [YOLOv8m-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-pose.pt) | 640 | 65.0 | 88.8 | 456.3 | 2.00 | 26.4 | 81.0 | +| [YOLOv8l-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-pose.pt) | 640 | 67.6 | 90.0 | 784.5 | 2.59 | 44.4 | 168.6 | +| [YOLOv8x-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose.pt) | 640 | 69.2 | 90.2 | 1607.1 | 3.73 | 69.4 | 263.2 | +| [YOLOv8x-pose-p6](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose-p6.pt) | 1280 | 71.6 | 91.2 | 4088.7 | 10.04 | 99.1 | 1066.4 | + +- **mAPval** の値は、[COCO Keypoints val2017](http://cocodataset.org)データセットでの単一モデル単一スケールに対するものです。 +
再現方法 `yolo val pose data=coco-pose.yaml device=0` +- **速度** は [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/)インスタンスを使用したCOCO val画像の平均です。 +
再現方法 `yolo val pose data=coco8-pose.yaml batch=1 device=0|cpu` + +## トレーニング + +COCO128-poseデータセットでYOLOv8-poseモデルをトレーニングします。 + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # モデルをロード + model = YOLO('yolov8n-pose.yaml') # 新しいモデルをYAMLからビルド + model = YOLO('yolov8n-pose.pt') # 事前トレーニング済みのモデルをロード（トレーニング用に推奨） + model = YOLO('yolov8n-pose.yaml').load('yolov8n-pose.pt') # YAMLからビルドして重みを転送 + + # モデルのトレーニング + results = model.train(data='coco8-pose.yaml', epochs=100, imgsz=640) + ``` + === "CLI" + + ```bash + # YAMLから新しいモデルをビルドし、最初からトレーニングを開始 + yolo pose train data=coco8-pose.yaml model=yolov8n-pose.yaml epochs=100 imgsz=640 + + # 事前トレーニング済みの*.ptモデルからトレーニングを開始 + yolo pose train data=coco8-pose.yaml model=yolov8n-pose.pt epochs=100 imgsz=640 + + # YAMLから新しいモデルをビルド、事前トレーニング済みの重みを転送してトレーニングを開始 + yolo pose train data=coco8-pose.yaml model=yolov8n-pose.yaml pretrained=yolov8n-pose.pt epochs=100 imgsz=640 + ``` + +### データセットフォーマット + +YOLOポーズデータセットフォーマットの詳細は、[データセットガイド](../../datasets/pose/index.md)に記載されています。既存のデータセットを他のフォーマット（COCOなど）からYOLOフォーマットに変換するには、Ultralyticsの[JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) ツールをご使用ください。 + +## Val + +COCO128-poseデータセットでトレーニングされたYOLOv8n-poseモデルの精度を検証します。引数は必要なく、`model`にはトレーニング`data`と引数がモデル属性として保持されます。 + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # モデルをロード + model = YOLO('yolov8n-pose.pt') # 公式モデルをロード + model = YOLO('path/to/best.pt') # カスタムモデルをロード + + # モデルを検証 + metrics = model.val() # データセットや設定は記録されているため引数は不要 + metrics.box.map # map50-95 + metrics.box.map50 # map50 + metrics.box.map75 # map75 + metrics.box.maps # 各カテゴリのmap50-95が含まれるリスト + ``` + === "CLI" + + ```bash + yolo pose val model=yolov8n-pose.pt # 公式モデルを検証 + yolo pose val model=path/to/best.pt # カスタムモデルを検証 + ``` + +## Predict + +トレーニング済みのYOLOv8n-poseモデルを使用して画像を予測します。 + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # モデルをロード + model = YOLO('yolov8n-pose.pt') # 公式モデルをロード + model = YOLO('path/to/best.pt') # カスタムモデルをロード + + # モデルで予測 + results = model('https://ultralytics.com/images/bus.jpg') # 画像に予測を実行 + ``` + === "CLI" + + ```bash + yolo pose predict model=yolov8n-pose.pt source='https://ultralytics.com/images/bus.jpg' # 公式モデルで予測 + yolo pose predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # カスタムモデルで予測 + ``` + +`predict`モードの詳細を[Predict](https://docs.ultralytics.com/modes/predict/)ページでご覧いただけます。 + +## Export + +YOLOv8n PoseモデルをONNX、CoreMLなどの異なるフォーマットにエクスポートします。 + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # モデルをロード + model = YOLO('yolov8n-pose.pt') # 公式モデルをロード + model = YOLO('path/to/best.pt') # カスタムトレーニング済みモデルをロード + + # モデルをエクスポート + model.export(format='onnx') + ``` + === "CLI" + + ```bash + yolo export model=yolov8n-pose.pt format=onnx # 公式モデルをエクスポート + yolo export model=path/to/best.pt format=onnx # カスタムトレーニング済みモデルをエクスポート + ``` + +利用可能なYOLOv8-poseエクスポートフォーマットは以下の表に示されており、エクスポート完了後にお使いのモデルに関する使用例が示されます。 + +| フォーマット | `format`引数 | モデル | メタデータ | 引数 | +|--------------------------------------------------------------------|---------------|--------------------------------|-------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n-pose.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-pose.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-pose.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-pose_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-pose.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-pose.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-pose_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-pose.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-pose.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-pose_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-pose_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-pose_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-pose_ncnn_model/` | ✅ | `imgsz`, `half` | + +`export`の詳細は[Export](https://docs.ultralytics.com/modes/export/)ページでご覧いただけます。 diff --git a/docs/ja/tasks/segment.md b/docs/ja/tasks/segment.md new file mode 100644 index 00000000..73427775 --- /dev/null +++ b/docs/ja/tasks/segment.md @@ -0,0 +1,186 @@ +--- +comments: true +description: Ultralytics YOLOを使用してインスタンスセグメンテーションモデルを使いこなす方法を学びましょう。トレーニング、バリデーション、画像予測、モデルエクスポートに関する指示が含まれています。 +keywords: yolov8, インスタンスセグメンテーション, Ultralytics, COCOデータセット, 画像セグメンテーション, オブジェクト検出, モデルトレーニング, モデルバリデーション, 画像予測, モデルエクスポート +--- + +# インスタンスセグメンテーション + +インスタンスセグメンテーションの例 + +インスタンスセグメンテーションはオブジェクト検出を一歩進めており、画像内の個々のオブジェクトを識別し、それらを画像の残りの部分からセグメント化します。 + +インスタンスセグメンテーションモデルの出力は、画像内の各オブジェクトを概説するマスクまたは輪郭のセットであり、各オブジェクトにはクラスラベルと信頼スコアが含まれています。オブジェクトの位置だけでなく、その正確な形状を知る必要がある場合に、インスタンスセグメンテーションが役立ちます。 + +

+
+ +
+ 視聴: Pythonで事前トレーニング済みのUltralytics YOLOv8モデルでセグメンテーションを実行する。 +

+ +!!! tip "ヒント" + + YOLOv8セグメントモデルは`-seg`サフィックスを使用し、つまり`yolov8n-seg.pt`などは[COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml)で事前トレーニングされています。 + +## [モデル](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8) + +ここでは、事前トレーニングされたYOLOv8セグメントモデルが示されています。Detect、Segment、Poseモデルは[COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml)データセットで事前トレーニングされている一方、Classifyモデルは[ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml)データセットで事前トレーニングされています。 + +[モデル](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models)は初回使用時に最新のUltralytics[リリース](https://github.com/ultralytics/assets/releases)から自動的にダウンロードされます。 + +| モデル | サイズ
(ピクセル) | mAPbox
50-95 | mAPmask
50-95 | スピード
CPU ONNX
(ms) | スピード
A100 TensorRT
(ms) | パラメータ
(M) | FLOPs
(B) | +|----------------------------------------------------------------------------------------------|--------------------|----------------------|-----------------------|-------------------------------|------------------------------------|-------------------|-------------------| +| [YOLOv8n-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-seg.pt) | 640 | 36.7 | 30.5 | 96.1 | 1.21 | 3.4 | 12.6 | +| [YOLOv8s-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-seg.pt) | 640 | 44.6 | 36.8 | 155.7 | 1.47 | 11.8 | 42.6 | +| [YOLOv8m-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-seg.pt) | 640 | 49.9 | 40.8 | 317.0 | 2.18 | 27.3 | 110.2 | +| [YOLOv8l-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-seg.pt) | 640 | 52.3 | 42.6 | 572.4 | 2.79 | 46.0 | 220.5 | +| [YOLOv8x-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-seg.pt) | 640 | 53.4 | 43.4 | 712.1 | 4.02 | 71.8 | 344.1 | + +- **mAPval**の値は[COCO val2017](http://cocodataset.org)データセットでの単一モデル単一スケールの値です。 +
再現するには `yolo val segment data=coco.yaml device=0` +- **スピード**は[Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/)インスタンスを使用してCOCO val画像で平均化されます。 +
再現するには `yolo val segment data=coco128-seg.yaml batch=1 device=0|cpu` + +## トレーニング + +COCO128-segデータセットで、画像サイズ640でYOLOv8n-segを100エポックトレーニングします。利用可能な全ての引数については、[コンフィギュレーション](../../usage/cfg.md)ページを参照してください。 + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # モデルをロード + model = YOLO('yolov8n-seg.yaml') # YAMLから新しいモデルをビルド + model = YOLO('yolov8n-seg.pt') # 事前トレーニングされたモデルをロード(トレーニングに推奨) + model = YOLO('yolov8n-seg.yaml').load('yolov8n.pt') # YAMLからビルドしウェイトを移行 + + # モデルをトレーニング + results = model.train(data='coco128-seg.yaml', epochs=100, imgsz=640) + ``` + === "CLI" + + ```bash + # YAMLから新しいモデルをビルドしゼロからトレーニングを開始 + yolo segment train data=coco128-seg.yaml model=yolov8n-seg.yaml epochs=100 imgsz=640 + + # 事前トレーニング済みの*.ptモデルからトレーニングを開始 + yolo segment train data=coco128-seg.yaml model=yolov8n-seg.pt epochs=100 imgsz=640 + + # YAMLから新しいモデルをビルドし、事前トレーニング済みウェイトを移行してトレーニングを開始 + yolo segment train data=coco128-seg.yaml model=yolov8n-seg.yaml pretrained=yolov8n-seg.pt epochs=100 imgsz=640 + ``` + +### データセットフォーマット + +YOLOセグメンテーションデータセットのフォーマットの詳細は、[データセットガイド](../../datasets/segment/index.md)で見つけることができます。既存のデータセットを他のフォーマット(例えばCOCOなど)からYOLOフォーマットに変換するには、Ultralyticsの[JSON2YOLO](https://github.com/ultralytics/JSON2YOLO)ツールを使用してください。 + +## 評価 + +訓練されたYOLOv8n-segモデルの精度をCOCO128-segデータセットで検証します。引数は必要ありません、なぜなら`model`はモデル属性としてトレーニング`data`と引数を保持しているからです。 + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # モデルをロード + model = YOLO('yolov8n-seg.pt') # 公式モデルをロード + model = YOLO('path/to/best.pt') # カスタムモデルをロード + + # モデルを評価 + metrics = model.val() # 引数は必要なし、データセットと設定は記憶している + metrics.box.map # map50-95(B) + metrics.box.map50 # map50(B) + metrics.box.map75 # map75(B) + metrics.box.maps # 各カテゴリのmap50-95(B)のリスト + metrics.seg.map # map50-95(M) + metrics.seg.map50 # map50(M) + metrics.seg.map75 # map75(M) + metrics.seg.maps # 各カテゴリのmap50-95(M)のリスト + ``` + === "CLI" + + ```bash + yolo segment val model=yolov8n-seg.pt # 公式モデルを評価 + yolo segment val model=path/to/best.pt # カスタムモデルを評価 + ``` + +## 予測 + +訓練されたYOLOv8n-segモデルを使用して画像の予測を実行します。 + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # モデルをロード + model = YOLO('yolov8n-seg.pt') # 公式モデルをロード + model = YOLO('path/to/best.pt') # カスタムモデルをロード + + # モデルで予測 + results = model('https://ultralytics.com/images/bus.jpg') # 画像で予測 + ``` + === "CLI" + + ```bash + yolo segment predict model=yolov8n-seg.pt source='https://ultralytics.com/images/bus.jpg' # 公式モデルで予測 + yolo segment predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # カスタムモデルで予測 + ``` + +`predict`モードの完全な詳細は、[予測](https://docs.ultralytics.com/modes/predict/)ページにて確認できます。 + +## エクスポート + +YOLOv8n-segモデルをONNX、CoreMLなどの別の形式にエクスポートします。 + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # モデルをロード + model = YOLO('yolov8n-seg.pt') # 公式モデルをロード + model = YOLO('path/to/best.pt') # カスタムトレーニングされたモデルをロード + + # モデルをエクスポート + model.export(format='onnx') + ``` + === "CLI" + + ```bash + yolo export model=yolov8n-seg.pt format=onnx # 公式モデルをエクスポート + yolo export model=path/to/best.pt format=onnx # カスタムトレーニングされたモデルをエクスポート + ``` + +ご利用可能なYOLOv8-segエクスポート形式は以下の表に示されています。エクスポートされたモデルに直接予測または評価が可能です、つまり `yolo predict model=yolov8n-seg.onnx`。エクスポートが完了した後に、モデルの使用例が表示されます。 + +| 形式 | `format`引数 | モデル | メタデータ | 引数 | +|--------------------------------------------------------------------|---------------|-------------------------------|-------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n-seg.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-seg.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-seg.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-seg_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-seg.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-seg.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-seg_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-seg.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-seg.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-seg_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-seg_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-seg_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-seg_ncnn_model/` | ✅ | `imgsz`, `half` | diff --git a/docs/ko/datasets/index.md b/docs/ko/datasets/index.md new file mode 100644 index 00000000..3ac8af7e --- /dev/null +++ b/docs/ko/datasets/index.md @@ -0,0 +1,127 @@ +--- +comments: true +description: Ultralytics가 지원하는 객체 탐지, 세분화, 자세 추정, 이미지 분류, 다중 객체 추적을 위한 다양한 컴퓨터 비전 데이터셋에 대한 탐색입니다. +keywords: 컴퓨터 비전, 데이터셋, Ultralytics, YOLO, 객체 탐지, 인스턴스 세분화, 자세 추정, 이미지 분류, 다중 객체 추적 +--- + +# 데이터셋 개요 + +Ultralytics는 탐지, 인스턴스 세분화, 자세 추정, 분류 및 다중 객체 추적과 같은 컴퓨터 비전 작업을 촉진하기 위해 다양한 데이터셋을 지원합니다. 아래는 주요 Ultralytics 데이터셋 목록과 각 컴퓨터 비전 작업의 요약, 그리고 해당 데이터셋입니다. + +!!! note + + 🚧 다국어 문서 작업은 현재 진행 중이며, 우리는 이를 개선하기 위해 노력하고 있습니다. 인내해 주셔서 감사합니다! 🙏 + +## [탐지 데이터셋](../../datasets/detect/index.md) + +바운딩 박스 객체 탐지는 이미지 내 객체들을 탐지하고 각 객체 주위에 바운딩 박스를 그려 객체를 위치시키는 컴퓨터 비전 기법입니다. + +- [Argoverse](../../datasets/detect/argoverse.md): 도시 환경에서의 3D 추적 및 동작 예측 데이터와 풍부한 주석이 담긴 데이터셋입니다. +- [COCO](../../datasets/detect/coco.md): 20만개가 넘는 레이블이 붙은 이미지로 설계된 객체 탐지, 세분화 및 설명을 위한 대규모 데이터셋입니다. +- [COCO8](../../datasets/detect/coco8.md): COCO train 및 COCO val에서 처음 4개의 이미지를 포함하여 신속한 테스트에 적합합니다. +- [Global Wheat 2020](../../datasets/detect/globalwheat2020.md): 전 세계에서 수집한 밀 머리 이미지로 구성된 객체 탐지 및 위치 지정 작업을 위한 데이터셋입니다. +- [Objects365](../../datasets/detect/objects365.md): 365개 객체 카테고리와 60만개가 넘는 주석이 달린 이미지를 포함하는 고품질 대규모 객체 탐지용 데이터셋입니다. +- [OpenImagesV7](../../datasets/detect/open-images-v7.md): 구글에서 제공하는 170만개의 훈련 이미지와 4만 2천개의 검증 이미지를 포함하는 포괄적인 데이터셋입니다. +- [SKU-110K](../../datasets/detect/sku-110k.md): 1만 1천 개의 이미지와 170만 개의 바운딩 박스를 특징으로 하는 소매 환경에서 밀집된 객체 탐지를 위한 데이터셋입니다. +- [VisDrone](../../datasets/detect/visdrone.md): 드론으로 촬영한 영상에서 객체 탐지 및 다중 객체 추적 데이터를 포함하는 데이터셋으로 1만 개가 넘는 이미지와 비디오 시퀀스를 포함합니다. +- [VOC](../../datasets/detect/voc.md): 객체 탐지와 세분화를 위한 파스칼 시각 객체 클래스(VOC) 데이터셋으로 20개 객체 클래스와 1만 1천 개가 넘는 이미지를 포함합니다. +- [xView](../../datasets/detect/xview.md): 상공 이미지에서 객체 탐지를 위한 데이터셋으로 60개 객체 카테고리와 100만 개가 넘는 주석이 달린 객체를 포함합니다. + +## [인스턴스 세분화 데이터셋](../../datasets/segment/index.md) + +인스턴스 세분화는 이미지 내 객체들을 픽셀 수준에서 식별하고 위치를 지정하는 컴퓨터 비전 기법입니다. + +- [COCO](../../datasets/segment/coco.md): 객체 탐지, 세분화 및 설명 작업을 위해 설계된 20만개가 넘는 레이블이 붙은 이미지로 구성된 대규모 데이터셋입니다. +- [COCO8-seg](../../datasets/segment/coco8-seg.md): 세분화 주석이 있는 8개의 COCO 이미지로 구성된 인스턴스 세분화 작업을 위한 더 작은 데이터셋입니다. + +## [자세 추정](../../datasets/pose/index.md) + +자세 추정은 카메라 또는 세계 좌표계에 대한 객체의 자세를 결정하는 기술입니다. + +- [COCO](../../datasets/pose/coco.md): 자세 추정 작업을 위해 사람의 자세 주석이 달린 대규모 데이터셋입니다. +- [COCO8-pose](../../datasets/pose/coco8-pose.md): 인간의 자세 주석이 포함된 8개의 COCO 이미지로 구성된 자세 추정 작업을 위한 더 작은 데이터셋입니다. +- [Tiger-pose](../../datasets/pose/tiger-pose.md): 자세 추정 작업을 위한 호랑이를 포함한 263개 이미지로 구성된 컴팩트한 데이터셋으로, 호랑이당 12개의 키포인트가 주석으로 표시되어 있습니다. + +## [분류](../../datasets/classify/index.md) + +이미지 분류는 이미지의 시각적 내용을 기반으로 이미지를 하나 이상의 미리 정의된 클래스나 카테고리로 분류하는 컴퓨터 비전 작업입니다. + +- [Caltech 101](../../datasets/classify/caltech101.md): 이미지 분류 작업을 위한 101개의 객체 카테고리를 포함하는 데이터셋입니다. +- [Caltech 256](../../datasets/classify/caltech256.md): Caltech 101의 확장판으로 256개의 객체 카테고리와 더 어려운 이미지를 포함합니다. +- [CIFAR-10](../../datasets/classify/cifar10.md): 각 클래스당 6천 개의 이미지를 포함하는 10개의 클래스로 구성된 60K 32x32 컬러 이미지 데이터셋입니다. +- [CIFAR-100](../../datasets/classify/cifar100.md): CIFAR-10의 확장판으로 100개의 객체 카테고리 및 클래스 당 600개 이미지를 포함합니다. +- [Fashion-MNIST](../../datasets/classify/fashion-mnist.md): 이미지 분류 작업을 위한 10개 패션 카테고리의 7만 개 그레이스케일 이미지를 포함하는 데이터셋입니다. +- [ImageNet](../../datasets/classify/imagenet.md): 객체 탐지 및 이미지 분류를 위한 1400만 개의 이미지와 2만 개의 카테고리를 포함하는 대규모 데이터셋입니다. +- [ImageNet-10](../../datasets/classify/imagenet10.md): 실험 및 테스트 속도를 높이기 위한 ImageNet의 10개 카테고리를 포함하는 더 작은 하위 집합입니다. +- [Imagenette](../../datasets/classify/imagenette.md): 훈련과 테스트를 더 빠르게 진행할 수 있도록 쉽게 구별 가능한 클래스 10개를 포함하는 ImageNet의 더 작은 하위 집합입니다. +- [Imagewoof](../../datasets/classify/imagewoof.md): 이미지 분류 작업을 위한 ImageNet의 더 어려운 하위 집합으로, 10개의 개 품종 카테고리를 포함합니다. +- [MNIST](../../datasets/classify/mnist.md): 손으로 쓴 숫자의 7만 개 그레이스케일 이미지를 포함하는 이미지 분류 작업을 위한 데이터셋입니다. + +## [지향 바운딩 박스 (OBB)](../../datasets/obb/index.md) + +지향 바운딩 박스(OBB)는 이미지 내 비스듬한 객체를 회전된 바운딩 박스를 사용하여 탐지하는 컴퓨터 비전 방법으로, 종종 항공 및 위성 영상에 적용됩니다. + +- [DOTAv2](../../datasets/obb/dota-v2.md): 170만 개 인스턴스와 1만 1천 268개 이미지를 포함하는 인기 있는 OBB 항공 이미지 데이터셋입니다. + +## [다중 객체 추적](../../datasets/track/index.md) + +다중 객체 추적은 비디오 시퀀스에서 시간에 걸쳐 여러 객체를 탐지하고 추적하는 컴퓨터 비전 기술입니다. + +- [Argoverse](../../datasets/detect/argoverse.md): 도시 환경에서의 3D 추적 및 동작 예측 데이터와 풍부한 주석으로 다중 객체 추적 작업을 위한 데이터셋입니다. +- [VisDrone](../../datasets/detect/visdrone.md): 드론으로 촬영한 영상에서 객체 탐지 및 다중 객체 추적 데이터를 포함하는 데이터셋으로 1만 개가 넘는 이미지와 비디오 시퀀스를 포함합니다. + +## 새 데이터셋 기여하기 + +새 데이터셋을 기여하는 것은 기존 인프라와 잘 조화되도록 보장하기 위해 여러 단계를 포함합니다. 아래는 필요한 단계입니다: + +### 새 데이터셋 기여를 위한 단계 + +1. **이미지 수집**: 데이터셋에 속하는 이미지를 모읍니다. 이는 공공 데이터베이스 또는 자체 수집한 자료 등 다양한 출처에서 수집할 수 있습니다. + +2. **이미지 주석 달기**: 이러한 이미지에 작업에 따라 바운딩 박스, 세그먼트 또는 키포인트로 주석을 답니다. + +3. **주석 내보내기**: 이 주석들을 Ultralytics가 지원하는 YOLO *.txt 파일 형식으로 변환합니다. + +4. **데이터셋 구성**: 데이터셋을 올바른 폴더 구조로 배열합니다. 'train/'과 'val/' 상위 디렉토리를 갖고 있어야 하며, 각각 'images/' 및 'labels/' 하위 디렉토리가 있어야 합니다. + + ``` + dataset/ + ├── train/ + │ ├── images/ + │ └── labels/ + └── val/ + ├── images/ + └── labels/ + ``` + +5. **`data.yaml` 파일 생성**: 데이터셋의 루트 디렉토리에서 데이터셋, 클래스 및 기타 필요한 정보를 설명하는 `data.yaml` 파일을 만듭니다. + +6. **이미지 최적화 (선택)**: 처리 과정을 더 효율적으로 하기 위해 데이터셋의 크기를 줄이고자 한다면 아래의 코드를 사용하여 이미지를 최적화할 수 있습니다. 필수는 아니지만, 데이터셋 크기를 작게하고 다운로드 속도를 빠르게 하는 것이 추천됩니다. + +7. **데이터셋 압축**: 전체 데이터셋 폴더를 zip 파일로 압축합니다. + +8. **문서화 및 PR**: 데이터셋에 대한 설명과 기존 프레임워크와의 적합성에 대해 설명하는 문서화 페이지를 만든 다음, 풀 리퀘스트(PR)를 제출합니다. PR을 제출하는 더 자세한 방법에 관해서는 [Ultralytics 기여 가이드라인](https://docs.ultralytics.com/help/contributing)을 참고하십시오. + +### 데이터셋 최적화 및 압축 예제 코드 + +!!! example "데이터셋 최적화 및 압축" + + === "Python" + + ```python + from pathlib import Path + from ultralytics.data.utils import compress_one_image + from ultralytics.utils.downloads import zip_directory + + # 데이터셋 디렉토리 정의 + path = Path('path/to/dataset') + + # 데이터셋의 이미지 최적화 (선택사항) + for f in path.rglob('*.jpg'): + compress_one_image(f) + + # 'path/to/dataset.zip'으로 데이터셋 압축 + zip_directory(path) + ``` + +이 단계들을 따르면 Ultralytics의 기존 구조와 잘 통합되는 새로운 데이터셋을 기여할 수 있습니다. diff --git a/docs/ko/index.md b/docs/ko/index.md new file mode 100644 index 00000000..1feed3b3 --- /dev/null +++ b/docs/ko/index.md @@ -0,0 +1,82 @@ +--- +comments: true +description: Ultralytics YOLOv8을 완벽하게 탐구하는 가이드로, 고속 및 정확성이 특징인 객체 탐지 및 이미지 분할 모델입니다. 설치, 예측, 훈련 튜토리얼 등이 포함되어 있습니다. +keywords: Ultralytics, YOLOv8, 객체 탐지, 이미지 분할, 기계 학습, 딥러닝, 컴퓨터 비전, YOLOv8 설치, YOLOv8 예측, YOLOv8 훈련, YOLO 역사, YOLO 라이센스 +--- + +
+

+ + Ultralytics YOLO 배너 +

+ Ultralytics GitHub + + Ultralytics LinkedIn + + Ultralytics Twitter + + Ultralytics YouTube + + Ultralytics TikTok + + Ultralytics Instagram + + Ultralytics Discord +
+
+ Ultralytics CI + Ultralytics 코드 커버리지 + YOLOv8 인용 + Docker 당기기 +
+ Run on Gradient + Open In Colab + Open In Kaggle +
+ +Ultralytics의 최신 버전인 [YOLOv8](https://github.com/ultralytics/ultralytics)을 소개합니다. 이 모델은 딥러닝과 컴퓨터 비전의 최신 발전을 바탕으로 구축되었으며, 속도와 정확성 면에서 뛰어난 성능을 제공합니다. 간결한 설계로 인해 다양한 애플리케이션에 적합하며, 엣지 디바이스에서부터 클라우드 API에 이르기까지 다양한 하드웨어 플랫폼에 쉽게 적응 가능합니다. + +YOLOv8 문서를 탐구하여, 그 기능과 능력을 이해하고 활용할 수 있도록 돕는 종합적인 자원입니다. 기계 학습 분야에서 경험이 많건, 새롭게 시작하는 이들이건, 이 허브는 YOLOv8의 잠재력을 극대화하기 위해 설계되었습니다. + +!!! note + + 🚧 다국어 문서는 현재 제작 중이며, 이를 개선하기 위해 노력하고 있습니다. 인내해 주셔서 감사합니다! 🙏 + +## 시작하기 + +- **설치** `ultralytics`를 pip으로 설치하고 몇 분 만에 시작하세요   [:material-clock-fast: 시작하기](quickstart.md){ .md-button } +- **예측** YOLOv8로 새로운 이미지와 비디오를 감지하세요   [:octicons-image-16: 이미지에서 예측하기](modes/predict.md){ .md-button } +- **훈련** 새로운 YOLOv8 모델을 사용자의 맞춤 데이터셋으로 훈련하세요   [:fontawesome-solid-brain: 모델 훈련하기](modes/train.md){ .md-button } +- **탐험** 세분화, 분류, 자세 인식, 추적과 같은 YOLOv8 작업   [:material-magnify-expand: 작업 탐험하기](tasks/index.md){ .md-button } + +

+
+ +
+ 시청하기: 사용자의 맞춤 데이터셋으로 YOLOv8 모델을 훈련하는 방법을 Google Colab에서 알아보세요. +

+ +## YOLO: 간단한 역사 + +[YOLO](https://arxiv.org/abs/1506.02640) (You Only Look Once, 단 한 번의 검사)는 워싱턴 대학교의 Joseph Redmon과 Ali Farhadi가 개발한 인기 있는 객체 탐지 및 이미지 분할 모델입니다. 2015년에 출시된 YOLO는 그 빠른 속도와 정확성으로 인해 빠르게 인기를 얻었습니다. + +- [YOLOv2](https://arxiv.org/abs/1612.08242)는 2016년에 공개되었으며 배치 정규화, 앵커 박스, 차원 클러스터를 통합하여 원본 모델을 개선했습니다. +- [YOLOv3](https://pjreddie.com/media/files/papers/YOLOv3.pdf)는 2018년에 출시되어 더 효율적인 백본 네트워크, 복수 앵커 및 공간 피라미드 풀링을 사용하여 모델의 성능을 더욱 향상시켰습니다. +- [YOLOv4](https://arxiv.org/abs/2004.10934)는 2020년에 나와서 모자이크 데이터 증가, 새로운 앵커-프리 탐지 헤드, 새로운 손실 함수와 같은 혁신을 도입했습니다. +- [YOLOv5](https://github.com/ultralytics/yolov5)는 모델의 성능을 더욱 향상시키고 하이퍼파라미터 최적화, 통합 실험 추적 및 인기 있는 수출 형식으로의 자동 수출과 같은 새로운 기능을 추가했습니다. +- [YOLOv6](https://github.com/meituan/YOLOv6)는 2022년에 [Meituan](https://about.meituan.com/)에 의해 오픈 소스화되었으며, 이 회사의 자율 배달 로봇에서 사용되고 있습니다. +- [YOLOv7](https://github.com/WongKinYiu/yolov7)는 COCO 키포인트 데이터셋에서의 자세 추정과 같은 추가 작업을 추가했습니다. +- [YOLOv8](https://github.com/ultralytics/ultralytics)은 Ultralytics에서 출시한 YOLO의 최신 버전입니다. 첨단 상태 기술 모델로서, YOLOv8은 이전 버전들의 성공을 기반으로 새로운 기능과 개선 사항을 도입하여 성능, 유연성 및 효율성을 향상시켰습니다. YOLOv8은 [탐지](tasks/detect.md), [분할](tasks/segment.md), [자세 추정](tasks/pose.md), [추적](modes/track.md), [분류](tasks/classify.md)를 포함하여 다양한 비전 AI 작업을 지원합니다. 이러한 다재다능함은 사용자들이 다양한 애플리케이션과 도메인 전반에 걸쳐 YOLOv8의 능력을 활용할 수 있도록 합니다. + +## YOLO 라이센스: Ultralytics YOLO는 어떻게 라이센스가 부여되나요? + +Ultralytics는 다양한 사용 사례에 맞춰 두 가지 라이선스 옵션을 제공합니다: + +- **AGPL-3.0 라이선스**: 이 [OSI 승인](https://opensource.org/licenses/) 오픈 소스 라이선스는 학생 및 애호가에게 이상적입니다. 오픈 협력과 지식 공유를 촉진합니다. 자세한 내용은 [라이선스](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) 파일을 참조하세요. +- **기업 라이선스**: 상업적 사용을 위해 설계된 이 라이선스는 Ultralytics 소프트웨어 및 AI 모델을 상업적 제품 및 서비스에 원활하게 통합할 수 있게 하여 AGPL-3.0의 오픈 소스 요건을 우회할 수 있습니다. 상업적 제공물에 솔루션을 내장하는 시나리오에 관여하는 경우 [Ultralytics 라이선싱](https://ultralytics.com/license)을 통해 문의하시기 바랍니다. + +우리의 라이선스 전략은 오픈 소스 프로젝트에 대한 개선 사항이 커뮤니티에 되돌아가도록 보장하려는 것입니다. 우리는 오픈 소스의 원칙을 가슴 깊이 새기고 있으며, 우리의 기여가 모두에게 유용한 방식으로 활용되고 확장될 수 있도록 보장하는 것이 우리의 사명입니다.❤️ diff --git a/docs/ko/models/index.md b/docs/ko/models/index.md new file mode 100644 index 00000000..5cd20962 --- /dev/null +++ b/docs/ko/models/index.md @@ -0,0 +1,94 @@ +--- +comments: true +description: Ultralytics에서 지원하는 YOLO 계열, SAM, MobileSAM, FastSAM, YOLO-NAS, RT-DETR 모델의 다양한 범위를 탐색하고 CLI 및 Python 사용 예시를 통해 시작해 보세요. +keywords: Ultralytics, 문서화, YOLO, SAM, MobileSAM, FastSAM, YOLO-NAS, RT-DETR, 모델, 아키텍처, Python, CLI +--- + +# Ultralytics에서 지원하는 모델 + +Ultralytics 모델 문서에 오신 것을 환영합니다! 저희는 [객체 검출](../tasks/detect.md), [인스턴스 분할](../tasks/segment.md), [이미지 분류](../tasks/classify.md), [자세 추정](../tasks/pose.md), [다중 객체 추적](../modes/track.md) 등 특정 작업에 맞춤화된 다양한 모델을 지원합니다. Ultralytics에 모델 아키텍처를 기여하고자 한다면, 저희의 [기여 가이드](../../help/contributing.md)를 확인해 주세요. + +!!! note + + 🚧 현재 다국어 문서화 작업이 진행 중이며 문서를 개선하기 위해 열심히 작업하고 있습니다. 기다려 주셔서 감사합니다! 🙏 + +## 주요 모델 + +여기 몇 가지 주요 모델을 소개합니다: + +1. **[YOLOv3](../../models/yolov3.md)**: Joseph Redmon에 의해 처음 제안된 YOLO 모델 계열의 세 번째 버전으로, 효율적인 실시간 객체 검출 능력으로 알려져 있습니다. +2. **[YOLOv4](../../models/yolov4.md)**: 2020년 Alexey Bochkovskiy에 의해 발표된 YOLOv3의 다크넷 기반 업데이트 버전입니다. +3. **[YOLOv5](../../models/yolov5.md)**: Ultralytics에 의해 개선된 YOLO 아키텍처 버전으로, 이전 버전들과 비교해 더 나은 성능 및 속도 저하를 제공합니다. +4. **[YOLOv6](../../models/yolov6.md)**: 2022년 [Meituan](https://about.meituan.com/)에 의해 발표되었으며, 회사의 자율 배송 로봇에 많이 사용되고 있습니다. +5. **[YOLOv7](../../models/yolov7.md)**: YOLOv4의 저자들에 의해 2022년에 발표된 업데이트된 YOLO 모델입니다. +6. **[YOLOv8](../../models/yolov8.md)**: YOLO 계열의 최신 버전으로, 인스턴스 분할, 자세/키포인트 추정 및 분류 등 향상된 기능을 제공합니다. +7. **[Segment Anything Model (SAM)](../../models/sam.md)**: Meta의 Segment Anything Model (SAM)입니다. +8. **[Mobile Segment Anything Model (MobileSAM)](../../models/mobile-sam.md)**: 경희대학교에 의한 모바일 애플리케이션용 MobileSAM입니다. +9. **[Fast Segment Anything Model (FastSAM)](../../models/fast-sam.md)**: 중국 과학원 자동화 연구소의 영상 및 비디오 분석 그룹에 의한 FastSAM입니다. +10. **[YOLO-NAS](../../models/yolo-nas.md)**: YOLO Neural Architecture Search (NAS) 모델입니다. +11. **[Realtime Detection Transformers (RT-DETR)](../../models/rtdetr.md)**: Baidu의 PaddlePaddle Realtime Detection Transformer (RT-DETR) 모델입니다. + +

+
+ +
+ 보기: 몇 줄의 코드로 Ultralytics YOLO 모델을 실행하세요. +

+ +## 시작하기: 사용 예시 + +!!! example "" + + === "Python" + + PyTorch로 사전훈련된 `*.pt` 모델과 구성 `*.yaml` 파일은 Python에서 `YOLO()`, `SAM()`, `NAS()` 및 `RTDETR()` 클래스에 전달하여 모델 인스턴스를 생성할 수 있습니다: + + ```python + from ultralytics import YOLO + + # COCO 사전훈련된 YOLOv8n 모델을 로드 + model = YOLO('yolov8n.pt') + + # 모델 정보 표시 (선택 사항) + model.info() + + # COCO8 예시 데이터셋에서 YOLOv8n 모델로 100 에포크 동안 훈련 + results = model.train(data='coco8.yaml', epochs=100, imgsz=640) + + # 'bus.jpg' 이미지에 YOLOv8n 모델로 추론 실행 + results = model('path/to/bus.jpg') + ``` + + === "CLI" + + 모델을 직접 실행하기 위한 CLI 커맨드도 제공됩니다: + + ```bash + # COCO 사전훈련된 YOLOv8n 모델을 로드하고 COCO8 예시 데이터셋에서 100 에포크 동안 훈련 + yolo train model=yolov8n.pt data=coco8.yaml epochs=100 imgsz=640 + + # COCO 사전훈련된 YOLOv8n 모델을 로드하고 'bus.jpg' 이미지에서 추론 실행 + yolo predict model=yolov8n.pt source=path/to/bus.jpg + ``` + +## 새 모델 기여하기 + +Ultralytics에 모델을 기여하고 싶으신가요? 훌륭합니다! 저희는 항상 모델 포트폴리오를 확장하는 것에 개방적입니다. + +1. **저장소를 포크하세요**: [Ultralytics GitHub 저장소](https://github.com/ultralytics/ultralytics)를 포크하며 시작하세요. + +2. **포크를 클론하세요**: 로컬 기기에 포크한 저장소를 클론하고 작업할 새 브랜치를 만드세요. + +3. **모델 구현하기**: 저희의 [기여 가이드](../../help/contributing.md)에 제시된 코딩 표준과 가이드라인을 따라 모델을 추가하세요. + +4. **철저히 테스트하기**: 파이프라인의 일부로서 뿐만 아니라 독립적으로도 모델을 철저히 테스트하세요. + +5. **풀 리퀘스트 생성하기**: 모델에 만족하게 되면, 리뷰를 위해 메인 저장소로 풀 리퀘스트를 생성하세요. + +6. **코드 리뷰 및 병합**: 리뷰 이후, 모델이 저희의 기준을 만족한다면 메인 저장소로 병합될 것입니다. + +자세한 단계는 저희의 [기여 가이드](../../help/contributing.md)를 참조하세요. diff --git a/docs/ko/modes/benchmark.md b/docs/ko/modes/benchmark.md new file mode 100644 index 00000000..6aa300f0 --- /dev/null +++ b/docs/ko/modes/benchmark.md @@ -0,0 +1,94 @@ +--- +comments: true +description: YOLOv8의 다양한 내보내기 형식에 걸쳐 속도 및 정확성을 프로파일링하는 방법을 알아보고, mAP50-95, accuracy_top5 메트릭 및 기타에 대한 통찰을 얻으십시오. +keywords: Ultralytics, YOLOv8, 벤치마킹, 속도 프로파일링, 정확도 프로파일링, mAP50-95, accuracy_top5, ONNX, OpenVINO, TensorRT, YOLO 내보내기 형식 +--- + +# Ultralytics YOLO를 사용한 모델 벤치마킹 + +Ultralytics YOLO 생태계 및 통합 + +## 소개 + +모델을 학습하고 검증한 후, 다음으로 논리적인 단계는 다양한 실제 상황에서의 성능을 평가하는 것입니다. Ultralytics YOLOv8의 벤치마크 모드는 다양한 내보내기 형식에서 모델의 속도와 정확도를 평가하는 강력한 프레임워크를 제공하여 이와 같은 목적을 수행하는 역할을 합니다. + +## 벤치마킹이 왜 중요한가요? + +- **정보에 기반한 결정:** 속도와 정확도 사이의 타협점에 대한 통찰력을 얻을 수 있습니다. +- **자원 배분:** 다양한 하드웨어에서 각기 다른 내보내기 형식의 성능을 이해합니다. +- **최적화:** 특정 사용 사례에 가장 적합한 내보내기 형식을 알아냅니다. +- **비용 효율성:** 벤치마크 결과에 기반하여 하드웨어 자원을 보다 효율적으로 사용합니다. + +### 벤치마크 모드의 주요 메트릭 + +- **mAP50-95:** 객체 인식, 세분화, 자세 추정에 사용됩니다. +- **accuracy_top5:** 이미지 분류에 사용됩니다. +- **추론 시간:** 각 이미지 당 밀리초로 측정된 시간입니다. + +### 지원되는 내보내기 형식 + +- **ONNX:** CPU 성능 최적화를 위함 +- **TensorRT:** GPU 효율성을 극대화하기 위함 +- **OpenVINO:** 인텔 하드웨어 최적화를 위함 +- **CoreML, TensorFlow SavedModel, 그 외:** 다양한 배포 요구 사항을 위함. + +!!! 팁 "팁" + + * CPU 속도 향상을 위해 ONNX 또는 OpenVINO로 내보내기. + * GPU 속도 향상을 위해 TensorRT로 내보내기. + +## 사용 예제 + +YOLOv8n 벤치마킹을 ONNX, TensorRT 등 모든 지원되는 내보내기 형식에 대해 실행합니다. 완벽한 내보내기 인수 목록을 보려면 아래의 인수 섹션을 참조하세요. + +!!! 예제 "" + + === "파이썬" + + ```python + from ultralytics.utils.benchmarks import benchmark + + # GPU에서 벤치마킹 + benchmark(model='yolov8n.pt', data='coco8.yaml', imgsz=640, half=False, device=0) + ``` + === "CLI" + + ```bash + yolo benchmark model=yolov8n.pt data='coco8.yaml' imgsz=640 half=False device=0 + ``` + +## 인수 + +`model`, `data`, `imgsz`, `half`, `device`, `verbose`와 같은 인수들은 사용자들이 벤치마킹을 특정 필요에 맞게 조정하고 쉽게 다른 내보내기 형식의 성능을 비교할 수 있도록 유연성을 제공합니다. + +| 키 | 값 | 설명 | +|-----------|---------|----------------------------------------------------------| +| `model` | `None` | 모델 파일 경로, 예: yolov8n.pt, yolov8n.yaml | +| `data` | `None` | 벤치마킹 데이터 세트를 참조하는 YAML 경로 ('val' 레이블 아래) | +| `imgsz` | `640` | 스칼라 또는 (h, w) 리스트 형태의 이미지 크기, 예: (640, 480) | +| `half` | `False` | FP16 양자화 | +| `int8` | `False` | INT8 양자화 | +| `device` | `None` | 실행할 기기, 예: CUDA device=0 혹은 device=0,1,2,3 또는 device=cpu | +| `verbose` | `False` | 오류 시 계속하지 않음 (bool), 또는 val 하한 임계값 (float) | + +## 내보내기 형식 + +벤치마크는 아래에 나와있는 가능한 모든 내보내기 형식에서 자동으로 실행을 시도합니다. + +| 형식 | `format` 인자 | 모델 | 메타데이터 | 인수 | +|--------------------------------------------------------------------|---------------|---------------------------|-------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | ✅ | `imgsz`, `half` | + +전체 `export` 세부 정보는 [Export](https://docs.ultralytics.com/modes/export/) 페이지에서 확인할 수 있습니다. diff --git a/docs/ko/modes/export.md b/docs/ko/modes/export.md new file mode 100644 index 00000000..7068d418 --- /dev/null +++ b/docs/ko/modes/export.md @@ -0,0 +1,108 @@ +--- +comments: true +description: YOLOv8 모델을 ONNX, TensorRT, CoreML 등의 다양한 형식으로 내보내는 단계별 가이드를 확인해보세요. 이제 배포를 진행해보세요!. +keywords: YOLO, YOLOv8, Ultralytics, 모델 내보내기, ONNX, TensorRT, CoreML, TensorFlow SavedModel, OpenVINO, PyTorch, 모델 내보내기 +--- + +# Ultralytics YOLO를 사용한 모델 내보내기 + +Ultralytics YOLO 생태계 및 통합 + +## 소개 + +모델을 훈련하는 최종 목적은 실제 환경에서 배포하기 위함입니다. Ultralytics YOLOv8의 내보내기 모드는 훈련된 모델을 다양한 형식으로 내보내어 여러 플랫폼과 디바이스에서 배포할 수 있는 범용적인 옵션을 제공합니다. 이 포괄적인 가이드는 모델 내보내기의 미묘한 점들을 설명하고 최대의 호환성과 성능을 달성하는 방법을 안내하는 것을 목표로 합니다. + +

+
+ +
+ 시청하기: 사용자 지정 훈련된 Ultralytics YOLOv8 모델을 내보내고 웹캠에서 실시간 추론을 실행하는 방법. +

+ +## YOLOv8의 내보내기 모드를 선택해야 하는 이유는 무엇인가요? + +- **범용성:** ONNX, TensorRT, CoreML 등 다양한 형식으로 내보낼 수 있습니다. +- **성능:** TensorRT를 사용할 경우 최대 5배 빠른 GPU 속도 향상 및 ONNX 또는 OpenVINO를 사용하여 최대 3배 빠른 CPU 속도 향상을 얻을 수 있습니다. +- **호환성:** 모델을 다양한 하드웨어 및 소프트웨어 환경에서 배포할 수 있도록 만들어줍니다. +- **사용의 용이성:** 모델 내보내기를 위한 간단한 CLI 및 Python API 제공. + +### 내보내기 모드의 주요 기능 + +다음은 몇 가지 주요 기능들입니다: + +- **원클릭 내보내기:** 다양한 형식으로 내보내기 위한 간단한 명령어. +- **배치 내보내기:** 배치 추론이 가능한 모델들을 내보낼 수 있습니다. +- **최적화된 추론:** 내보낸 모델들은 더 빠른 추론 시간을 위해 최적화되어 있습니다. +- **튜토리얼 비디오:** 원활한 내보내기 경험을 위한 심도 있는 가이드 및 튜토리얼. + +!!! 팁 "팁" + + * CPU 속도 향상을 위해 ONNX 또는 OpenVINO로 내보내세요. + * GPU 속도 향상을 위해 TensorRT로 내보내세요. + +## 사용 예시 + +YOLOv8n 모델을 ONNX나 TensorRT와 같은 다른 형식으로 내보냅니다. 내보내기 인수에 대한 전체 목록은 아래 '인수' 섹션을 참조하세요. + +!!! 예시 "" + + === "Python" + + ```python + from ultralytics import YOLO + + # 모델을 불러오기 + model = YOLO('yolov8n.pt') # 공식 모델을 불러오기 + model = YOLO('path/to/best.pt') # 사용자 지정 훈련 모델을 불러오기 + + # 모델을 내보내기 + model.export(format='onnx') + ``` + === "CLI" + + ```bash + yolo export model=yolov8n.pt format=onnx # 공식 모델을 내보내기 + yolo export model=path/to/best.pt format=onnx # 사용자 지정 훈련 모델을 내보내기 + ``` + +## 인수 + +YOLO 모델의 내보내기 설정은 다른 환경이나 플랫폼에서 모델을 사용하기 위해 저장 또는 내보내기할 때 사용하는 다양한 구성 및 옵션을 의미합니다. 이러한 설정은 모델의 성능, 크기 및 다양한 시스템과의 호환성에 영향을 미칠 수 있습니다. 일반적인 YOLO 내보내기 설정에는 내보낸 모델 파일의 형식(예: ONNX, TensorFlow SavedModel), 모델이 실행될 장치(예: CPU, GPU) 및 마스크 또는 상자당 여러 라벨과 같은 추가 기능의 포함 여부 등이 있습니다. 모델이 사용되는 특정 작업과 대상 환경 또는 플랫폼의 요구 사항이나 제약 사항에 따라 내보내기 과정에 영향을 미치는 다른 요소들도 있을 수 있습니다. 내보낸 모델이 의도한 용도로 최적화되어 있고 대상 환경에서 효과적으로 사용할 수 있도록 이러한 설정을 세심하게 고려하고 구성하는 것이 중요합니다. + +| 키 | 값 | 설명 | +|-------------|-----------------|---------------------------------------------| +| `format` | `'torchscript'` | 내보낼 형식 | +| `imgsz` | `640` | 스칼라 또는 (h, w) 리스트 형식의 이미지 크기, 예: (640, 480) | +| `keras` | `False` | TF SavedModel 내보내기에 Keras 사용 | +| `optimize` | `False` | TorchScript: 모바일 최적화 | +| `half` | `False` | FP16 양자화 | +| `int8` | `False` | INT8 양자화 | +| `dynamic` | `False` | ONNX/TensorRT: 동적 축 | +| `simplify` | `False` | ONNX/TensorRT: 모델 단순화 | +| `opset` | `None` | ONNX: opset 버전 (선택적, 기본값은 최신) | +| `workspace` | `4` | TensorRT: 작업공간 크기 (GB) | +| `nms` | `False` | CoreML: NMS 추가 | + +## 내보내기 형식 + +아래 표에는 사용 가능한 YOLOv8 내보내기 형식이 나와 있습니다. `format` 인수를 사용하여 어떤 형식으로든 내보낼 수 있습니다. 예: `format='onnx'` 또는 `format='engine'`. + +| 형식 | `format` 인수 | 모델 | 메타데이터 | 인수 | +|--------------------------------------------------------------------|---------------|---------------------------|-------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | ✅ | `imgsz`, `half` | diff --git a/docs/ko/modes/index.md b/docs/ko/modes/index.md new file mode 100644 index 00000000..4d4c7c1e --- /dev/null +++ b/docs/ko/modes/index.md @@ -0,0 +1,73 @@ +--- +comments: true +description: YOLOv8를 통해 트레이닝부터 추적까지, Ultralytics에 최적화된 모든 기능을 활용하세요. 지원되는 각 모드에 대한 통찰력과 예시를 포함하여 검증, 내보내기, 벤치마킹까지 이해하실 수 있습니다. +keywords: Ultralytics, YOLOv8, 머신러닝, 객체탐지, 트레이닝, 검증, 예측, 내보내기, 추적, 벤치마킹 +--- + +# Ultralytics YOLOv8 모드 + +Ultralytics YOLO 생태계 및 통합 + +## 서론 + +Ultralytics YOLOv8는 단순한 객체 탐지 모델이 아닙니다; 데이터 수집에서 모델 트레이닝, 검증, 배포, 실세계 추적에 이르기까지 머신러닝 모델의 전체 생애주기를 커버하기 위해 설계된 다재다능한 프레임워크입니다. 각각의 모드는 특정 목적을 위해 섬세하게 구성되며, 다양한 작업 및 사용 사례에 필요한 유연성과 효율성을 제공합니다. + +

+
+ +
+ 시청하기: Ultralytics 모드 튜토리얼: 트레이닝, 검증, 예측, 내보내기 및 벤치마킹. +

+ +### 모드 요약 + +YOLOv8이 지원하는 **모드**를 이해하는 것은 모델을 최대한 활용하기 위해 필수적입니다: + +- **Train** 모드: 사용자 맞춤 또는 사전 로드된 데이터셋 위에서 모델을 튜닝합니다. +- **Val** 모드: 트레이닝 후 모델 성능을 검증하기 위한 체크포인트. +- **Predict** 모드: 실세계 데이터에서 모델의 예측력을 발휘합니다. +- **Export** 모드: 다양한 포맷으로 모델을 배포 준비 상태로 만듭니다. +- **Track** 모드: 객체 탐지 모델을 실시간 추적 애플리케이션으로 확장합니다. +- **Benchmark** 모드: 다양한 배포 환경에서 모델의 속도와 정확도를 분석합니다. + +이 포괄적인 가이드는 각 모드에 대한 개요와 실제 인사이트를 제공하여 YOLOv8의 전체 잠재력을 활용할 수 있도록 도와줍니다. + +## [Train](train.md) + +Train 모드는 사용자 맞춤 데이터셋 위에서 YOLOv8 모델을 트레이닝하기 위해 사용됩니다. 이 모드에서는 지정된 데이터셋과 하이퍼파라미터를 사용하여 모델을 트레이닝합니다. 트레이닝 과정에서 모델의 파라미터를 최적화하여 이미지 내 객체의 클래스와 위치를 정확히 예측할 수 있도록 합니다. + +[Train 예시](train.md){ .md-button .md-button--primary} + +## [Val](val.md) + +Val 모드는 트레이닝된 YOLOv8 모델을 검증하기 위해 사용됩니다. 이 모드에서는 모델을 검증 세트에서 평가하여 정확도 및 일반화 성능을 측정합니다. 이 모드는 모델의 하이퍼파라미터를 조정하고 성능을 개선하는데 사용할 수 있습니다. + +[Val 예시](val.md){ .md-button .md-button--primary} + +## [Predict](predict.md) + +Predict 모드는 트레이닝된 YOLOv8 모델을 사용하여 새 이미지 또는 비디오에서 예측을 수행하기 위해 사용됩니다. 이 모드에서는 체크포인트 파일에서 모델을 로드하고, 사용자가 이미지나 비디오를 제공하여 추론을 수행합니다. 모델은 입력 이미지 또는 비디오에서 객체의 클래스와 위치를 예측합니다. + +[Predict 예시](predict.md){ .md-button .md-button--primary} + +## [Export](export.md) + +Export 모드는 배포를 위해 YOLOv8 모델을 내보낼 수 있는 포맷으로 변환하기 위해 사용됩니다. 이 모드에서는 모델을 다른 소프트웨어 어플리케이션 또는 하드웨어 기기에서 사용할 수 있는 포맷으로 변환합니다. 이 모드는 모델을 생산 환경으로 배포하는데 유용합니다. + +[Export 예시](export.md){ .md-button .md-button--primary} + +## [Track](track.md) + +Track 모드는 실시간으로 YOLOv8 모델을 사용하여 객체를 추적하기 위해 사용됩니다. 이 모드에서는 체크포인트 파일에서 모델을 로드하고, 사용자가 실시간 비디오 스트림을 제공하여 실시간 객체 추적을 수행합니다. 이 모드는 감시 시스템이나 자율 주행 차량 같은 애플리케이션에 유용합니다. + +[Track 예시](track.md){ .md-button .md-button--primary} + +## [Benchmark](benchmark.md) + +Benchmark 모드는 YOLOv8의 다양한 내보내기 포맷에 대한 속도와 정확도를 프로파일링하기 위해 사용됩니다. 벤치마크는 내보낸 포맷의 크기, 그리고 객체 탐지, 세분화 및 포즈에 대한 `mAP50-95` 메트릭 또는 분류에 대한 `accuracy_top5` 메트릭, 그리고 ONNX, OpenVINO, TensorRT 등 다양한 내보내기 포맷에서의 이미지당 추론 시간을 밀리초로 제공합니다. 이 정보는 속도와 정확도에 대한 특정 사용 사례 요구 사항에 기반하여 최적의 내보내기 포맷을 선택하는 데 도움이 될 수 있습니다. + +[Benchmark 예시](benchmark.md){ .md-button .md-button--primary} diff --git a/docs/ko/modes/predict.md b/docs/ko/modes/predict.md new file mode 100644 index 00000000..825757d7 --- /dev/null +++ b/docs/ko/modes/predict.md @@ -0,0 +1,227 @@ +--- +comments: true +description: YOLOv8 예측 모드를 사용하여 다양한 작업을 수행하는 방법을 알아보십시오. 이미지, 비디오 및 데이터 형식과 같은 다양한 추론 소스에 대해 자세히 알아봅니다. +keywords: Ultralytics, YOLOv8, 예측 모드, 추론 소스, 예측 작업, 스트리밍 모드, 이미지 처리, 비디오 처리, 머신 러닝, AI +--- + +# Ultralytics YOLO로 모델 예측 + +Ultralytics YOLO 생태계와 통합 + +## 소개 + +머신 러닝 및 컴퓨터 비전의 세계에서 시각적 데이터를 해석하는 과정을 '추론' 또는 '예측'이라고 합니다. Ultralytics YOLOv8는 다양한 데이터 소스에서의 고성능, 실시간 추론을 위해 맞춤화된 강력한 기능인 **예측 모드**를 제공합니다. + +

+
+ +
+ 시청: Ultralytics YOLOv8 모델에서 출력을 추출하여 맞춤 프로젝트에 사용하는 방법. +

+ +## 실제 응용 분야 + +| 제조업 | 스포츠 | 안전 | +|:-----------------------------------------------------------------------------------------------------------------:|:--------------------------------------------------------------------------------------------------------------:|:---------------------------------------------------------------------------------------------------------------:| +| ![차량 예비 부품 탐지](https://github.com/RizwanMunawar/ultralytics/assets/62513924/a0f802a8-0776-44cf-8f17-93974a4a28a1) | ![축구 선수 탐지](https://github.com/RizwanMunawar/ultralytics/assets/62513924/7d320e1f-fc57-4d7f-a691-78ee579c3442) | ![사람 넘어짐 탐지](https://github.com/RizwanMunawar/ultralytics/assets/62513924/86437c4a-3227-4eee-90ef-9efb697bdb43) | +| 차량 예비 부품 탐지 | 축구 선수 탐지 | 사람 넘어짐 탐지 | + +## 예측 인퍼런스를 위해 Ultralytics YOLO 사용하기 + +다음은 YOLOv8의 예측 모드를 다양한 추론 요구 사항에 사용해야 하는 이유입니다: + +- **다양성:** 이미지, 비디오, 심지어 실시간 스트림에 대한 추론을 수행할 수 있습니다. +- **성능:** 정확성을 희생하지 않고 실시간, 고속 처리를 위해 설계되었습니다. +- **사용 편의성:** 빠른 배포 및 테스트를 위한 직관적인 Python 및 CLI 인터페이스를 제공합니다. +- **고도의 사용자 정의:** 특정 요구 사항에 맞게 모델의 추론 행동을 조율하기 위한 다양한 설정 및 매개변수를 제공합니다. + +### 예측 모드의 주요 기능 + +YOLOv8의 예측 모드는 강력하고 다재다능하게 설계되었으며, 다음과 같은 특징을 갖고 있습니다: + +- **다중 데이터 소스 호환성:** 데이터가 개별 이미지, 이미지 컬렉션, 비디오 파일 또는 실시간 비디오 스트림의 형태로 존재하는지 여부에 관계없이 예측 모드가 지원합니다. +- **스트리밍 모드:** `Results` 객체의 메모리 효율적인 생성자로 스트리밍 기능을 사용합니다. 예측기의 호출 메서드에서 `stream=True`로 설정하여 활성화합니다. +- **배치 처리:** 단일 배치에서 여러 이미지 또는 비디오 프레임을 처리하는 기능을 통해 추론 시간을 더욱 단축합니다. +- **통합 친화적:** 유연한 API 덕분에 기존 데이터 파이프라인 및 기타 소프트웨어 구성 요소와 쉽게 통합할 수 있습니다. + +Ultralytics YOLO 모델은 Python `Results` 객체의 리스트를 반환하거나, 추론 중 `stream=True`가 모델에 전달될 때 `Results` 객체의 메모리 효율적인 Python 생성자를 반환합니다: + +!!! 예시 "예측" + + === "`stream=False`로 리스트 반환" + ```python + from ultralytics import YOLO + + # 모델 로드 + model = YOLO('yolov8n.pt') # 사전 훈련된 YOLOv8n 모델 + + # 이미지 리스트에 대한 배치 추론 실행 + results = model(['im1.jpg', 'im2.jpg']) # Results 객체의 리스트 반환 + + # 결과 리스트 처리 + for result in results: + boxes = result.boxes # bbox 출력을 위한 Boxes 객체 + masks = result.masks # 세그멘테이션 마스크 출력을 위한 Masks 객체 + keypoints = result.keypoints # 자세 출력을 위한 Keypoints 객체 + probs = result.probs # 분류 출력을 위한 Probs 객체 + ``` + + === "`stream=True`로 생성자 반환" + ```python + from ultralytics import YOLO + + # 모델 로드 + model = YOLO('yolov8n.pt') # 사전 훈련된 YOLOv8n 모델 + + # 이미지 리스트에 대한 배치 추론 실행 + results = model(['im1.jpg', 'im2.jpg'], stream=True) # Results 객체의 생성자 반환 + + # 결과 생성자 처리 + for result in results: + boxes = result.boxes # bbox 출력을 위한 Boxes 객체 + masks = result.masks # 세그멘테이션 마스크 출력을 위한 Masks 객체 + keypoints = result.keypoints # 자세 출력을 위한 Keypoints 객체 + probs = result.probs # 분류 출력을 위한 Probs 객체 + ``` + +## 추론 소스 + +YOLOv8은 아래 표에 표시된 바와 같이 추론을 위한 다양한 유형의 입력 소스를 처리할 수 있습니다. 소스에는 정적 이미지, 비디오 스트림, 다양한 데이터 형식이 포함됩니다. 표는 또한 각 소스를 'stream=True' ✅와 함께 스트리밍 모드에서 사용할 수 있는지 여부를 나타냅니다. 스트리밍 모드는 비디오나 라이브 스트림을 처리할 때 결과를 메모리에 모두 로드하는 대신 결과의 생성자를 만들어 유용하게 사용됩니다. + +!!! 팁 "팁" + + 긴 비디오나 큰 데이터 세트를 처리할 때 'stream=True'를 사용하여 효율적으로 메모리를 관리합니다. 'stream=False'일 때는 모든 프레임 또는 데이터 포인트에 대한 결과가 메모리에 저장되어, 입력이 크면 메모리 부족 오류를 빠르게 유발할 수 있습니다. 반면에, 'stream=True'는 생성자를 사용하여 현재 프레임 또는 데이터 포인트의 결과만 메모리에 유지하여 메모리 소비를 크게 줄이고 메모리 부족 문제를 방지합니다. + +| 소스 | 인수 | 유형 | 비고 | +|-----------|--------------------------------------------|-----------------|--------------------------------------------------------------------------| +| 이미지 | `'image.jpg'` | `str` 또는 `Path` | 단일 이미지 파일. | +| URL | `'https://ultralytics.com/images/bus.jpg'` | `str` | 이미지 URL. | +| 스크린샷 | `'screen'` | `str` | 스크린샷을 캡처합니다. | +| PIL | `Image.open('im.jpg')` | `PIL.Image` | HWC 형식으로 RGB 채널이 있습니다. | +| OpenCV | `cv2.imread('im.jpg')` | `np.ndarray` | HWC 형식으로 BGR 채널이 있고 `uint8 (0-255)` 입니다. | +| numpy | `np.zeros((640,1280,3))` | `np.ndarray` | HWC 형식으로 BGR 채널이 있고 `uint8 (0-255)` 입니다. | +| torch | `torch.zeros(16,3,320,640)` | `torch.Tensor` | BCHW 형식으로 RGB 채널이 있고 `float32 (0.0-1.0)` 입니다. | +| CSV | `'sources.csv'` | `str` 또는 `Path` | 이미지, 비디오 또는 디렉토리 경로가 있는 CSV 파일. | +| 비디오 ✅ | `'video.mp4'` | `str` 또는 `Path` | MP4, AVI 등과 같은 형식의 비디오 파일입니다. | +| 디렉토리 ✅ | `'path/'` | `str` 또는 `Path` | 이미지나 비디오가 있는 디렉토리 경로입니다. | +| 글로브 ✅ | `'path/*.jpg'` | `str` | 여러 파일에 일치하는 글로브 패턴입니다. '*' 문자를 와일드카드로 사용하세요. | +| YouTube ✅ | `'https://youtu.be/LNwODJXcvt4'` | `str` | YouTube 비디오의 URL입니다. | +| 스트림 ✅ | `'rtsp://example.com/media.mp4'` | `str` | RTSP, RTMP, TCP 또는 IP 주소와 같은 스트리밍 프로토콜의 URL입니다. | +| 멀티-스트림 ✅ | `'list.streams'` | `str` 또는 `Path` | 스트림 URL이 행당 하나씩 있는 `*.streams` 텍스트 파일이며, 예를 들어 8개의 스트림은 배치 크기 8에서 실행됩니다. | + +아래는 각 유형의 소스를 사용하는 코드 예제입니다: + +!!! 예시 "예측 소스" + + === "이미지" + 이미지 파일에서 추론을 실행합니다. + ```python + from ultralytics import YOLO + + # 사전 훈련된 YOLOv8n 모델 로드 + model = YOLO('yolov8n.pt') + + # 이미지 파일 경로 정의 + source = 'path/to/image.jpg' + + # 소스에서 추론 실행 + results = model(source) # Results 객체의 리스트 + ``` + + === "스크린샷" + 현재 스크린 콘텐츠를 스크린샷으로 추론을 실행합니다. + ```python + from ultralytics import YOLO + + # 사전 훈련된 YOLOv8n 모델 로드 + model = YOLO('yolov8n.pt') + + # 현재 스크린샷을 소스로 정의 + source = 'screen' + + # 소스에서 추론 실행 + results = model(source) # Results 객체의 리스트 + ``` + + === "URL" + URL을 통해 원격으로 호스팅되는 이미지나 비디오에서 추론을 실행합니다. + ```python + from ultralytics import YOLO + + # 사전 훈련된 YOLOv8n 모델 로드 + model = YOLO('yolov8n.pt') + + # 원격 이미지나 동영상 URL 정의 + source = 'https://ultralytics.com/images/bus.jpg' + + # 소스에서 추론 실행 + results = model(source) # Results 객체의 리스트 + ``` + + === "PIL" + Python Imaging Library (PIL)로 열린 이미지에서 추론을 실행합니다. + ```python + from PIL import Image + from ultralytics import YOLO + + # 사전 훈련된 YOLOv8n 모델 로드 + model = YOLO('yolov8n.pt') + + # PIL을 사용하여 이미지 열기 + source = Image.open('path/to/image.jpg') + + # 소스에서 추론 실행 + results = model(source) # Results 객체의 리스트 + ``` + + === "OpenCV" + OpenCV로 읽은 이미지에서 추론을 실행합니다. + ```python + import cv2 + from ultralytics import YOLO + + # 사전 훈련된 YOLOv8n 모델 로드 + model = YOLO('yolov8n.pt') + + # OpenCV를 사용하여 이미지 읽기 + source = cv2.imread('path/to/image.jpg') + + # 소스에서 추론 실행 + results = model(source) # Results 객체의 리스트 + ``` + + === "numpy" + numpy 배열로 표현된 이미지에서 추론을 실행합니다. + ```python + import numpy as np + from ultralytics import YOLO + + # 사전 훈련된 YOLOv8n 모델 로드 + model = YOLO('yolov8n.pt') + + # 무작위 numpy 배열 생성, HWC 형태 (640, 640, 3), 값 범위 [0, 255], 타입 uint8 + source = np.random.randint(low=0, high=255, size=(640, 640, 3), dtype='uint8') + + # 소스에서 추론 실행 + results = model(source) # Results 객체의 리스트 + ``` + + === "torch" + PyTorch 텐서로 표현된 이미지에서 추론을 실행합니다. + ```python + import torch + from ultralytics import YOLO + + # 사전 훈련된 YOLOv8n 모델 로드 + model = YOLO('yolov8n.pt') + + # 무작위 torch 텐서 생성, BCHW 형태 (1, 3, 640, 640), 값 범위 [0, 1], 타입 float32 + source = torch.rand(1, 3, 640, 640, dtype=torch.float32) + + # 소스에서 추론 실행 + results = model(source) # Results 객체의 리스트 + ``` diff --git a/docs/ko/modes/track.md b/docs/ko/modes/track.md new file mode 100644 index 00000000..73f2cca3 --- /dev/null +++ b/docs/ko/modes/track.md @@ -0,0 +1,256 @@ +--- +comments: true +description: Ultralytics YOLO를 사용하여 비디오 스트림에서 객체 추적을 사용하는 방법을 알아보세요. 다양한 추적기를 사용하는 안내와 추적기 구성을 맞춤 설정하는 방법에 대한 가이드가 있습니다. +keywords: Ultralytics, YOLO, 객체 추적, 비디오 스트림, BoT-SORT, ByteTrack, 파이썬 가이드, CLI 가이드 +--- + +# Ultralytics YOLO를 이용한 다중 객체 추적 + +다중 객체 추적 예시 + +비디오 분석의 영역에서 객체 추적은 프레임 내에서 객체의 위치와 클래스를 식별할 뿐만 아니라 비디오가 진행됨에 따라 각각의 검출된 객체에 대해 고유 ID를 유지하는 중요한 작업입니다. 응용 프로그램은 감시 및 보안에서 실시간 스포츠 분석에 이르기까지 무한합니다. + +## 객체 추적을 위해 Ultralytics YOLO를 선택해야 하는 이유는? + +Ultralytics 추적기의 출력은 표준 객체 검출과 일관되지만 객체 ID가 추가된 가치가 있습니다. 이를 통해 비디오 스트림에서 객체를 추적하고 이후 분석을 수행하기가 쉽습니다. 여기에 어떤 이유로 Ultralytics YOLO를 사용해야 하는지에 대해 설명합니다: + +- **효율성:** 정확성을 저하시키지 않으면서 실시간으로 비디오 스트림을 처리합니다. +- **유연성:** 다양한 추적 알고리즘과 구성을 지원합니다. +- **사용하기 쉬움:** 간단한 파이썬 API 및 CLI 옵션으로 빠른 통합 및 배치가 가능합니다. +- **맞춤 설정:** 맞춤 학습된 YOLO 모델과 함께 사용하기 쉬워 특정 도메인 응용 프로그램에 통합할 수 있습니다. + +

+
+ +
+ 시청하기: Ultralytics YOLOv8로 객체 감지 및 추적하기. +

+ +## 실제 세계 응용 프로그램 + +| 교통수단 | 소매업 | 수산업 | +|:-----------------------------------------------------------------------------------------------------------:|:-----------------------------------------------------------------------------------------------------------:|:------------------------------------------------------------------------------------------------------------:| +| ![차량 추적](https://github.com/RizwanMunawar/ultralytics/assets/62513924/ee6e6038-383b-4f21-ac29-b2a1c7d386ab) | ![사람 추적](https://github.com/RizwanMunawar/ultralytics/assets/62513924/93bb4ee2-77a0-4e4e-8eb6-eb8f527f0527) | ![물고기 추적](https://github.com/RizwanMunawar/ultralytics/assets/62513924/a5146d0f-bfa8-4e0a-b7df-3c1446cd8142) | +| 차량 추적 | 사람 추적 | 물고기 추적 | + +## 한눈에 보기 + +Ultralytics YOLO는 객체 감지 기능을 확장하여 견고하고 다재다능한 객체 추적을 제공합니다: + +- **실시간 추적:** 고화면률의 비디오에서 매끄럽게 객체 추적합니다. +- **다중 추적기 지원:** 다양한 검증된 추적 알고리즘 중에서 선택 가능합니다. +- **맞춤형 추적기 구성:** 다양한 매개변수를 조정하여 특정 요구사항에 맞게 추적 알고리즘을 맞춤화할 수 있습니다. + +## 사용 가능한 추적기 + +Ultralytics YOLO는 다음과 같은 추적 알고리즘을 지원합니다. 관련 YAML 구성 파일(예: `tracker=tracker_type.yaml`)을 전달하여 사용할 수 있습니다: + +* [BoT-SORT](https://github.com/NirAharon/BoT-SORT) - 이 추적기를 활성화하려면 `botsort.yaml`을 사용합니다. +* [ByteTrack](https://github.com/ifzhang/ByteTrack) - 이 추적기를 활성화하려면 `bytetrack.yaml`을 사용합니다. + +기본 추적기는 BoT-SORT입니다. + +## 추적 + +비디오 스트림에서 추적기를 실행하려면 YOLOv8n, YOLOv8n-seg 및 YOLOv8n-pose와 같은 훈련된 Detect, Segment 또는 Pose 모델을 사용하십시오. + +!!! 예시 "" + + === "파이썬" + + ```python + from ultralytics import YOLO + + # 공식 모델 또는 맞춤 모델을 불러오기 + model = YOLO('yolov8n.pt') # 공식 Detect 모델 불러오기 + model = YOLO('yolov8n-seg.pt') # 공식 Segment 모델 불러오기 + model = YOLO('yolov8n-pose.pt') # 공식 Pose 모델 불러오기 + model = YOLO('path/to/best.pt') # 맞춤 학습된 모델 불러오기 + + # 모델을 사용하여 추적 수행 + results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True) # 기본 추적기로 추적하기 + results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml") # ByteTrack 추적기로 추적하기 + ``` + + === "CLI" + + ```bash + # 명령 행 인터페이스를 사용하여 다양한 모델로 추적 수행 + yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" # 공식 Detect 모델 + yolo track model=yolov8n-seg.pt source="https://youtu.be/LNwODJXcvt4" # 공식 Segment 모델 + yolo track model=yolov8n-pose.pt source="https://youtu.be/LNwODJXcvt4" # 공식 Pose 모델 + yolo track model=path/to/best.pt source="https://youtu.be/LNwODJXcvt4" # 맞춤 학습된 모델 + + # ByteTrack 추적기를 사용하여 추적하기 + yolo track model=path/to/best.pt tracker="bytetrack.yaml" + ``` + +위의 사용법에서 볼 수 있듯이 모든 Detect, Segment 및 Pose 모델은 비디오나 스트리밍 출처에서 추적이 가능합니다. + +## 구성 + +### 추적 인수 + +추적 구성은 `conf`, `iou` 및 `show`와 같은 예측 모드와 동일한 속성을 공유합니다. 추가 구성에 대해서는 [Predict](https://docs.ultralytics.com/modes/predict/) 모델 페이지를 참조하십시오. + +!!! 예시 "" + + === "파이썬" + + ```python + from ultralytics import YOLO + + # 추적 매개변수를 구성하고 추적기를 실행합니다 + model = YOLO('yolov8n.pt') + results = model.track(source="https://youtu.be/LNwODJXcvt4", conf=0.3, iou=0.5, show=True) + ``` + + === "CLI" + + ```bash + # 추적 매개변수를 구성하고 명령 행 인터페이스를 사용하여 추적기를 실행합니다 + yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" conf=0.3, iou=0.5 show + ``` + +### 추적기 선택 + +Ultralytics에서는 수정된 추적기 구성 파일도 사용할 수 있습니다. 이를 위해 [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers)에서 추적기 구성 파일의 복사본(예: `custom_tracker.yaml`)을 만들고 필요한대로 구성을 수정하면 됩니다(단, `tracker_type` 제외). + +!!! 예시 "" + + === "파이썬" + + ```python + from ultralytics import YOLO + + # 모델을 불러오고 맞춤 구성 파일로 추적기를 실행합니다 + model = YOLO('yolov8n.pt') + results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker='custom_tracker.yaml') + ``` + + === "CLI" + + ```bash + # 명령 행 인터페이스를 사용하여 맞춤 구성 파일로 모델을 불러오고 추적기를 실행합니다 + yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" tracker='custom_tracker.yaml' + ``` + +추적 인수에 대한 종합적인 목록은 [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers) 페이지를 참조하세요. + +## 파이썬 예시 + +### 보존하는 추적 루프 + +다음은 OpenCV(`cv2`)와 YOLOv8를 사용하여 비디오 프레임에서 객체 추적을 실행하는 파이썬 스크립트입니다. 이 스크립트에서는 필요한 패키지(`opencv-python` 및 `ultralytics`)를 이미 설치했다고 가정합니다. `persist=True` 인수는 추적기에 현재 이미지 또는 프레임이 시퀀스에서 다음 것이며 현재 이미지에서 이전 이미지의 추적을 예상한다고 알립니다. + +!!! 예시 "추적이 포함된 스트리밍 for-loop" + + ```python + import cv2 + from ultralytics import YOLO + + # YOLOv8 모델을 불러옵니다 + model = YOLO('yolov8n.pt') + + # 비디오 파일을 엽니다 + video_path = "path/to/video.mp4" + cap = cv2.VideoCapture(video_path) + + # 비디오 프레임을 반복합니다 + while cap.isOpened(): + # 비디오에서 프레임을 읽습니다 + success, frame = cap.read() + + if success: + # 프레임에 YOLOv8 추적을 실행하여 추적을 유지합니다 + results = model.track(frame, persist=True) + + # 결과를 프레임에 시각화합니다 + annotated_frame = results[0].plot() + + # 어노테이션된 프레임을 표시합니다 + cv2.imshow("YOLOv8 추적", annotated_frame) + + # 'q'가 눌리면 루프를 중단합니다 + if cv2.waitKey(1) & 0xFF == ord("q"): + break + else: + # 비디오의 끝에 도달하면 루프를 중단합니다 + break + + # 비디오 캡처 객체를 해제하고 표시 창을 닫습니다 + cap.release() + cv2.destroyAllWindows() + ``` + +여기서 `model(frame)`을 `model.track(frame)`으로 변경하면 단순 감지가 아닌 객체 추적이 가능해집니다. 이 수정된 스크립트는 비디오의 각 프레임에 추적기를 실행하고 결과를 시각화한 후 창에 표시합니다. 'q'를 누르면 루프가 종료됩니다. + +### 시간에 따른 추적 그리기 + +연속 프레임에서 객체 추적을 시각화하면 비디오 내에서 검출된 객체의 이동 패턴과 행동에 대한 소중한 통찰력을 제공할 수 있습니다. Ultralytics YOLOv8을 사용하면 이러한 추적을 원활하고 효율적으로 플로팅할 수 있습니다. + +다음 예시에서, 여러 비디오 프레임에 걸친 검출된 객체의 움직임을 플로팅하기 위해 YOLOv8의 추적 기능을 활용하는 방법을 보여줍니다. 이 스크립트는 비디오 파일을 여는 것을 포함하여 프레임별로 읽고 YOLO 모델을 사용하여 다양한 객체를 식별하고 추적합니다. 검출된 경계 상자의 중심점을 보존하고 연결하여 추적된 객체의 경로를 나타내는 선을 그립니다. + +!!! 예시 "비디오 프레임에 걸쳐 추적 그리기" + + ```python + from collections import defaultdict + + import cv2 + import numpy as np + + from ultralytics import YOLO + + # YOLOv8 모델을 불러옵니다 + model = YOLO('yolov8n.pt') + + # 비디오 파일을 엽니다 + video_path = "path/to/video.mp4" + cap = cv2.VideoCapture(video_path) + + # 추적 내역을 저장합니다 + track_history = defaultdict(lambda: []) + + # 비디오 프레임을 반복합니다 + while cap.isOpened(): + # 비디오에서 프레임을 읽습니다 + success, frame = cap.read() + + if success: + # 프레임에 YOLOv8 추적을 실행하여 추적을 유지합니다 + results = model.track(frame, persist=True) + + # 상자 및 추적 ID를 가져옵니다 + boxes = results[0].boxes.xywh.cpu() + track_ids = results[0].boxes.id.int().cpu().tolist() + + # 결과를 프레임에 시각화합니다 + annotated_frame = results[0].plot() + + # 추적을 플롯합니다 + for box, track_id in zip(boxes, track_ids): + x, y, w, h = box + track = track_history[track_id] + track.append((float(x), float(y))) # x, y의 중심점 + if len(track) > 30: # 90프레임에 대해 90개의 추적을 유지 + track.pop(0) + + # 추적 라인을 그립니다 + points = np.hstack(track).astype(np.int32).reshape((-1, 1, 2)) + cv2.polylines(annotated_frame, [points], isClosed=False, color=(230, 230, 230), thickness=10) + + # 어노테이션된 프레임을 표시합니다 + cv2.imshow("YOLOv8 추적", annotated_frame) + + # 'q'가 눌리면 루프를 중단합니다 + if cv2.waitKey(1) & 0xFF == ord("q"): + break + else: + # 비디오의 끝에 도달하면 루프를 중단합니다 + break + + ``` diff --git a/docs/ko/modes/train.md b/docs/ko/modes/train.md new file mode 100644 index 00000000..512b8cb6 --- /dev/null +++ b/docs/ko/modes/train.md @@ -0,0 +1,145 @@ +--- +comments: true +description: YOLOv8 모델을 Ultralytics YOLO를 사용하여 훈련하는 단계별 가이드로, 단일 GPU 및 다중 GPU 훈련의 예제 포함 +keywords: Ultralytics, YOLOv8, YOLO, 객체 감지, 훈련 모드, 사용자 정의 데이터셋, GPU 훈련, 다중 GPU, 하이퍼파라미터, CLI 예제, Python 예제 +--- + +# Ultralytics YOLO와 함께 하는 모델 훈련 + +Ultralytics YOLO 생태계 및 통합 + +## 소개 + +딥러닝 모델을 훈련한다는 것은 모델에 데이터를 공급하고 그것이 정확한 예측을 할 수 있도록 매개변수를 조정하는 과정을 말합니다. Ultralytics YOLOv8의 훈련 모드는 현대 하드웨어 기능을 완전히 활용하여 객체 감지 모델의 효과적이고 효율적인 훈련을 위해 설계되었습니다. 이 가이드는 YOLOv8의 강력한 기능 세트를 사용하여 자체 모델을 훈련하는 데 필요한 모든 세부 정보를 다루는 것을 목표로 합니다. + +

+
+ +
+ 시청하기: Google Colab에서 여러분의 사용자 정의 데이터셋으로 YOLOv8 모델을 훈련하는 방법. +

+ +## Ultralytics YOLO로 훈련하는 이유? + +YOLOv8의 훈련 모드를 선택하는 데는 몇 가지 설득력 있는 이유가 있습니다: + +- **효율성:** 단일 GPU 설정이든 여러 GPU로 확장하든, 하드웨어를 최대한 활용하세요. +- **다양성:** COCO, VOC, ImageNet과 같은 기존의 데이터셋뿐만 아니라 사용자 정의 데이터셋으로도 훈련 가능. +- **사용자 친화적:** 간단하면서도 강력한 CLI 및 Python 인터페이스를 통한 직관적인 훈련 경험 제공. +- **하이퍼파라미터 유연성:** 모델의 성능을 미세 조정할 수 있는 다양하게 구성 가능한 하이퍼파라미터. + +### 훈련 모드의 주요 기능 + +다음은 YOLOv8의 훈련 모드의 주요 기능 중 일부입니다: + +- **자동 데이터셋 다운로드:** COCO, VOC, ImageNet과 같은 표준 데이터셋들은 첫 사용시 자동으로 다운로드됩니다. +- **다중 GPU 지원:** 여러 GPU에 걸쳐 훈련 노력을 빠르게 확대하기 위한 규모있는 훈련 지원. +- **하이퍼파라미터 구성:** YAML 구성 파일이나 CLI 인수를 통해 하이퍼파라미터 수정 가능. +- **시각화 및 모니터링:** 훈련 지표의 실시간 추적 및 학습 과정의 시각화로 더 나은 인사이트 제공. + +!!! 팁 "팁" + + * YOLOv8 데이터셋들은 첫 사용시 자동으로 다운로드됩니다, 예: `yolo train data=coco.yaml` + +## 사용 예제 + +COCO128 데이터셋에서 YOLOv8n을 이미지 크기 640으로 100 에포크 동안 훈련합니다. 훈련 장치는 `device` 인수를 사용하여 지정할 수 있습니다. 인수를 전달하지 않으면 사용 가능한 경우 GPU `device=0`이, 아니면 `device=cpu`가 사용됩니다. 전체 훈련 인수 목록은 아래 Arguments 섹션을 참조하세요. + +!!! 예제 "단일 GPU 및 CPU 훈련 예제" + + 장치는 자동으로 결정됩니다. GPU가 사용 가능하면 사용되며, 그렇지 않으면 CPU에서 훈련이 시작됩니다. + + === "Python" + + ```python + from ultralytics import YOLO + + # 모델을 로드하세요. + model = YOLO('yolov8n.yaml') # YAML에서 새 모델 구축 + model = YOLO('yolov8n.pt') # 사전 훈련된 모델 로드 (훈련을 위해 권장됨) + model = YOLO('yolov8n.yaml').load('yolov8n.pt') # YAML에서 구축 및 가중치 전달 + + # 모델을 훈련합니다. + results = model.train(data='coco128.yaml', epochs=100, imgsz=640) + ``` + + === "CLI" + + ```bash + # YAML에서 새 모델을 구축하고 처음부터 훈련을 시작하세요. + yolo detect train data=coco128.yaml model=yolov8n.yaml epochs=100 imgsz=640 + + # 사전 훈련된 *.pt 모델에서 훈련을 시작하세요. + yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 + + # YAML에서 새 모델을 구축하고, 사전 훈련된 가중치를 전달하고 훈련을 시작하세요. + yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640 + ``` + +### 다중 GPU 훈련 + +다중 GPU 훈련을 통해 사용 가능한 하드웨어 리소스를 더 효율적으로 활용할 수 있습니다. 이 기능은 Python API와 명령행 인터페이스 모두를 통해 사용할 수 있습니다. 다중 GPU 훈련을 활성화하려면 사용하려는 GPU 장치 ID를 지정하세요. + +!!! 예제 "다중 GPU 훈련 예제" + + 2개의 GPU, CUDA 장치 0과 1로 훈련하려면 다음 명령을 사용하세요. 필요에 따라 추가 GPU로 확장하세요. + + === "Python" + + ```python + from ultralytics import YOLO + + # 모델을 로드하세요. + model = YOLO('yolov8n.pt') # 사전 훈련된 모델 로드 (훈련 추천됨) + + # 2개의 GPU로 모델을 훈련합니다. + results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device=[0, 1]) + ``` + + === "CLI" + + ```bash + # 사전 훈련된 *.pt 모델로부터 시작하여 GPU 0과 1을 사용하여 훈련합니다. + yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=0,1 + ``` + +### Apple M1 및 M2 MPS 훈련 + +Ultralytics YOLO 모델에 통합된 Apple M1 및 M2 칩들에 대한 지원을 통해 Apple의 강력한 Metal Performance Shaders (MPS) 프레임워크를 활용하여 장치에서 모델을 훈련할 수 있습니다. MPS는 Apple 사용자 지정 실리콘에서 컴퓨터 및 이미지 처리 작업을 실행하는 고성능 방법을 제공합니다. + +Apple M1 및 M2 칩에서 훈련을 활성화하려면, 훈련 과정을 시작할 때 장치로 'mps'를 지정해야 합니다. 아래는 Python 및 명령행 인터페이스를 통해 이를 수행할 수 있는 예제입니다: + +!!! 예제 "MPS 훈련 예제" + + === "Python" + + ```python + from ultralytics import YOLO + + # 모델을 로드하세요. + model = YOLO('yolov8n.pt') # 사전 훈련된 모델 로드 (훈련 추천됨) + + # 2개의 GPU로 모델을 훈련합니다. + results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device='mps') + ``` + + === "CLI" + + ```bash + # 사전 훈련된 *.pt 모델을 사용하여 mps 장치에서 훈련을 시작합니다. + yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=mps + ``` + +M1/M2 칩의 연산력을 활용하면서 훈련 작업을 더 효율적으로 처리할 수 있습니다. 자세한 지침과 고급 설정 옵션을 원하신다면 [PyTorch MPS 문서](https://pytorch.org/docs/stable/notes/mps.html)를 참조하세요. + +### 중단된 훈련 이어나가기 + +이전에 저장된 상태에서 훈련을 이어나가는 기능은 딥러닝 모델을 다룰 때 중요한 기능입니다. 이 기능은 훈련 과정이 예기치 않게 중단되었거나 새로운 데이터로 모델을 계속 훈련하거나 더 많은 에포크 동안 훈련을 진행하고 싶을 때 유용합니다. + +훈련을 재개할 때, Ultralytics YOLO는 마지막으로 저장된 모델에서 가중치를 로드하고 옵티마이저 상태, 학습률 스케줄러, 에포크 번호도 복원합니다. 이를 통해 훈련 과정을 중단된 지점부터 이어갈 수 있습니다. + +Ultralytics YOLO에서 `train` 메서드 호출 시 `resume` 인수를 `True`로 설정하고 부분적으로 훈련된 모델 가중치가 포함된 `.pt` 파일의 경로를 지정하면 훈련을 이어나갈 수 있습니다. diff --git a/docs/ko/modes/val.md b/docs/ko/modes/val.md new file mode 100644 index 00000000..4b4b0cd4 --- /dev/null +++ b/docs/ko/modes/val.md @@ -0,0 +1,86 @@ +--- +comments: true +description: YOLOv8 모델 검증 가이드. 검증 설정 및 측정 항목을 사용하여 YOLO 모델의 성능을 평가하는 방법에 대해 알아보세요. Python 및 CLI 예제가 포함되어 있습니다. +keywords: Ultralytics, YOLO 문서, YOLOv8, 검증, 모델 평가, 하이퍼파라미터, 정확도, 측정 항목, Python, CLI +--- + +# Ultralytics YOLO로 모델 검증하기 + +Ultralytics YOLO 생태계 및 통합 + +## 도입 + +검증은 훈련된 모델의 품질을 평가할 수 있게 해주는 기계학습 파이프라인에서 중요한 단계입니다. Ultralytics YOLOv8의 Val 모드는 모델의 객체 탐지 성능을 평가하기 위한 강력한 도구 및 측정 항목 모음을 제공합니다. 이 가이드는 Val 모드를 효과적으로 사용하여 모델의 정확성과 신뢰성을 보장하는 방법에 대한 완벽한 리소스 역할을 합니다. + +## 왜 Ultralytics YOLO로 검증을 해야 할까요? + +YOLOv8의 Val 모드를 사용하는 이점은 다음과 같습니다: + +- **정밀도:** mAP50, mAP75, mAP50-95와 같은 정확한 측정 항목으로 모델을 종합적으로 평가합니다. +- **편의성:** 훈련 설정을 기억하는 내장 기능을 활용하여 검증 절차를 단순화합니다. +- **유연성:** 같거나 다른 데이터셋과 이미지 크기로 모델을 검증할 수 있습니다. +- **하이퍼파라미터 튜닝:** 검증 측정 항목을 사용하여 모델의 성능을 더 잘 조율합니다. + +### Val 모드의 주요 기능 + +YOLOv8의 Val 모드가 제공하는 주목할 만한 기능들은 다음과 같습니다: + +- **자동화된 설정:** 모델은 훈련 구성을 기억하여 간단하게 검증이 가능합니다. +- **멀티-메트릭 지원:** 다양한 정확도 측정 항목을 기반으로 모델을 평가합니다. +- **CLI 및 Python API:** 검증을 위해 명령 줄 인터페이스 또는 Python API 중에서 선택할 수 있습니다. +- **데이터 호환성:** 훈련 단계에서 사용된 데이터셋과 사용자 정의 데이터셋 모두와 원활하게 작동합니다. + +!!! tip "팁" + + * YOLOv8 모델은 훈련 설정을 자동으로 기억하므로 `yolo val model=yolov8n.pt`나 `model('yolov8n.pt').val()`만으로 같은 이미지 크기와 원본 데이터셋에서 쉽게 검증할 수 있습니다. + +## 사용 예제 + +COCO128 데이터셋에서 훈련된 YOLOv8n 모델의 정확도를 검증합니다. `모델`은 훈련 `데이터`와 인자를 모델 속성으로 유지하므로 인자가 필요 없습니다. 전체 내보내기 인자 목록은 아래의 인자 섹션을 참고하세요. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # 모델 로드 + model = YOLO('yolov8n.pt') # 공식 모델을 로드합니다 + model = YOLO('path/to/best.pt') # 사용자 정의 모델을 로드합니다 + + # 모델 검증 + metrics = model.val() # 인자가 필요 없음, 데이터셋과 설정이 기억됩니다 + metrics.box.map # map50-95 + metrics.box.map50 # map50 + metrics.box.map75 # map75 + metrics.box.maps # 각 카테고리의 map50-95가 포함된 목록 + ``` + === "CLI" + + ```bash + yolo detect val model=yolov8n.pt # 공식 모델 검증 + yolo detect val model=path/to/best.pt # 사용자 정의 모델 검증 + ``` + +## 인자 + +YOLO 모델의 검증 설정은 모델의 성능을 검증 데이터셋에서 평가하기 위한 다양한 하이퍼파라미터 및 구성을 의미합니다. 이러한 설정은 모델의 성능, 속도, 정확성에 영향을 미칠 수 있습니다. 일반적인 YOLO 검증 설정에는 배치 크기, 훈련 중 검증이 수행되는 빈도 및 모델 성능을 평가하기 위해 사용되는 측정 항목이 포함됩니다. 검증 과정에 영향을 줄 수 있는 다른 요소로는 검증 데이터셋의 크기와 구성 및 모델이 사용되는 구체적인 작업이 있습니다. 모델이 검증 데이터셋에서 잘 수행되고 있고 과적합을 감지하고 방지하기 위해서는 이러한 설정을 신중하게 조정하고 실험하는 것이 중요합니다. + +| Key | Value | Description | +|---------------|---------|---------------------------------------------------| +| `data` | `None` | 데이터 파일 경로 예: coco128.yaml | +| `imgsz` | `640` | 입력 이미지의 크기를 정수로 지정 | +| `batch` | `16` | 배치 당 이미지 수 (-1은 AutoBatch에 해당) | +| `save_json` | `False` | 결과를 JSON 파일로 저장 | +| `save_hybrid` | `False` | 라벨의 하이브리드 버전(라벨 + 추가 예측)을 저장 | +| `conf` | `0.001` | 탐지를 위한 객체 신뢰도 임계값 | +| `iou` | `0.6` | NMS 용 교차 영역과 합친 영역(IoU)의 임계값 | +| `max_det` | `300` | 이미지 당 최대 탐지 개수 | +| `half` | `True` | 반정밀도(FP16) 사용 | +| `device` | `None` | 사용할 장치 예: cuda의 device=0/1/2/3이나 device=cpu | +| `dnn` | `False` | ONNX 추론에 OpenCV DNN 사용 | +| `plots` | `False` | 훈련 중 플롯 표시 | +| `rect` | `False` | 최소한의 패딩을 위해 각 배치가 직사각형 val로 조정됨 | +| `split` | `val` | 검증을 위해 사용되는 데이터셋 분할, 예: 'val', 'test', 혹은 'train' | +| diff --git a/docs/ko/quickstart.md b/docs/ko/quickstart.md new file mode 100644 index 00000000..4fcba217 --- /dev/null +++ b/docs/ko/quickstart.md @@ -0,0 +1,196 @@ +--- +comments: true +description: pip, conda, git 및 Docker를 사용하여 Ultralytics을 설치하는 다양한 방법을 탐색해 보세요. Ultralytics을 명령줄 인터페이스 또는 Python 프로젝트 내에서 사용하는 방법을 알아보세요. +keywords: Ultralytics 설치, pip를 이용한 Ultralytics 설치, Docker를 이용한 Ultralytics 설치, Ultralytics 명령줄 인터페이스, Ultralytics Python 인터페이스 +--- + +## Ultralytics 설치하기 + +Ultralytics는 pip, conda, Docker를 포함한 다양한 설치 방법을 제공합니다. `ultralytics` pip 패키지를 이용해 가장 안정적인 최신 버전의 YOLOv8을 설치하거나 [Ultralytics GitHub 저장소](https://github.com/ultralytics/ultralytics)를 복제하여 가장 최신 버전을 받아볼 수 있습니다. Docker를 이용하면 패키지를 로컬에 설치하지 않고 격리된 컨테이너에서 실행할 수 있습니다. + +!!! example "설치하기" + + === "Pip 설치하기 (권장)" + pip을 사용하여 `ultralytics` 패키지를 설치하거나, `pip install -U ultralytics`를 실행하여 기존 설치를 업데이트하세요. Python Package Index(PyPI)에서 `ultralytics` 패키지에 대한 자세한 내용을 확인하세요: [https://pypi.org/project/ultralytics/](https://pypi.org/project/ultralytics/). + + [![PyPI 버전](https://badge.fury.io/py/ultralytics.svg)](https://badge.fury.io/py/ultralytics) [![다운로드](https://static.pepy.tech/badge/ultralytics)](https://pepy.tech/project/ultralytics) + + ```bash + # PyPI에서 ultralytics 패키지 설치하기 + pip install ultralytics + ``` + + GitHub [저장소](https://github.com/ultralytics/ultralytics)에서 직접 `ultralytics` 패키지를 설치할 수도 있습니다. 최신 개발 버전이 필요한 경우 유용할 수 있습니다. 시스템에 Git 명령줄 도구가 설치되어 있는지 확인하세요. `@main` 명령어는 `main` 브랜치를 설치하며, `@my-branch`로 변경하거나 `main` 브랜치를 기본으로 사용하려면 아예 제거하면 됩니다. + + ```bash + # GitHub에서 ultralytics 패키지 설치하기 + pip install git+https://github.com/ultralytics/ultralytics.git@main + ``` + + + === "Conda 설치하기" + pip의 대안으로 사용할 수 있는 또 다른 패키지 관리자인 Conda를 통해서도 설치할 수 있습니다. [https://anaconda.org/conda-forge/ultralytics](https://anaconda.org/conda-forge/ultralytics)에서 Anaconda에 대한 자세한 정보를 확인하세요. Conda 패키지를 업데이트하는 Ultralytics feedstock 저장소는 [https://github.com/conda-forge/ultralytics-feedstock/](https://github.com/conda-forge/ultralytics-feedstock/)에 있습니다. + + + [![Conda 레시피](https://img.shields.io/badge/recipe-ultralytics-green.svg)](https://anaconda.org/conda-forge/ultralytics) [![Conda 다운로드](https://img.shields.io/conda/dn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics) [![Conda 버전](https://img.shields.io/conda/vn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics) [![Conda 플랫폼](https://img.shields.io/conda/pn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics) + + ```bash + # conda를 사용하여 ultralytics 패키지 설치하기 + conda install -c conda-forge ultralytics + ``` + + !!! note + + CUDA 환경에서 설치하는 경우 일반적으로 `ultralytics`, `pytorch` 및 `pytorch-cuda`를 동일한 명령어로 설치하여 Conda 패키지 관리자가 충돌을 해결하도록 하거나, 필요한 경우 CPU 전용 `pytorch` 패키지를 덮어쓸 수 있도록 `pytorch-cuda`를 마지막에 설치하는 것이 좋습니다. + ```bash + # Conda를 사용하여 모든 패키지 함께 설치하기 + conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics + ``` + + ### Conda Docker 이미지 + + Ultralytics Conda Docker 이미지들도 [DockerHub](https://hub.docker.com/r/ultralytics/ultralytics)에서 사용할 수 있습니다. 이 이미지들은 [Miniconda3](https://docs.conda.io/projects/miniconda/en/latest/)를 기반으로 하며, Conda 환경에서 `ultralytics`를 사용하기 위한 간단한 방법입니다. + + ```bash + # 이미지 이름을 변수로 설정하기 + t=ultralytics/ultralytics:latest-conda + + # Docker Hub에서 최신 ultralytics 이미지 가져오기 + sudo docker pull $t + + # GPU 지원으로 ultralytics 이미지를 컨테이너에서 실행하기 + sudo docker run -it --ipc=host --gpus all $t # 모든 GPU 사용 + sudo docker run -it --ipc=host --gpus '"device=2,3"' $t # 특정 GPU 지정 + ``` + + + === "Git 복제하기" + 개발에 기여하거나 최신 소스 코드를 실험해 보고 싶다면 `ultralytics` 저장소를 복제하세요. 복제한 후 해당 디렉토리로 이동하여 pip을 이용해 편집 가능 모드 `-e`로 패키지를 설치합니다. + ```bash + # ultralytics 저장소 복제하기 + git clone https://github.com/ultralytics/ultralytics + + # 복제한 디렉토리로 이동하기 + cd ultralytics + + # 개발을 위한 편집 가능 모드로 패키지 설치하기 + pip install -e . + ``` + + === "Docker 사용하기" + + Docker를 사용하면 `ultralytics` 패키지를 격리된 컨테이너에서 원활하게 실행할 수 있으며, 다양한 환경에서 일관된 성능을 보장합니다. [Docker Hub](https://hub.docker.com/r/ultralytics/ultralytics)의 공식 `ultralytics` 이미지 중 하나를 선택함으로써 로컬 설치의 복잡함을 피하고 검증된 작업 환경에 접근할 수 있습니다. Ultralytics은 서로 다른 플랫폼과 사용 사례에 대해 높은 호환성과 효율성을 제공하기 위해 5가지 주요 Docker 이미지를 제공합니다: + + Docker Pulls + + - **Dockerfile:** 트레이닝에 추천되는 GPU 이미지입니다. + - **Dockerfile-arm64:** Raspberry Pi와 같은 ARM64 기반 플랫폼에 배포하기에 최적화된 ARM64 아키텍처용입니다. + - **Dockerfile-cpu:** GPU가 없는 환경에서 인퍼런스에 적합한 Ubuntu 기반 CPU 전용 버전입니다. + - **Dockerfile-jetson:** NVIDIA Jetson 장치에 최적화된 GPU 지원을 통합한 버전입니다. + - **Dockerfile-python:** 가볍게 애플리케이션을 위해 필요한 종속성과 Python만 있는 최소한의 이미지입니다. + - **Dockerfile-conda:** Miniconda3를 기반으로 하며 ultralytics 패키지의 conda 설치를 포함하고 있습니다. + + 아래의 명령어로 최신 이미지를 받고 실행할 수 있습니다: + + ```bash + # 이미지 이름을 변수로 설정하기 + t=ultralytics/ultralytics:latest + + # Docker Hub에서 최신 ultralytics 이미지 가져오기 + sudo docker pull $t + + # GPU 지원으로 ultralytics 이미지를 컨테이너에서 실행하기 + sudo docker run -it --ipc=host --gpus all $t # 모든 GPU 사용 + sudo docker run -it --ipc=host --gpus '"device=2,3"' $t # 특정 GPU 지정 + ``` + + 위 명령어는 최신 `ultralytics` 이미지로 Docker 컨테이너를 초기화합니다. `-it` 플래그는 pseudo-TTY를 할당하고 표준 입력을 유지하여 컨테이너와 상호 작용할 수 있게 해줍니다. `--ipc=host` 플래그는 프로세스 간 메모리 공유에 필요한 IPC(Inter-Process Communication) 네임스페이스를 호스트로 설정합니다. `--gpus all` 플래그는 컨테이너 내에서 사용 가능한 모든 GPU에 대한 접근을 활성화하는데, GPU 계산이 필요한 작업에 중요합니다. + + 참고: 로컬 기계의 파일을 컨테이너 내에서 작업하기 위해서는 로컬 디렉토리를 컨테이너에 마운트하는 데 Docker 볼륨을 사용하세요: + + ```bash + # 로컬 디렉토리를 컨테이너 내부 디렉토리에 마운트하기 + sudo docker run -it --ipc=host --gpus all -v /path/on/host:/path/in/container $t + ``` + + `/path/on/host`를 로컬 기계의 디렉토리 경로로, `/path/in/container`를 컨테이너 내부에서 원하는 경로로 변경하여 접근할 수 있게 하세요. + + Docker 사용에 대한 고급 기능은 [Ultralytics Docker 가이드](https://docs.ultralytics.com/guides/docker-quickstart/)에서 더 탐구해보세요. + +`ultralytics`의 종속성 목록은 [requirements.txt](https://github.com/ultralytics/ultralytics/blob/main/requirements.txt) 파일에서 확인할 수 있습니다. 위 예제에서는 모든 필요한 종속성을 설치합니다. + +!!! tip "팁" + + PyTorch 설치 요구사항은 운영 체제와 CUDA 요구사항에 따라 다르므로 [https://pytorch.org/get-started/locally](https://pytorch.org/get-started/locally)의 지침에 따라 PyTorch를 먼저 설치하는 것이 권장됩니다. + + + PyTorch 설치 지침 + + +## 명령줄 인터페이스(CLI)로 Ultralytics 사용하기 + +Ultralytics 명령줄 인터페이스(CLI)는 Python 환경이 필요 없이 단일 라인 명령어를 통해 작업을 쉽게 실행할 수 있도록 합니다. CLI는 커스터마이징이나 Python 코드가 필요 없습니다. `yolo` 명령어를 이용해 터미널에서 모든 작업을 실행할 수 있습니다. 명령줄에서 YOLOv8을 사용하는 방법에 대해 더 알아보려면 [CLI 가이드](../usage/cli.md)를 참고하세요. + +!!! example + + === "문법" + + Ultralytics `yolo` 명령어는 다음과 같은 문법을 사용합니다: + ```bash + yolo TASK MODE ARGS + + 여기서 TASK (선택적)은 [detect, segment, classify] 중 하나 + MODE (필수)는 [train, val, predict, export, track] 중 하나 + ARGS (선택적)은 'imgsz=320'과 같이 기본값을 재정의하는 'arg=value' 쌍을 아무 개수나 지정할 수 있습니다. + ``` + 모든 ARGS는 전체 [구성 가이드](../usage/cfg.md)에서 또는 `yolo cfg`로 확인할 수 있습니다 + + === "Train" + + 10 에포크 동안 초기 학습률 0.01로 감지 모델을 훈련합니다. + ```bash + yolo train data=coco128.yaml model=yolov8n.pt epochs=10 lr0=0.01 + ``` + + === "Predict" + + 이전 훈련된 세분화 모델을 사용하여 이미지 크기 320으로 YouTube 동영상을 예측합니다: + ```bash + yolo predict model=yolov8n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320 + ``` + + === "Val" + + 배치 크기 1와 이미지 크기 640으로 이전 훈련된 감지 모델을 검증합니다: + ```bash + yolo val model=yolov8n.pt data=coco128.yaml batch=1 imgsz=640 + ``` + + === "Export" + + YOLOv8n 분류 모델을 ONNX 형식으로 내보냅니다. 이미지 크기는 224x128입니다 (TASK 필요 없음). + ```bash + yolo export model=yolov8n-cls.pt format=onnx imgsz=224,128 + ``` + + === "특별" + + 버전 확인, 설정 보기, 검사 실행 등을 위한 특별 명령어를 실행하세요: + ```bash + yolo help + yolo checks + yolo version + yolo settings + yolo copy-cfg + yolo cfg + ``` + +!!! warning "주의" + + 모든 인수는 `arg=val`쌍으로 전달되어야 하며, 각 쌍 사이에는 공백으로 구분해야 합니다. 인수 접두사로 `--`를 사용하거나 인수 사이에 쉼표 `,`를 사용해서는 안 됩니다. + + - `yolo predict model=yolov8n.pt imgsz=640 conf=0.25`   ✅ + - `yolo predict model yolov8n.pt imgsz 640 conf 0.25`   ❌ + - `yolo predict --model yolov8n.pt --imgsz 640 --conf 0.25`   ❌ + +[CLI 가이드](../usage/cli.md){ .md-button .md-button--primary} diff --git a/docs/ko/tasks/classify.md b/docs/ko/tasks/classify.md new file mode 100644 index 00000000..d164ebc6 --- /dev/null +++ b/docs/ko/tasks/classify.md @@ -0,0 +1,172 @@ +--- +comments: true +description: YOLOv8 분류 모델에 대한 이미지 분류 정보를 알아보세요. 사전 훈련된 모델 목록과 모델 학습, 검증, 예측, 내보내기 방법에 대한 자세한 정보를 확인하실 수 있습니다. +keywords: Ultralytics, YOLOv8, 이미지 분류, 사전 훈련된 모델, YOLOv8n-cls, 학습, 검증, 예측, 모델 내보내기 +--- + +# 이미지 분류 + +Image classification examples + +이미지 분류는 가장 단순한 세 가지 작업 중 하나로, 전체 이미지를 미리 정의된 클래스 집합 중 하나로 분류하는 작업입니다. + +이미지 분류기의 출력은 단일 클래스 라벨과 신뢰도 점수입니다. 이미지 분류는 클래스의 이미지만 알고 싶고 해당 클래스의 객체가 어디에 위치하고 있는지 또는 그 정확한 형태가 무엇인지 알 필요가 없을 때 유용합니다. + +!!! 팁 "팁" + + YOLOv8 분류 모델은 `-cls` 접미사를 사용합니다. 예: `yolov8n-cls.pt`이며, [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml)에서 사전 훈련되었습니다. + +## [모델](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8) + +여기에는 사전 훈련된 YOLOv8 분류 모델이 표시됩니다. Detect, Segment 및 Pose 모델은 [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml) 데이터셋에서 사전 훈련되고, 분류 모델은 [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml) 데이터셋에서 사전 훈련됩니다. + +[모델](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models)은 첫 사용 시 최신 Ultralytics [릴리스](https://github.com/ultralytics/assets/releases)에서 자동으로 다운로드됩니다. + +| 모델 | 크기
(픽셀) | 정확도
top1 | 정확도
top5 | 속도
CPU ONNX
(ms) | 속도
A100 TensorRT
(ms) | 매개변수
(M) | FLOPs
(B) at 640 | +|----------------------------------------------------------------------------------------------|-----------------|------------------|------------------|-----------------------------|----------------------------------|------------------|--------------------------| +| [YOLOv8n-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-cls.pt) | 224 | 66.6 | 87.0 | 12.9 | 0.31 | 2.7 | 4.3 | +| [YOLOv8s-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-cls.pt) | 224 | 72.3 | 91.1 | 23.4 | 0.35 | 6.4 | 13.5 | +| [YOLOv8m-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-cls.pt) | 224 | 76.4 | 93.2 | 85.4 | 0.62 | 17.0 | 42.7 | +| [YOLOv8l-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-cls.pt) | 224 | 78.0 | 94.1 | 163.0 | 0.87 | 37.5 | 99.7 | +| [YOLOv8x-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-cls.pt) | 224 | 78.4 | 94.3 | 232.0 | 1.01 | 57.4 | 154.8 | + +- **정확도** 값은 [ImageNet](https://www.image-net.org/) 데이터셋 검증 세트에서의 모델 정확도입니다. +
[ImageNet](https://www.image-net.org/)에서 재현 가능합니다: `yolo val classify data=path/to/ImageNet device=0` +- **속도**는 [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) 인스턴스를 사용해 ImageNet 검증 이미지들의 평균 속도입니다. +
[ImageNet](https://www.image-net.org/)에서 재현 가능합니다: `yolo val classify data=path/to/ImageNet batch=1 device=0|cpu` + +## 학습 + +YOLOv8n-cls 모델을 MNIST160 데이터셋에서 100 에포크 동안 학습시키고 이미지 크기는 64로 설정합니다. 가능한 모든 인자는 [설정](../../usage/cfg.md) 페이지에서 확인할 수 있습니다. + +!!! 예제 "" + + === "Python" + + ```python + from ultralytics import YOLO + + # 모델 불러오기 + model = YOLO('yolov8n-cls.yaml') # YAML에서 새 모델 구축 + model = YOLO('yolov8n-cls.pt') # 사전 훈련된 모델 불러오기 (학습용 추천) + model = YOLO('yolov8n-cls.yaml').load('yolov8n-cls.pt') # YAML로 구축하고 가중치 전송 + + # 모델 학습 + result = model.train(data='mnist160', epochs=100, imgsz=64) + ``` + + === "CLI" + + ```bash + # YAML에서 새 모델을 구축하고 처음부터 학습 시작 + yolo classify train data=mnist160 model=yolov8n-cls.yaml epochs=100 imgsz=64 + + # 사전 훈련된 *.pt 모델에서 학습 시작 + yolo classify train data=mnist160 model=yolov8n-cls.pt epochs=100 imgsz=64 + + # YAML에서 새 모델을 구축하고 사전 훈련된 가중치를 전송한 뒤 학습 시작 + yolo classify train data=mnist160 model=yolov8n-cls.yaml pretrained=yolov8n-cls.pt epochs=100 imgsz=64 + ``` + +### 데이터셋 형식 + +YOLO 분류 데이터셋 형식은 [데이터셋 가이드](../../datasets/classify/index.md)에서 자세히 확인할 수 있습니다. + +## 검증 + +학습된 YOLOv8n-cls 모델의 정확도를 MNIST160 데이터셋에서 검증합니다. `model`은 모델 속성으로 훈련 시 `data` 및 인자를 유지하므로 추가 인자를 전달할 필요가 없습니다. + +!!! 예제 "" + + === "Python" + + ```python + from ultralytics import YOLO + + # 모델 불러오기 + model = YOLO('yolov8n-cls.pt') # 공식 모델 불러오기 + model = YOLO('path/to/best.pt') # 사용자 모델 불러오기 + + # 모델 검증 + metrics = model.val() # 추가 인자 불필요, 데이터셋 및 설정 기억함 + metrics.top1 # top1 정확도 + metrics.top5 # top5 정확도 + ``` + === "CLI" + + ```bash + yolo classify val model=yolov8n-cls.pt # 공식 모델 검증 + yolo classify val model=path/to/best.pt # 사용자 모델 검증 + ``` + +## 예측 + +학습된 YOLOv8n-cls 모델을 사용하여 이미지에 대한 예측을 실행합니다. + +!!! 예제 "" + + === "Python" + + ```python + from ultralytics import YOLO + + # 모델 불러오기 + model = YOLO('yolov8n-cls.pt') # 공식 모델 불러오기 + model = YOLO('path/to/best.pt') # 사용자 모델 불러오기 + + # 예측 실행 + results = model('https://ultralytics.com/images/bus.jpg') # 이미지에 대한 예측 실행 + ``` + === "CLI" + + ```bash + yolo classify predict model=yolov8n-cls.pt source='https://ultralytics.com/images/bus.jpg' # 공식 모델로 예측 실행 + yolo classify predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # 사용자 모델로 예측 실행 + ``` + +자세한 `predict` 모드 정보는 [예측](https://docs.ultralytics.com/modes/predict/) 페이지에서 확인하세요. + +## 내보내기 + +YOLOv8n-cls 모델을 ONNX, CoreML 등과 같은 다른 형식으로 내보냅니다. + +!!! 예제 "" + + === "Python" + + ```python + from ultralytics import YOLO + + # 모델 불러오기 + model = YOLO('yolov8n-cls.pt') # 공식 모델 불러오기 + model = YOLO('path/to/best.pt') # 사용자 훈련 모델 불러오기 + + # 모델 내보내기 + model.export(format='onnx') + ``` + === "CLI" + + ```bash + yolo export model=yolov8n-cls.pt format=onnx # 공식 모델 내보내기 + yolo export model=path/to/best.pt format=onnx # 사용자 훈련 모델 내보내기 + ``` + +아래 표에 사용 가능한 YOLOv8-cls 내보내기 형식이 나와 있습니다. 내보낸 모델에서 바로 예측하거나 검증할 수 있습니다. 즉, `yolo predict model=yolov8n-cls.onnx`를 사용할 수 있습니다. 내보내기가 완료된 후 모델에 대한 사용 예제들이 표시됩니다. + +| 형식 | `format` 인자 | 모델 | 메타데이터 | 인자 | +|--------------------------------------------------------------------|---------------|-------------------------------|-------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n-cls.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-cls.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-cls.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-cls_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-cls.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-cls.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-cls_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-cls.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-cls.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-cls_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-cls_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-cls_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-cls_ncnn_model/` | ✅ | `imgsz`, `half` | + +자세한 `export` 정보는 [내보내기](https://docs.ultralytics.com/modes/export/) 페이지에서 확인하세요. diff --git a/docs/ko/tasks/detect.md b/docs/ko/tasks/detect.md new file mode 100644 index 00000000..73a4e6ea --- /dev/null +++ b/docs/ko/tasks/detect.md @@ -0,0 +1,184 @@ +--- +comments: true +description: Ultralytics 공식 YOLOv8 문서입니다. 모델 훈련, 검증, 예측 및 다양한 형식으로 모델 내보내기 방법을 배우십시오. 세부적인 성능 통계를 포함합니다. +keywords: YOLOv8, Ultralytics, 객체 감지, 사전 훈련된 모델, 훈련, 검증, 예측, 모델 내보내기, COCO, ImageNet, PyTorch, ONNX, CoreML +--- + +# 객체 감지 + +객체 감지 예제 + +객체 감지는 이미지 또는 비디오 스트림 내의 객체의 위치와 클래스를 식별하는 작업입니다. + +객체 감지기의 출력은 이미지 속 객체를 내포하는 경계 상자(bounding box) 세트와 각 상자에 대한 클래스 레이블과 신뢰도 점수를 포함합니다. 장면 내 관심 객체를 식별해야 하지만 객체의 정확한 위치나 정확한 모양을 알 필요가 없을 때 객체 감지가 좋은 선택입니다. + +

+
+ +
+ 시청하기: 사전 훈련된 Ultralytics YOLOv8 모델로 객체 감지하기. +

+ +!!! tip "팁" + + YOLOv8 Detect 모델들은 기본 YOLOv8 모델이며 예를 들어 `yolov8n.pt` 이 [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml) 데이터셋에서 사전 훈련되었습니다. + +## [모델](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8) + +여기서는 YOLOv8 사전 훈련된 Detect 모델을 나타냅니다. Detect, Segment, 및 Pose 모델은 [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml) 데이터셋에서, Classify 모델은 [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml) 데이터셋에서 사전 훈련되었습니다. + +[모델](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models)은 첫 사용 시 Ultralytics의 최신 [릴리즈](https://github.com/ultralytics/assets/releases)에서 자동으로 다운로드됩니다. + +| 모델 | 크기
(픽셀) | mAPval
50-95 | 속도
CPU ONNX
(ms) | 속도
A100 TensorRT
(ms) | 파라미터
(M) | FLOPs
(B) | +|--------------------------------------------------------------------------------------|-----------------|----------------------|-----------------------------|----------------------------------|------------------|-------------------| +| [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n.pt) | 640 | 37.3 | 80.4 | 0.99 | 3.2 | 8.7 | +| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s.pt) | 640 | 44.9 | 128.4 | 1.20 | 11.2 | 28.6 | +| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m.pt) | 640 | 50.2 | 234.7 | 1.83 | 25.9 | 78.9 | +| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l.pt) | 640 | 52.9 | 375.2 | 2.39 | 43.7 | 165.2 | +| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x.pt) | 640 | 53.9 | 479.1 | 3.53 | 68.2 | 257.8 | + +- **mAPval** 값은 [COCO val2017](http://cocodataset.org) 데이터셋에서 단일 모델 단일 스케일을 사용한 값입니다. +
[COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml) 데이터와 `yolo val detect data=coco.yaml device=0` 명령으로 재현할 수 있습니다. +- **속도**는 [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) 인스턴스를 사용해 COCO val 이미지들을 평균한 것입니다. +
[COCO128](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco128.yaml) 데이터와 `yolo val detect data=coco128.yaml batch=1 device=0|cpu` 명령으로 재현할 수 있습니다. + +## 훈련 + +COCO128 데이터셋에서 이미지 크기 640으로 YOLOv8n 모델을 100 에포크 동안 훈련합니다. 가능한 모든 인수에 대한 목록은 [설정](../../usage/cfg.md) 페이지에서 확인할 수 있습니다. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # 모델 로드하기 + model = YOLO('yolov8n.yaml') # YAML에서 새 모델을 빌드합니다. + model = YOLO('yolov8n.pt') # 사전 훈련된 모델을 로드합니다(훈련을 위해 권장됩니다). + model = YOLO('yolov8n.yaml').load('yolov8n.pt') # YAML에서 빌드하고 가중치를 전달합니다. + + # 모델 훈련하기 + results = model.train(data='coco128.yaml', epochs=100, imgsz=640) + ``` + === "CLI" + + ```bash + # YAML에서 새 모델을 빌드하고 처음부터 훈련을 시작합니다. + yolo detect train data=coco128.yaml model=yolov8n.yaml epochs=100 imgsz=640 + + # 사전 훈련된 *.pt 모델로부터 훈련을 시작합니다. + yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 + + # YAML에서 새 모델을 빌드하고, 사전 훈련된 가중치를 전달한 후 훈련을 시작합니다. + yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640 + ``` + +### 데이터셋 형식 + +YOLO 감지 데이터셋 형식은 [데이터셋 가이드](../../datasets/detect/index.md)에서 자세히 볼 수 있습니다. 다른 형식(예: COCO 등)의 기존 데이터셋을 YOLO 형식으로 변환하려면 Ultralytics의 [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) 도구를 사용하십시오. + +## 검증 + +COCO128 데이터셋에서 훈련된 YOLOv8n 모델의 정확도를 검증합니다. `model`은 훈련 시의 `data`와 인수를 모델 속성으로 보존하기 때문에 인수를 전달할 필요가 없습니다. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # 모델 로드하기 + model = YOLO('yolov8n.pt') # 공식 모델을 로드합니다. + model = YOLO('path/to/best.pt') # 사용자 정의 모델을 로드합니다. + + # 모델 검증하기 + metrics = model.val() # 데이터셋과 설정을 기억하니 인수는 필요 없습니다. + metrics.box.map # map50-95 + metrics.box.map50 # map50 + metrics.box.map75 # map75 + metrics.box.maps # 각 카테고리의 map50-95가 포함된 리스트입니다. + ``` + === "CLI" + + ```bash + yolo detect val model=yolov8n.pt # 공식 모델 검증하기 + yolo detect val model=path/to/best.pt # 사용자 정의 모델 검증하기 + ``` + +## 예측 + +훈련된 YOLOv8n 모델을 사용하여 이미지에 대한 예측을 수행합니다. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # 모델 로드하기 + model = YOLO('yolov8n.pt') # 공식 모델을 로드합니다. + model = YOLO('path/to/best.pt') # 사용자 정의 모델을 로드합니다. + + # 모델로 예측하기 + results = model('https://ultralytics.com/images/bus.jpg') # 이미지에 대해 예측합니다. + ``` + === "CLI" + + ```bash + yolo detect predict model=yolov8n.pt source='https://ultralytics.com/images/bus.jpg' # 공식 모델로 예측하기 + yolo detect predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # 사용자 정의 모델로 예측하기 + ``` + +전체 'predict' 모드 세부 사항은 [Predict](https://docs.ultralytics.com/modes/predict/) 페이지에서 확인하세요. + +## 내보내기 + +YOLOv8n 모델을 ONNX, CoreML 등과 같은 다른 형식으로 내보냅니다. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # 모델 로드하기 + model = YOLO('yolov8n.pt') # 공식 모델을 로드합니다. + model = YOLO('path/to/best.pt') # 사용자 정의 모델을 로드합니다. + + # 모델 내보내기 + model.export(format='onnx') + ``` + === "CLI" + + ```bash + yolo export model=yolov8n.pt format=onnx # 공식 모델 내보내기 + yolo export model=path/to/best.pt format=onnx # 사용자 정의 모델 내보내기 + ``` + +사용 가능한 YOLOv8 내보내기 형식은 아래 표에 나와 있습니다. 내보내기 완료 후 사용 예시는 모델에 대해 보여줍니다. + +| 형식 | `format` 인수 | 모델 | 메타데이터 | 인수 | +|--------------------------------------------------------------------|---------------|---------------------------|-------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | ✅ | `imgsz`, `half` | + +전체 'export' 세부 사항은 [Export](https://docs.ultralytics.com/modes/export/) 페이지에서 확인하세요. diff --git a/docs/ko/tasks/index.md b/docs/ko/tasks/index.md new file mode 100644 index 00000000..e725ffa8 --- /dev/null +++ b/docs/ko/tasks/index.md @@ -0,0 +1,55 @@ +--- +comments: true +description: YOLOv8을 사용하여 수행할 수 있는 컴퓨터 비전 작업의 기초인 탐지, 세분화, 분류 및 자세 추정에 대해 알아보세요. AI 프로젝트에서의 그 용도를 이해하세요. +keywords: Ultralytics, YOLOv8, 탐지, 세분화, 분류, 자세 추정, AI 프레임워크, 컴퓨터 비전 작업 +--- + +# Ultralytics YOLOv8 작업 + +
+Ultralytics YOLO 지원 작업 + +YOLOv8는 여러 컴퓨터 비전 **작업**을 지원하는 AI 프레임워크입니다. 이 프레임워크는 [탐지](detect.md), [세분화](segment.md), [분류](classify.md), 그리고 [자세](pose.md) 추정을 수행하는 데 사용될 수 있습니다. 각각의 작업은 서로 다른 목적과 사용 사례를 가지고 있습니다. + +!!! note + + 🚧 다국어 문서화 작업이 진행 중에 있으며, 더 나은 문서를 제공하기 위해 노력하고 있습니다. 인내해 주셔서 감사합니다! 🙏 + +

+
+ +
+ 보기: Ultralytics YOLO 작업 탐색: 객체 탐지, 세분화, 추적, 자세 추정. +

+ +## [탐지](detect.md) + +탐지는 YOLOv8이 지원하는 기본 작업입니다. 이미지 또는 비디오 프레임에서 객체를 탐지하고 주변에 경계 상자를 그리는 것을 포함합니다. 탐지된 객체들은 그 특징에 따라 다른 카테고리로 분류됩니다. YOLOv8은 단일 이미지나 비디오 프레임에서 여러 객체를 정확하고 빠르게 탐지할 수 있습니다. + +[탐지 예시](detect.md){ .md-button .md-button--primary} + +## [세분화](segment.md) + +세분화는 이미지를 내용에 기반하여 다른 영역으로 나누는 작업입니다. 각 영역은 내용에 따라 레이블이 지정됩니다. 이 작업은 이미지 세분화와 의료 영상과 같은 응용 분야에 유용합니다. YOLOv8는 U-Net 아키텍처의 변형을 사용하여 세분화를 수행합니다. + +[세분화 예시](segment.md){ .md-button .md-button--primary} + +## [분류](classify.md) + +분류는 이미지를 다른 카테고리로 분류하는 작업입니다. YOLOv8는 이미지의 내용을 바탕으로 이미지 분류에 사용될 수 있습니다. 이는 EfficientNet 아키텍처의 변형을 사용하여 분류 작업을 수행합니다. + +[분류 예시](classify.md){ .md-button .md-button--primary} + +## [자세](pose.md) + +자세/키포인트 탐지는 이미지나 비디오 프레임에서 특정 점들을 탐지하는 작업입니다. 이들 점은 키포인트로 불리며, 움직임 추적이나 자세 추정에 사용됩니다. YOLOv8은 이미지나 비디오 프레임의 키포인트를 정확하고 빠르게 탐지할 수 있습니다. + +[자세 예시](pose.md){ .md-button .md-button--primary} + +## 결론 + +YOLOv8은 탐지, 세분화, 분류, 키포인트 탐지 등 다양한 작업을 지원합니다. 각각의 작업은 다른 목적과 사용 사례를 가지고 있습니다. 이러한 작업의 차이점을 이해함으로써, 컴퓨터 비전 응용 프로그램에 적합한 작업을 선택할 수 있습니다. diff --git a/docs/ko/tasks/pose.md b/docs/ko/tasks/pose.md new file mode 100644 index 00000000..9500beba --- /dev/null +++ b/docs/ko/tasks/pose.md @@ -0,0 +1,185 @@ +--- +comments: true +description: Ultralytics YOLOv8을 사용하여 포즈 추정 작업을 수행하는 방법을 알아보세요. 미리 학습된 모델을 찾고, 학습, 검증, 예측, 내보내기 등을 진행하는 방법을 배울 수 있습니다. +keywords: Ultralytics, YOLO, YOLOv8, 포즈 추정, 키포인트 검출, 객체 검출, 미리 학습된 모델, 기계 학습, 인공 지능 +--- + +# 포즈 추정 + +포즈 추정 예시 + +포즈 추정은 이미지 내 특정 점들의 위치를 식별하는 작업입니다. 이러한 점들은 보통 관절, 표식, 또는 기타 구별 가능한 특징으로 나타나는 키포인트입니다. 키포인트의 위치는 대개 2D `[x, y]` 또는 3D `[x, y, visible]` 좌표의 집합으로 표현됩니다. + +포즈 추정 모델의 출력은 이미지 속 객체 상의 키포인트를 나타내는 점들의 집합과 각 점의 신뢰도 점수를 포함합니다. 포즈 추정은 장면 속 객체의 구체적인 부분을 식별하고, 서로 관련된 위치를 파악해야 할 때 좋은 선택입니다. + +

+
+ +
+ 시청하기: Ultralytics YOLOv8을 이용한 포즈 추정. +

+ +!!! tip "팁" + + YOLOv8 _pose_ 모델은 `-pose` 접미사가 붙습니다. 예: `yolov8n-pose.pt`. 이 모델들은 [COCO keypoints](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco-pose.yaml) 데이터셋으로 학습되었으며 포즈 추정 작업에 적합합니다. + +## [모델](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8) + +여기에 표시된 YOLOv8 미리 학습된 포즈 모델을 확인하세요. Detect, Segment 및 Pose 모델은 [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml) 데이터셋으로 미리 학습되며, Classify 모델은 [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml) 데이터셋으로 미리 학습됩니다. + +[모델](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models)은 첫 사용 시 Ultralytics [릴리스](https://github.com/ultralytics/assets/releases)에서 자동으로 다운로드됩니다. + +| 모델 | 크기
(픽셀) | mAP포즈
50-95 | mAP포즈
50 | 속도
CPU ONNX
(ms) | 속도
A100 TensorRT
(ms) | 파라미터
(M) | FLOPs
(B) | +|------------------------------------------------------------------------------------------------------|-----------------|---------------------|------------------|-----------------------------|----------------------------------|------------------|-------------------| +| [YOLOv8n-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-pose.pt) | 640 | 50.4 | 80.1 | 131.8 | 1.18 | 3.3 | 9.2 | +| [YOLOv8s-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-pose.pt) | 640 | 60.0 | 86.2 | 233.2 | 1.42 | 11.6 | 30.2 | +| [YOLOv8m-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-pose.pt) | 640 | 65.0 | 88.8 | 456.3 | 2.00 | 26.4 | 81.0 | +| [YOLOv8l-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-pose.pt) | 640 | 67.6 | 90.0 | 784.5 | 2.59 | 44.4 | 168.6 | +| [YOLOv8x-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose.pt) | 640 | 69.2 | 90.2 | 1607.1 | 3.73 | 69.4 | 263.2 | +| [YOLOv8x-pose-p6](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose-p6.pt) | 1280 | 71.6 | 91.2 | 4088.7 | 10.04 | 99.1 | 1066.4 | + +- **mAPval** 값은 [COCO Keypoints val2017](http://cocodataset.org) 데이터셋에서 단일 모델 단일 규모를 기준으로 합니다. +
재현하려면 `yolo val pose data=coco-pose.yaml device=0`을 사용하세요. +- **속도**는 [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) 인스턴스를 사용하여 COCO val 이미지 평균입니다. +
재현하려면 `yolo val pose data=coco8-pose.yaml batch=1 device=0|cpu`를 사용하세요. + +## 학습 + +COCO128-pose 데이터셋에서 YOLOv8-pose 모델 학습하기. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # 모델 불러오기 + model = YOLO('yolov8n-pose.yaml') # YAML에서 새로운 모델 구축 + model = YOLO('yolov8n-pose.pt') # 사전 학습된 모델 불러오기 (학습에 추천) + model = YOLO('yolov8n-pose.yaml').load('yolov8n-pose.pt') # YAML에서 구축하고 가중치 전달 + + # 모델 학습 + results = model.train(data='coco8-pose.yaml', epochs=100, imgsz=640) + ``` + === "CLI" + + ```bash + # YAML에서 새로운 모델 구축하고 처음부터 학습 시작 + yolo pose train data=coco8-pose.yaml model=yolov8n-pose.yaml epochs=100 imgsz=640 + + # 사전 학습된 *.pt 모델로부터 학습 시작 + yolo pose train data=coco8-pose.yaml model=yolov8n-pose.pt epochs=100 imgsz=640 + + # YAML에서 새로운 모델 구축하고 사전 학습된 가중치를 전달하여 학습 시작 + yolo pose train data=coco8-pose.yaml model=yolov8n-pose.yaml pretrained=yolov8n-pose.pt epochs=100 imgsz=640 + ``` + +### 데이터셋 형식 + +YOLO 포즈 데이터셋 형식에 대한 자세한 내용은 [데이터셋 가이드](../../datasets/pose/index.md)에서 찾아볼 수 있습니다. 기존 데이터셋을 다른 형식(예: COCO 등)에서 YOLO 형식으로 변환하려면 Ultralytics의 [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) 도구를 사용하세요. + +## 검증 + +학습된 YOLOv8n-pose 모델의 정확도를 COCO128-pose 데이터셋에서 검증하기. 모델은 학습 `data` 및 인수를 모델 속성으로 유지하기 때문에 인수를 전달할 필요가 없습니다. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # 모델 불러오기 + model = YOLO('yolov8n-pose.pt') # 공식 모델 불러오기 + model = YOLO('path/to/best.pt') # 사용자 모델 불러오기 + + # 모델 검증 + metrics = model.val() # 데이터셋 및 설정을 기억하므로 인수 필요 없음 + metrics.box.map # map50-95 + metrics.box.map50 # map50 + metrics.box.map75 # map75 + metrics.box.maps # 각 범주의 map50-95를 포함하는 리스트 + ``` + === "CLI" + + ```bash + yolo pose val model=yolov8n-pose.pt # 공식 모델 검증 + yolo pose val model=path/to/best.pt # 사용자 모델 검증 + ``` + +## 예측 + +학습된 YOLOv8n-pose 모델을 사용하여 이미지에 대한 예측 수행하기. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # 모델 불러오기 + model = YOLO('yolov8n-pose.pt') # 공식 모델 불러오기 + model = YOLO('path/to/best.pt') # 사용자 모델 불러오기 + + # 모델로 예측하기 + results = model('https://ultralytics.com/images/bus.jpg') # 이미지에서 예측 + ``` + === "CLI" + + ```bash + yolo pose predict model=yolov8n-pose.pt source='https://ultralytics.com/images/bus.jpg' # 공식 모델로 예측 + yolo pose predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # 사용자 모델로 예측 + ``` + +`predict` 모드의 전체 세부 정보는 [예측](https://docs.ultralytics.com/modes/predict/) 페이지에서 확인하세요. + +## 내보내기 + +YOLOv8n 포즈 모델을 ONNX, CoreML 등 다른 형식으로 내보내기. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # 모델 불러오기 + model = YOLO('yolov8n-pose.pt') # 공식 모델 불러오기 + model = YOLO('path/to/best.pt') # 사용자 학습 모델 불러오기 + + # 모델 내보내기 + model.export(format='onnx') + ``` + === "CLI" + + ```bash + yolo export model=yolov8n-pose.pt format=onnx # 공식 모델 내보내기 + yolo export model=path/to/best.pt format=onnx # 사용자 학습 모델 내보내기 + ``` + +YOLOv8-pose 내보내기 가능한 형식은 아래 표에 나열되어 있습니다. 내보낸 모델에서 직접 예측 또는 검증이 가능합니다, 예: `yolo predict model=yolov8n-pose.onnx`. 내보내기가 완료된 후 모델 사용 예제가 표시됩니다. + +| 형식 | `format` 인수 | 모델 | 메타데이터 | 인수 | +|--------------------------------------------------------------------|---------------|--------------------------------|-------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n-pose.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-pose.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-pose.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-pose_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-pose.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-pose.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-pose_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-pose.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-pose.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-pose_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-pose_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-pose_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-pose_ncnn_model/` | ✅ | `imgsz`, `half` | + +`export`의 전체 세부 정보는 [내보내기](https://docs.ultralytics.com/modes/export/) 페이지에서 확인하세요. diff --git a/docs/ko/tasks/segment.md b/docs/ko/tasks/segment.md new file mode 100644 index 00000000..c8c4a910 --- /dev/null +++ b/docs/ko/tasks/segment.md @@ -0,0 +1,188 @@ +--- +comments: true +description: Ultralytics YOLO를 이용한 인스턴스 세그멘테이션 모델 사용법 배우기. 훈련, 검증, 이미지 예측 및 모델 수출에 대한 지침. +keywords: yolov8, 인스턴스 세그멘테이션, Ultralytics, COCO 데이터셋, 이미지 세그멘테이션, 객체 탐지, 모델 훈련, 모델 검증, 이미지 예측, 모델 수출 +--- + +# 인스턴스 세그멘테이션 + +인스턴스 세그멘테이션 예시 + +인스턴스 세그멘테이션은 객체 탐지를 한 단계 더 발전시켜 이미지에서 각각의 개별 객체를 식별하고 이미지의 나머지 부분에서 분리하는 기술입니다. + +인스턴스 세그멘테이션 모델의 출력은 이미지의 각 객체를 윤곽하는 마스크나 윤곽 선뿐만 아니라 각 객체에 대한 클래스 레이블과 신뢰도 점수로 구성됩니다. 객체들이 이미지 안에서 어디에 있는지 뿐만 아니라 그들의 정확한 형태가 무엇인지 알아야 할 때 인스턴스 세그멘테이션이 유용합니다. + +

+
+ +
+ 시청하기: Python에서 사전 훈련된 Ultralytics YOLOv8 모델로 세그멘테이션 실행. +

+ +!!! tip "팁" + + YOLOv8 Segment 모델은 '-seg' 접미사를 사용하며 즉, `yolov8n-seg.pt`와 같이 [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml) 데이터셋에 사전 훈련되어 있습니다. + +## [모델](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8) + +여기에는 YOLOv8 사전 훈련 세그먼트 모델들이 나열되어 있습니다. Detect, Segment, Pose 모델들은 [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml) 데이터셋에 사전 훈련되어 있으며, Classify 모델들은 [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml) 데이터셋에 사전 훈련되어 있습니다. + +[모델](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models)은 첫 사용 시 Ultralytics의 최신 [릴리스](https://github.com/ultralytics/assets/releases)에서 자동으로 다운로드 됩니다. + +| 모델 | 크기
(픽셀) | mAP박스
50-95 | mAP마스크
50-95 | 속도
CPU ONNX
(밀리초) | 속도
A100 TensorRT
(밀리초) | 매개변수
(M) | FLOPs
(B) | +|----------------------------------------------------------------------------------------------|-----------------|---------------------|----------------------|------------------------------|-----------------------------------|------------------|-------------------| +| [YOLOv8n-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-seg.pt) | 640 | 36.7 | 30.5 | 96.1 | 1.21 | 3.4 | 12.6 | +| [YOLOv8s-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-seg.pt) | 640 | 44.6 | 36.8 | 155.7 | 1.47 | 11.8 | 42.6 | +| [YOLOv8m-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-seg.pt) | 640 | 49.9 | 40.8 | 317.0 | 2.18 | 27.3 | 110.2 | +| [YOLOv8l-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-seg.pt) | 640 | 52.3 | 42.6 | 572.4 | 2.79 | 46.0 | 220.5 | +| [YOLOv8x-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-seg.pt) | 640 | 53.4 | 43.4 | 712.1 | 4.02 | 71.8 | 344.1 | + +- **mAPval** 값들은 [COCO val2017](http://cocodataset.org) 데이터셋에서 단일 모델 단일 스케일로 얻은 값입니다. +
복제는 `yolo val segment data=coco.yaml device=0` 명령어로 실행할 수 있습니다. +- **속도**는 [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) 인스턴스를 이용하여 COCO 검증 이미지로 평균 내었습니다. +
복제는 `yolo val segment data=coco128-seg.yaml batch=1 device=0|cpu` 명령어로 실행할 수 있습니다. + +## 훈련 + +COCO128-seg 데이터셋에서 이미지 크기 640으로 YOLOv8n-seg을 100 에포크 동안 훈련합니다. 가능한 모든 인자 목록은 [설정](../../usage/cfg.md) 페이지에서 확인할 수 있습니다. + +!!! example "" + + === "파이썬" + + ```python + from ultralytics import YOLO + + # 모델을 불러옵니다 + model = YOLO('yolov8n-seg.yaml') # YAML에서 새로운 모델을 구성 + model = YOLO('yolov8n-seg.pt') # 사전 훈련된 모델을 불러옴 (훈련에 추천) + model = YOLO('yolov8n-seg.yaml').load('yolov8n.pt') # YAML에서 구성하고 가중치를 전달 + + # 모델을 훈련시킵니다 + results = model.train(data='coco128-seg.yaml', epochs=100, imgsz=640) + ``` + === "CLI" + + ```bash + # YAML에서 새로운 모델을 구성하고 처음부터 훈련을 시작합니다 + yolo segment train data=coco128-seg.yaml model=yolov8n-seg.yaml epochs=100 imgsz=640 + + # 사전 훈련된 *.pt 모델로 부터 훈련을 시작합니다 + yolo segment train data=coco128-seg.yaml model=yolov8n-seg.pt epochs=100 imgsz=640 + + # YAML에서 새로운 모델을 구성하고 사전 훈련된 가중치를 전달한 뒤 훈련을 시작합니다 + yolo segment train data=coco128-seg.yaml model=yolov8n-seg.yaml pretrained=yolov8n-seg.pt epochs=100 imgsz=640 + ``` + +### 데이터셋 형식 + +YOLO 세그멘테이션 데이터셋 형식은 [데이터셋 가이드](../../datasets/segment/index.md)에서 자세히 확인할 수 있습니다. 기존 데이터셋 (COCO 등)을 YOLO 형식으로 변환하려면 Ultralytics의 [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) 도구를 이용하세요. + +## 검증 + +COCO128-seg 데이터셋에서 훈련된 YOLOv8n-seg 모델의 정확도를 검증합니다. 모델은 훈련할 때의 `data`와 인자를 모델 속성으로 기억하기 때문에 별도의 인자를 전달할 필요가 없습니다. + +!!! example "" + + === "파이썬" + + ```python + from ultralytics import YOLO + + # 모델을 불러옵니다 + model = YOLO('yolov8n-seg.pt') # 공식 모델을 불러옴 + model = YOLO('path/to/best.pt') # 커스텀 모델을 불러옴 + + # 모델을 검증합니다 + metrics = model.val() # 데이터셋과 설정이 기억되어 있어 인자가 필요 없습니다 + metrics.box.map # map50-95(B) + metrics.box.map50 # map50(B) + metrics.box.map75 # map75(B) + metrics.box.maps # 각 카테고리별 map50-95(B) 리스트 + metrics.seg.map # map50-95(M) + metrics.seg.map50 # map50(M) + metrics.seg.map75 # map75(M) + metrics.seg.maps # 각 카테고리별 map50-95(M) 리스트 + ``` + === "CLI" + + ```bash + yolo segment val model=yolov8n-seg.pt # 공식 모델로 검증 + yolo segment val model=path/to/best.pt # 커스텀 모델로 검증 + ``` + +## 예측 + +훈련된 YOLOv8n-seg 모델을 사용하여 이미지에 대한 예측을 실행합니다. + +!!! example "" + + === "파이썬" + + ```python + from ultralytics import YOLO + + # 모델을 불러옵니다 + model = YOLO('yolov8n-seg.pt') # 공식 모델을 불러옴 + model = YOLO('path/to/best.pt') # 커스텀 모델을 불러옴 + + # 모델로 예측을 진행합니다 + results = model('https://ultralytics.com/images/bus.jpg') # 이미지에 대한 예측 + ``` + === "CLI" + + ```bash + yolo segment predict model=yolov8n-seg.pt source='https://ultralytics.com/images/bus.jpg' # 공식 모델로 예측 실행 + yolo segment predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # 커스텀 모델로 예측 실행 + ``` + +`predict` 모드의 전체 세부 사항은 [예측](https://docs.ultralytics.com/modes/predict/) 페이지에서 확인할 수 있습니다. + +## 수출 + +ONNX, CoreML 등과 같은 다른 형식으로 YOLOv8n-seg 모델을 수출합니다. + +!!! example "" + + === "파이썬" + + ```python + from ultralytics import YOLO + + # 모델을 불러옵니다 + model = YOLO('yolov8n-seg.pt') # 공식 모델을 불러옴 + model = YOLO('path/to/best.pt') # 커스텀 훈련 모델을 불러옴 + + # 모델을 수출합니다 + model.export(format='onnx') + ``` + === "CLI" + + ```bash + yolo export model=yolov8n-seg.pt format=onnx # 공식 모델을 수출합니다 + yolo export model=path/to/best.pt format=onnx # 커스텀 훈련 모델을 수출합니다 + ``` + +아래 표에 나열된 것은 가능한 YOLOv8-seg 수출 형식입니다. 수출 완료 후 모델 사용 예는 모델을 직접 예측하거나 검증할 때 사용할 수 있습니다. + +| 형식 | `format` 인자 | 모델 | 메타데이터 | 인자 | +|--------------------------------------------------------------------|---------------|-------------------------------|-------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n-seg.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-seg.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-seg.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-seg_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-seg.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-seg.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-seg_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-seg.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-seg.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-seg_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-seg_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-seg_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-seg_ncnn_model/` | ✅ | `imgsz`, `half` | + +`export`의 전체 세부 사항은 [수출](https://docs.ultralytics.com/modes/export/) 페이지에서 확인할 수 있습니다. diff --git a/docs/mkdocs.yml b/docs/mkdocs.yml index b85c0d4a..19e3c5b3 100644 --- a/docs/mkdocs.yml +++ b/docs/mkdocs.yml @@ -1,8 +1,8 @@ # Ultralytics YOLO 🚀, AGPL-3.0 license site_name: Ultralytics YOLOv8 Docs -site_url: https://docs.ultralytics.com site_description: Explore Ultralytics YOLOv8, a cutting-edge real-time object detection and image segmentation model for various applications and hardware platforms. +site_url: https://docs.ultralytics.com site_author: Ultralytics repo_url: https://github.com/ultralytics/ultralytics edit_uri: https://github.com/ultralytics/ultralytics/tree/main/docs/en/ @@ -65,12 +65,33 @@ extra: provider: google property: G-2M5EHKC0BH alternate: # language drop-down - - name: English + - name: 🇬🇧 English link: / lang: en - - name: 简体中文 + - name: 🇨🇳 简体中文 link: /zh/ lang: zh + - name: 🇰🇷 한국어 + link: /ko/ + lang: ko + - name: 🇯🇵 日本語 + link: /ja/ + lang: ja + - name: 🇷🇺 Русский + link: /ru/ + lang: ru + - name: 🇩🇪 Deutsch + link: /de/ + lang: de + - name: 🇫🇷 Français + link: /fr/ + lang: fr + - name: 🇪🇸 Español + link: /es/ + lang: es + - name: 🇵🇹 Português + link: /pt/ + lang: pt social: - icon: fontawesome/brands/github link: https://github.com/ultralytics diff --git a/docs/mkdocs_de.yml b/docs/mkdocs_de.yml new file mode 100644 index 00000000..de6b1525 --- /dev/null +++ b/docs/mkdocs_de.yml @@ -0,0 +1,187 @@ +# Ultralytics YOLO 🚀, AGPL-3.0 license + +site_name: Ultralytics YOLOv8 Dokumentation +site_description: Entdecken Sie Ultralytics YOLOv8, ein hochmodernes Echtzeit-Objekterkennungs- und Bildsegmentierungsmodell für verschiedene Anwendungen und Hardware-Plattformen. +site_url: https://docs.ultralytics.com/de/ +site_author: Ultralytics +repo_url: https://github.com/ultralytics/ultralytics +edit_uri: https://github.com/ultralytics/ultralytics/tree/main/docs/de/ +repo_name: ultralytics/ultralytics +remote_name: https://github.com/ultralytics/docs +docs_dir: 'de/' # where to find the markdown files +site_dir: '../site/de' # where to publish to + +theme: + name: material + language: de + custom_dir: overrides/ + logo: https://github.com/ultralytics/assets/raw/main/logo/Ultralytics_Logotype_Reverse.svg + favicon: assets/favicon.ico + icon: + repo: fontawesome/brands/github + # font: # disabled for faster page load times + # text: Helvetica + # code: Roboto Mono + palette: + - scheme: default # light mode + # primary: grey + toggle: + icon: material/toggle-switch + name: Switch to dark mode + - scheme: slate # dark mode + # primary: black + toggle: + icon: material/toggle-switch-off-outline + name: Switch to light mode + features: + - announce.dismiss + - content.action.edit + - content.code.annotate + - content.code.copy + - content.tooltips + - search.highlight + - search.share + - search.suggest + - toc.follow + - navigation.top + - navigation.tabs + - navigation.tabs.sticky + - navigation.prune + - navigation.footer + - navigation.tracking + - navigation.instant + - navigation.instant.progress + - navigation.indexes + - navigation.sections + - content.tabs.link # all code tabs change simultaneously + +# Customization +copyright: © 2023 Ultralytics Inc. All rights reserved. +extra: + # version: + # provider: mike # version drop-down menu + robots: robots.txt + analytics: + provider: google + property: G-2M5EHKC0BH + alternate: # language drop-down + - name: 🇬🇧 English + link: / + lang: en + - name: 🇨🇳 简体中文 + link: /zh/ + lang: zh + - name: 🇰🇷 한국어 + link: /ko/ + lang: ko + - name: 🇯🇵 日本語 + link: /ja/ + lang: ja + - name: 🇷🇺 Русский + link: /ru/ + lang: ru + - name: 🇩🇪 Deutsch + link: /de/ + lang: de + - name: 🇫🇷 Français + link: /fr/ + lang: fr + - name: 🇪🇸 Español + link: /es/ + lang: es + - name: 🇵🇹 Português + link: /pt/ + lang: pt + social: + - icon: fontawesome/brands/github + link: https://github.com/ultralytics + - icon: fontawesome/brands/linkedin + link: https://www.linkedin.com/company/ultralytics/ + - icon: fontawesome/brands/twitter + link: https://twitter.com/ultralytics + - icon: fontawesome/brands/youtube + link: https://www.youtube.com/ultralytics + - icon: fontawesome/brands/docker + link: https://hub.docker.com/r/ultralytics/ultralytics/ + - icon: fontawesome/brands/python + link: https://pypi.org/project/ultralytics/ + - icon: fontawesome/brands/discord + link: https://ultralytics.com/discord + +extra_css: + - 'stylesheets/style.css' + +markdown_extensions: + - admonition + - md_in_html + - tables + - attr_list + - def_list + - pymdownx.critic + - pymdownx.caret + - pymdownx.keys + - pymdownx.mark + - pymdownx.tilde + - pymdownx.details + - pymdownx.superfences + - pymdownx.inlinehilite + - pymdownx.highlight: + anchor_linenums: true + - pymdownx.snippets: + base_path: ./ + - pymdownx.emoji: + emoji_index: !!python/name:material.extensions.emoji.twemoji + emoji_generator: !!python/name:material.extensions.emoji.to_svg + - pymdownx.tabbed: + alternate_style: true + + +# Primary navigation --------------------------------------------------------------------------------------------------- +nav: + - Página Inicial: + - Página Inicial: index.md + - Início Rápido: quickstart.md + - Modos: + - modes/index.md + - Treinamento: modes/train.md + - Validação: modes/val.md + - Previsão: modes/predict.md + - Exportação: modes/export.md + - Rastreamento: modes/track.md + - Benchmarking: modes/benchmark.md + - Tarefas: + - tasks/index.md + - Detecção: tasks/detect.md + - Segmentação: tasks/segment.md + - Classificação: tasks/classify.md + - Pose: tasks/pose.md + - Início Rápido: quickstart.md + - Modos: + - modes/index.md + - Treinamento: modes/train.md + - Validação: modes/val.md + - Previsão: modes/predict.md + - Exportação: modes/export.md + - Rastreamento: modes/track.md + - Benchmarking: modes/benchmark.md + - Tarefas: + - tasks/index.md + - Detecção: tasks/detect.md + - Segmentação: tasks/segment.md + - Classificação: tasks/classify.md + - Pose: tasks/pose.md + - Modelos: + - models/index.md + - Conjuntos de Dados: + - datasets/index.md + + +# Plugins including 301 redirects navigation --------------------------------------------------------------------------- +plugins: + - search: + lang: de + - ultralytics: + add_desc: False + add_image: True + add_share_buttons: True + default_image: https://github.com/ultralytics/ultralytics/assets/26833433/6d09221c-c52a-4234-9a5d-b862e93c6529 diff --git a/docs/mkdocs_es.yml b/docs/mkdocs_es.yml new file mode 100644 index 00000000..28d100b3 --- /dev/null +++ b/docs/mkdocs_es.yml @@ -0,0 +1,186 @@ +# Ultralytics YOLO 🚀, AGPL-3.0 license + +site_name: Documentación Ultralytics YOLOv8 +site_description: Explore Ultralytics YOLOv8, un modelo avanzado de detección de objetos e segmentación de imágenes en tiempo real para diversas aplicaciones y plataformas de hardware. +site_url: https://docs.ultralytics.com/es/ +site_author: Ultralytics +repo_url: https://github.com/ultralytics/ultralytics +edit_uri: https://github.com/ultralytics/ultralytics/tree/main/docs/es/ +repo_name: ultralytics/ultralytics +remote_name: https://github.com/ultralytics/docs +docs_dir: 'es/' # where to find the markdown files +site_dir: '../site/es' # where to publish to + +theme: + name: material + language: es + custom_dir: overrides/ + logo: https://github.com/ultralytics/assets/raw/main/logo/Ultralytics_Logotype_Reverse.svg + favicon: assets/favicon.ico + icon: + repo: fontawesome/brands/github + # font: # disabled for faster page load times + # text: Helvetica + # code: Roboto Mono + palette: + - scheme: default # light mode + # primary: grey + toggle: + icon: material/toggle-switch + name: Switch to dark mode + - scheme: slate # dark mode + # primary: black + toggle: + icon: material/toggle-switch-off-outline + name: Switch to light mode + features: + - announce.dismiss + - content.action.edit + - content.code.annotate + - content.code.copy + - content.tooltips + - search.highlight + - search.share + - search.suggest + - toc.follow + - navigation.top + - navigation.tabs + - navigation.tabs.sticky + - navigation.prune + - navigation.footer + - navigation.tracking + - navigation.instant + - navigation.instant.progress + - navigation.indexes + - navigation.sections + - content.tabs.link # all code tabs change simultaneously + +# Customization +copyright: © 2023 Ultralytics Inc. All rights reserved. +extra: + # version: + # provider: mike # version drop-down menu + robots: robots.txt + analytics: + provider: google + property: G-2M5EHKC0BH + alternate: # language drop-down + - name: 🇬🇧 English + link: / + lang: en + - name: 🇨🇳 简体中文 + link: /zh/ + lang: zh + - name: 🇰🇷 한국어 + link: /ko/ + lang: ko + - name: 🇯🇵 日本語 + link: /ja/ + lang: ja + - name: 🇷🇺 Русский + link: /ru/ + lang: ru + - name: 🇩🇪 Deutsch + link: /de/ + lang: de + - name: 🇫🇷 Français + link: /fr/ + lang: fr + - name: 🇪🇸 Español + link: /es/ + lang: es + - name: 🇵🇹 Português + link: /pt/ + lang: pt + social: + - icon: fontawesome/brands/github + link: https://github.com/ultralytics + - icon: fontawesome/brands/linkedin + link: https://www.linkedin.com/company/ultralytics/ + - icon: fontawesome/brands/twitter + link: https://twitter.com/ultralytics + - icon: fontawesome/brands/youtube + link: https://www.youtube.com/ultralytics + - icon: fontawesome/brands/docker + link: https://hub.docker.com/r/ultralytics/ultralytics/ + - icon: fontawesome/brands/python + link: https://pypi.org/project/ultralytics/ + - icon: fontawesome/brands/discord + link: https://ultralytics.com/discord + +extra_css: + - 'stylesheets/style.css' + +markdown_extensions: + - admonition + - md_in_html + - tables + - attr_list + - def_list + - pymdownx.critic + - pymdownx.caret + - pymdownx.keys + - pymdownx.mark + - pymdownx.tilde + - pymdownx.details + - pymdownx.superfences + - pymdownx.inlinehilite + - pymdownx.highlight: + anchor_linenums: true + - pymdownx.snippets: + base_path: ./ + - pymdownx.emoji: + emoji_index: !!python/name:material.extensions.emoji.twemoji + emoji_generator: !!python/name:material.extensions.emoji.to_svg + - pymdownx.tabbed: + alternate_style: true + + +# Primary navigation --------------------------------------------------------------------------------------------------- +nav: + - Inicio: + - Inicio: index.md + - Inicio rápido: quickstart.md + - Modos: + - modes/index.md + - Entrenamiento: modes/train.md + - Validación: modes/val.md + - Predicción: modes/predict.md + - Exportar: modes/export.md + - Seguimiento: modes/track.md + - Benchmarking: modes/benchmark.md + - Tareas: + - tasks/index.md + - Detección: tasks/detect.md + - Segmentación: tasks/segment.md + - Clasificación: tasks/classify.md + - Pose: tasks/pose.md + - Inicio rápido: quickstart.md + - Modos: + - modes/index.md + - Entrenamiento: modes/train.md + - Validación: modes/val.md + - Predicción: modes/predict.md + - Exportar: modes/export.md + - Seguimiento: modes/track.md + - Benchmarking: modes/benchmark.md + - Tareas: + - tasks/index.md + - Detección: tasks/detect.md + - Segmentación: tasks/segment.md + - Clasificación: tasks/classify.md + - Pose: tasks/pose.md + - Modelos: + - models/index.md + - Conjuntos de datos: + - datasets/index.md + +# Plugins including 301 redirects navigation --------------------------------------------------------------------------- +plugins: + - search: + lang: es + - ultralytics: + add_desc: False + add_image: True + add_share_buttons: True + default_image: https://github.com/ultralytics/ultralytics/assets/26833433/6d09221c-c52a-4234-9a5d-b862e93c6529 diff --git a/docs/mkdocs_fr.yml b/docs/mkdocs_fr.yml new file mode 100644 index 00000000..14359cfa --- /dev/null +++ b/docs/mkdocs_fr.yml @@ -0,0 +1,186 @@ +# Ultralytics YOLO 🚀, AGPL-3.0 license + +site_name: Documentation Ultralytics YOLOv8 +site_description: Explorez Ultralytics YOLOv8, un modèle de pointe pour la détection d'objets et la segmentation d'image en temps réel, adapté à diverses applications et plateformes matérielles. +site_url: https://docs.ultralytics.com/fr/ +site_author: Ultralytics +repo_url: https://github.com/ultralytics/ultralytics +edit_uri: https://github.com/ultralytics/ultralytics/tree/main/docs/fr/ +repo_name: ultralytics/ultralytics +remote_name: https://github.com/ultralytics/docs +docs_dir: 'fr/' # where to find the markdown files +site_dir: '../site/fr' # where to publish to + +theme: + name: material + language: fr + custom_dir: overrides/ + logo: https://github.com/ultralytics/assets/raw/main/logo/Ultralytics_Logotype_Reverse.svg + favicon: assets/favicon.ico + icon: + repo: fontawesome/brands/github + # font: # disabled for faster page load times + # text: Helvetica + # code: Roboto Mono + palette: + - scheme: default # light mode + # primary: grey + toggle: + icon: material/toggle-switch + name: Switch to dark mode + - scheme: slate # dark mode + # primary: black + toggle: + icon: material/toggle-switch-off-outline + name: Switch to light mode + features: + - announce.dismiss + - content.action.edit + - content.code.annotate + - content.code.copy + - content.tooltips + - search.highlight + - search.share + - search.suggest + - toc.follow + - navigation.top + - navigation.tabs + - navigation.tabs.sticky + - navigation.prune + - navigation.footer + - navigation.tracking + - navigation.instant + - navigation.instant.progress + - navigation.indexes + - navigation.sections + - content.tabs.link # all code tabs change simultaneously + +# Customization +copyright: © 2023 Ultralytics Inc. All rights reserved. +extra: + # version: + # provider: mike # version drop-down menu + robots: robots.txt + analytics: + provider: google + property: G-2M5EHKC0BH + alternate: # language drop-down + - name: 🇬🇧 English + link: / + lang: en + - name: 🇨🇳 简体中文 + link: /zh/ + lang: zh + - name: 🇰🇷 한국어 + link: /ko/ + lang: ko + - name: 🇯🇵 日本語 + link: /ja/ + lang: ja + - name: 🇷🇺 Русский + link: /ru/ + lang: ru + - name: 🇩🇪 Deutsch + link: /de/ + lang: de + - name: 🇫🇷 Français + link: /fr/ + lang: fr + - name: 🇪🇸 Español + link: /es/ + lang: es + - name: 🇵🇹 Português + link: /pt/ + lang: pt + social: + - icon: fontawesome/brands/github + link: https://github.com/ultralytics + - icon: fontawesome/brands/linkedin + link: https://www.linkedin.com/company/ultralytics/ + - icon: fontawesome/brands/twitter + link: https://twitter.com/ultralytics + - icon: fontawesome/brands/youtube + link: https://www.youtube.com/ultralytics + - icon: fontawesome/brands/docker + link: https://hub.docker.com/r/ultralytics/ultralytics/ + - icon: fontawesome/brands/python + link: https://pypi.org/project/ultralytics/ + - icon: fontawesome/brands/discord + link: https://ultralytics.com/discord + +extra_css: + - 'stylesheets/style.css' + +markdown_extensions: + - admonition + - md_in_html + - tables + - attr_list + - def_list + - pymdownx.critic + - pymdownx.caret + - pymdownx.keys + - pymdownx.mark + - pymdownx.tilde + - pymdownx.details + - pymdownx.superfences + - pymdownx.inlinehilite + - pymdownx.highlight: + anchor_linenums: true + - pymdownx.snippets: + base_path: ./ + - pymdownx.emoji: + emoji_index: !!python/name:material.extensions.emoji.twemoji + emoji_generator: !!python/name:material.extensions.emoji.to_svg + - pymdownx.tabbed: + alternate_style: true + + +# Primary navigation --------------------------------------------------------------------------------------------------- +nav: + - Accueil: + - Accueil: index.md + - Démarrage rapide: quickstart.md + - Modes: + - modes/index.md + - Entraînement: modes/train.md + - Validation: modes/val.md + - Prédiction: modes/predict.md + - Exportation: modes/export.md + - Suivi: modes/track.md + - Benchmarking: modes/benchmark.md + - Tâches: + - tasks/index.md + - Détection: tasks/detect.md + - Segmentation: tasks/segment.md + - Classification: tasks/classify.md + - Pose: tasks/pose.md + - Démarrage rapide: quickstart.md + - Modes: + - modes/index.md + - Entraînement: modes/train.md + - Validation: modes/val.md + - Prédiction: modes/predict.md + - Exportation: modes/export.md + - Suivi: modes/track.md + - Benchmarking: modes/benchmark.md + - Tâches: + - tasks/index.md + - Détection: tasks/detect.md + - Segmentation: tasks/segment.md + - Classification: tasks/classify.md + - Pose: tasks/pose.md + - Modèles: + - models/index.md + - Jeux de données: + - datasets/index.md + +# Plugins including 301 redirects navigation --------------------------------------------------------------------------- +plugins: + - search: + lang: fr + - ultralytics: + add_desc: False + add_image: True + add_share_buttons: True + default_image: https://github.com/ultralytics/ultralytics/assets/26833433/6d09221c-c52a-4234-9a5d-b862e93c6529 diff --git a/docs/mkdocs_ja.yml b/docs/mkdocs_ja.yml new file mode 100644 index 00000000..31cf7428 --- /dev/null +++ b/docs/mkdocs_ja.yml @@ -0,0 +1,186 @@ +# Ultralytics YOLO 🚀, AGPL-3.0 license + +site_name: Ultralytics YOLOv8 ドキュメント +site_description: Ultralytics YOLOv8を探求してください。これは、さまざまなアプリケーションおよびハードウェアプラットフォームに適した最先端のリアルタイム物体検出および画像分割モデルです。 +site_url: https://docs.ultralytics.com/ja/ +site_author: Ultralytics +repo_url: https://github.com/ultralytics/ultralytics +edit_uri: https://github.com/ultralytics/ultralytics/tree/main/docs/ja/ +repo_name: ultralytics/ultralytics +remote_name: https://github.com/ultralytics/docs +docs_dir: 'ja/' # where to find the markdown files +site_dir: '../site/ja' # where to publish to + +theme: + name: material + language: ja + custom_dir: overrides/ + logo: https://github.com/ultralytics/assets/raw/main/logo/Ultralytics_Logotype_Reverse.svg + favicon: assets/favicon.ico + icon: + repo: fontawesome/brands/github + # font: # disabled for faster page load times + # text: Helvetica + # code: Roboto Mono + palette: + - scheme: default # light mode + # primary: grey + toggle: + icon: material/toggle-switch + name: Switch to dark mode + - scheme: slate # dark mode + # primary: black + toggle: + icon: material/toggle-switch-off-outline + name: Switch to light mode + features: + - announce.dismiss + - content.action.edit + - content.code.annotate + - content.code.copy + - content.tooltips + - search.highlight + - search.share + - search.suggest + - toc.follow + - navigation.top + - navigation.tabs + - navigation.tabs.sticky + - navigation.prune + - navigation.footer + - navigation.tracking + - navigation.instant + - navigation.instant.progress + - navigation.indexes + - navigation.sections + - content.tabs.link # all code tabs change simultaneously + +# Customization +copyright: © 2023 Ultralytics Inc. All rights reserved. +extra: + # version: + # provider: mike # version drop-down menu + robots: robots.txt + analytics: + provider: google + property: G-2M5EHKC0BH + alternate: # language drop-down + - name: 🇬🇧 English + link: / + lang: en + - name: 🇨🇳 简体中文 + link: /zh/ + lang: zh + - name: 🇰🇷 한국어 + link: /ko/ + lang: ko + - name: 🇯🇵 日本語 + link: /ja/ + lang: ja + - name: 🇷🇺 Русский + link: /ru/ + lang: ru + - name: 🇩🇪 Deutsch + link: /de/ + lang: de + - name: 🇫🇷 Français + link: /fr/ + lang: fr + - name: 🇪🇸 Español + link: /es/ + lang: es + - name: 🇵🇹 Português + link: /pt/ + lang: pt + social: + - icon: fontawesome/brands/github + link: https://github.com/ultralytics + - icon: fontawesome/brands/linkedin + link: https://www.linkedin.com/company/ultralytics/ + - icon: fontawesome/brands/twitter + link: https://twitter.com/ultralytics + - icon: fontawesome/brands/youtube + link: https://www.youtube.com/ultralytics + - icon: fontawesome/brands/docker + link: https://hub.docker.com/r/ultralytics/ultralytics/ + - icon: fontawesome/brands/python + link: https://pypi.org/project/ultralytics/ + - icon: fontawesome/brands/discord + link: https://ultralytics.com/discord + +extra_css: + - 'stylesheets/style.css' + +markdown_extensions: + - admonition + - md_in_html + - tables + - attr_list + - def_list + - pymdownx.critic + - pymdownx.caret + - pymdownx.keys + - pymdownx.mark + - pymdownx.tilde + - pymdownx.details + - pymdownx.superfences + - pymdownx.inlinehilite + - pymdownx.highlight: + anchor_linenums: true + - pymdownx.snippets: + base_path: ./ + - pymdownx.emoji: + emoji_index: !!python/name:material.extensions.emoji.twemoji + emoji_generator: !!python/name:material.extensions.emoji.to_svg + - pymdownx.tabbed: + alternate_style: true + + +# Primary navigation --------------------------------------------------------------------------------------------------- +nav: + - ホーム: + - ホーム: index.md + - クイックスタート: quickstart.md + - モード: + - modes/index.md + - トレーニング: modes/train.md + - 検証: modes/val.md + - 予測: modes/predict.md + - エクスポート: modes/export.md + - トラッキング: modes/track.md + - ベンチマーク: modes/benchmark.md + - タスク: + - tasks/index.md + - 検出: tasks/detect.md + - セグメンテーション: tasks/segment.md + - 分類: tasks/classify.md + - ポーズ: tasks/pose.md + - クイックスタート: quickstart.md + - モード: + - modes/index.md + - トレーニング: modes/train.md + - 検証: modes/val.md + - 予測: modes/predict.md + - エクスポート: modes/export.md + - トラッキング: modes/track.md + - ベンチマーク: modes/benchmark.md + - タスク: + - tasks/index.md + - 検出: tasks/detect.md + - セグメンテーション: tasks/segment.md + - 分類: tasks/classify.md + - ポーズ: tasks/pose.md + - モデル: + - models/index.md + - データセット: + - datasets/index.md + +# Plugins including 301 redirects navigation --------------------------------------------------------------------------- +plugins: + - search: + lang: ja + - ultralytics: + add_desc: False + add_image: True + add_share_buttons: True + default_image: https://github.com/ultralytics/ultralytics/assets/26833433/6d09221c-c52a-4234-9a5d-b862e93c6529 diff --git a/docs/mkdocs_ko.yml b/docs/mkdocs_ko.yml new file mode 100644 index 00000000..046b1b30 --- /dev/null +++ b/docs/mkdocs_ko.yml @@ -0,0 +1,186 @@ +# Ultralytics YOLO 🚀, AGPL-3.0 license + +site_name: Ultralytics YOLOv8 문서 +site_description: Ultralytics YOLOv8을 탐색하세요. 이는 다양한 애플리케이션 및 하드웨어 플랫폼을 위한 최첨단 실시간 객체 감지 및 이미지 분할 모델입니다. +site_url: https://docs.ultralytics.com/ko/ +site_author: Ultralytics +repo_url: https://github.com/ultralytics/ultralytics +edit_uri: https://github.com/ultralytics/ultralytics/tree/main/docs/ko/ +repo_name: ultralytics/ultralytics +remote_name: https://github.com/ultralytics/docs +docs_dir: 'ko/' # where to find the markdown files +site_dir: '../site/ko' # where to publish to + +theme: + name: material + language: ko + custom_dir: overrides/ + logo: https://github.com/ultralytics/assets/raw/main/logo/Ultralytics_Logotype_Reverse.svg + favicon: assets/favicon.ico + icon: + repo: fontawesome/brands/github + # font: # disabled for faster page load times + # text: Helvetica + # code: Roboto Mono + palette: + - scheme: default # light mode + # primary: grey + toggle: + icon: material/toggle-switch + name: Switch to dark mode + - scheme: slate # dark mode + # primary: black + toggle: + icon: material/toggle-switch-off-outline + name: Switch to light mode + features: + - announce.dismiss + - content.action.edit + - content.code.annotate + - content.code.copy + - content.tooltips + - search.highlight + - search.share + - search.suggest + - toc.follow + - navigation.top + - navigation.tabs + - navigation.tabs.sticky + - navigation.prune + - navigation.footer + - navigation.tracking + - navigation.instant + - navigation.instant.progress + - navigation.indexes + - navigation.sections + - content.tabs.link # all code tabs change simultaneously + +# Customization +copyright: © 2023 Ultralytics Inc. All rights reserved. +extra: + # version: + # provider: mike # version drop-down menu + robots: robots.txt + analytics: + provider: google + property: G-2M5EHKC0BH + alternate: # language drop-down + - name: 🇬🇧 English + link: / + lang: en + - name: 🇨🇳 简体中文 + link: /zh/ + lang: zh + - name: 🇰🇷 한국어 + link: /ko/ + lang: ko + - name: 🇯🇵 日本語 + link: /ja/ + lang: ja + - name: 🇷🇺 Русский + link: /ru/ + lang: ru + - name: 🇩🇪 Deutsch + link: /de/ + lang: de + - name: 🇫🇷 Français + link: /fr/ + lang: fr + - name: 🇪🇸 Español + link: /es/ + lang: es + - name: 🇵🇹 Português + link: /pt/ + lang: pt + social: + - icon: fontawesome/brands/github + link: https://github.com/ultralytics + - icon: fontawesome/brands/linkedin + link: https://www.linkedin.com/company/ultralytics/ + - icon: fontawesome/brands/twitter + link: https://twitter.com/ultralytics + - icon: fontawesome/brands/youtube + link: https://www.youtube.com/ultralytics + - icon: fontawesome/brands/docker + link: https://hub.docker.com/r/ultralytics/ultralytics/ + - icon: fontawesome/brands/python + link: https://pypi.org/project/ultralytics/ + - icon: fontawesome/brands/discord + link: https://ultralytics.com/discord + +extra_css: + - 'stylesheets/style.css' + +markdown_extensions: + - admonition + - md_in_html + - tables + - attr_list + - def_list + - pymdownx.critic + - pymdownx.caret + - pymdownx.keys + - pymdownx.mark + - pymdownx.tilde + - pymdownx.details + - pymdownx.superfences + - pymdownx.inlinehilite + - pymdownx.highlight: + anchor_linenums: true + - pymdownx.snippets: + base_path: ./ + - pymdownx.emoji: + emoji_index: !!python/name:material.extensions.emoji.twemoji + emoji_generator: !!python/name:material.extensions.emoji.to_svg + - pymdownx.tabbed: + alternate_style: true + + +# Primary navigation --------------------------------------------------------------------------------------------------- +nav: + - 홈: + - 홈: index.md + - 빠른 시작: quickstart.md + - 모드: + - modes/index.md + - 훈련: modes/train.md + - 검증: modes/val.md + - 예측: modes/predict.md + - 내보내기: modes/export.md + - 추적: modes/track.md + - 벤치마크: modes/benchmark.md + - 작업: + - tasks/index.md + - 감지: tasks/detect.md + - 분할: tasks/segment.md + - 분류: tasks/classify.md + - 포즈: tasks/pose.md + - 빠른 시작: quickstart.md + - 모드: + - modes/index.md + - 훈련: modes/train.md + - 검증: modes/val.md + - 예측: modes/predict.md + - 내보내기: modes/export.md + - 추적: modes/track.md + - 벤치마크: modes/benchmark.md + - 작업: + - tasks/index.md + - 감지: tasks/detect.md + - 분할: tasks/segment.md + - 분류: tasks/classify.md + - 포즈: tasks/pose.md + - 모델: + - models/index.md + - 데이터셋: + - datasets/index.md + +# Plugins including 301 redirects navigation --------------------------------------------------------------------------- +plugins: + - search: + lang: ko + - ultralytics: + add_desc: False + add_image: True + add_share_buttons: True + default_image: https://github.com/ultralytics/ultralytics/assets/26833433/6d09221c-c52a-4234-9a5d-b862e93c6529 diff --git a/docs/mkdocs_pt.yml b/docs/mkdocs_pt.yml new file mode 100644 index 00000000..00e44904 --- /dev/null +++ b/docs/mkdocs_pt.yml @@ -0,0 +1,186 @@ +# Ultralytics YOLO 🚀, AGPL-3.0 license + +site_name: Documentação Ultralytics YOLOv8 +site_description: Explore o Ultralytics YOLOv8, um modelo avançado de detecção de objetos e segmentação de imagem em tempo real, adequado para várias aplicações e plataformas de hardware. +site_url: https://docs.ultralytics.com/pt/ +site_author: Ultralytics +repo_url: https://github.com/ultralytics/ultralytics +edit_uri: https://github.com/ultralytics/ultralytics/tree/main/docs/pt/ +repo_name: ultralytics/ultralytics +remote_name: https://github.com/ultralytics/docs +docs_dir: 'pt/' # where to find the markdown files +site_dir: '../site/pt' # where to publish to + +theme: + name: material + language: pt + custom_dir: overrides/ + logo: https://github.com/ultralytics/assets/raw/main/logo/Ultralytics_Logotype_Reverse.svg + favicon: assets/favicon.ico + icon: + repo: fontawesome/brands/github + # font: # disabled for faster page load times + # text: Helvetica + # code: Roboto Mono + palette: + - scheme: default # light mode + # primary: grey + toggle: + icon: material/toggle-switch + name: Switch to dark mode + - scheme: slate # dark mode + # primary: black + toggle: + icon: material/toggle-switch-off-outline + name: Switch to light mode + features: + - announce.dismiss + - content.action.edit + - content.code.annotate + - content.code.copy + - content.tooltips + - search.highlight + - search.share + - search.suggest + - toc.follow + - navigation.top + - navigation.tabs + - navigation.tabs.sticky + - navigation.prune + - navigation.footer + - navigation.tracking + - navigation.instant + - navigation.instant.progress + - navigation.indexes + - navigation.sections + - content.tabs.link # all code tabs change simultaneously + +# Customization +copyright: © 2023 Ultralytics Inc. All rights reserved. +extra: + # version: + # provider: mike # version drop-down menu + robots: robots.txt + analytics: + provider: google + property: G-2M5EHKC0BH + alternate: # language drop-down + - name: 🇬🇧 English + link: / + lang: en + - name: 🇨🇳 简体中文 + link: /zh/ + lang: zh + - name: 🇰🇷 한국어 + link: /ko/ + lang: ko + - name: 🇯🇵 日本語 + link: /ja/ + lang: ja + - name: 🇷🇺 Русский + link: /ru/ + lang: ru + - name: 🇩🇪 Deutsch + link: /de/ + lang: de + - name: 🇫🇷 Français + link: /fr/ + lang: fr + - name: 🇪🇸 Español + link: /es/ + lang: es + - name: 🇵🇹 Português + link: /pt/ + lang: pt + social: + - icon: fontawesome/brands/github + link: https://github.com/ultralytics + - icon: fontawesome/brands/linkedin + link: https://www.linkedin.com/company/ultralytics/ + - icon: fontawesome/brands/twitter + link: https://twitter.com/ultralytics + - icon: fontawesome/brands/youtube + link: https://www.youtube.com/ultralytics + - icon: fontawesome/brands/docker + link: https://hub.docker.com/r/ultralytics/ultralytics/ + - icon: fontawesome/brands/python + link: https://pypi.org/project/ultralytics/ + - icon: fontawesome/brands/discord + link: https://ultralytics.com/discord + +extra_css: + - 'stylesheets/style.css' + +markdown_extensions: + - admonition + - md_in_html + - tables + - attr_list + - def_list + - pymdownx.critic + - pymdownx.caret + - pymdownx.keys + - pymdownx.mark + - pymdownx.tilde + - pymdownx.details + - pymdownx.superfences + - pymdownx.inlinehilite + - pymdownx.highlight: + anchor_linenums: true + - pymdownx.snippets: + base_path: ./ + - pymdownx.emoji: + emoji_index: !!python/name:material.extensions.emoji.twemoji + emoji_generator: !!python/name:material.extensions.emoji.to_svg + - pymdownx.tabbed: + alternate_style: true + + +# Primary navigation --------------------------------------------------------------------------------------------------- +nav: + - Startseite: + - Startseite: index.md + - Schnellstart: quickstart.md + - Modi: + - modes/index.md + - Training: modes/train.md + - Validierung: modes/val.md + - Vorhersage: modes/predict.md + - Exportieren: modes/export.md + - Verfolgen: modes/track.md + - Benchmarking: modes/benchmark.md + - Aufgaben: + - tasks/index.md + - Erkennung: tasks/detect.md + - Segmentierung: tasks/segment.md + - Klassifizierung: tasks/classify.md + - Pose: tasks/pose.md + - Schnellstart: quickstart.md + - Modi: + - modes/index.md + - Training: modes/train.md + - Validierung: modes/val.md + - Vorhersage: modes/predict.md + - Exportieren: modes/export.md + - Verfolgen: modes/track.md + - Benchmarking: modes/benchmark.md + - Aufgaben: + - tasks/index.md + - Erkennung: tasks/detect.md + - Segmentierung: tasks/segment.md + - Klassifizierung: tasks/classify.md + - Pose: tasks/pose.md + - Modelle: + - models/index.md + - Datensätze: + - datasets/index.md + +# Plugins including 301 redirects navigation --------------------------------------------------------------------------- +plugins: + - search: + lang: pt + - ultralytics: + add_desc: False + add_image: True + add_share_buttons: True + default_image: https://github.com/ultralytics/ultralytics/assets/26833433/6d09221c-c52a-4234-9a5d-b862e93c6529 diff --git a/docs/mkdocs_ru.yml b/docs/mkdocs_ru.yml new file mode 100644 index 00000000..e023942b --- /dev/null +++ b/docs/mkdocs_ru.yml @@ -0,0 +1,186 @@ +# Ultralytics YOLO 🚀, AGPL-3.0 license + +site_name: Документация Ultralytics YOLOv8 +site_description: Изучите Ultralytics YOLOv8, передовую модель для обнаружения объектов и сегментации изображений в реальном времени, подходящую для различных приложений и аппаратных платформ. +site_url: https://docs.ultralytics.com/ru/ +site_author: Ultralytics +repo_url: https://github.com/ultralytics/ultralytics +edit_uri: https://github.com/ultralytics/ultralytics/tree/main/docs/ru/ +repo_name: ultralytics/ultralytics +remote_name: https://github.com/ultralytics/docs +docs_dir: 'ru/' # where to find the markdown files +site_dir: '../site/ru' # where to publish to + +theme: + name: material + language: ru + custom_dir: overrides/ + logo: https://github.com/ultralytics/assets/raw/main/logo/Ultralytics_Logotype_Reverse.svg + favicon: assets/favicon.ico + icon: + repo: fontawesome/brands/github + # font: # disabled for faster page load times + # text: Helvetica + # code: Roboto Mono + palette: + - scheme: default # light mode + # primary: grey + toggle: + icon: material/toggle-switch + name: Switch to dark mode + - scheme: slate # dark mode + # primary: black + toggle: + icon: material/toggle-switch-off-outline + name: Switch to light mode + features: + - announce.dismiss + - content.action.edit + - content.code.annotate + - content.code.copy + - content.tooltips + - search.highlight + - search.share + - search.suggest + - toc.follow + - navigation.top + - navigation.tabs + - navigation.tabs.sticky + - navigation.prune + - navigation.footer + - navigation.tracking + - navigation.instant + - navigation.instant.progress + - navigation.indexes + - navigation.sections + - content.tabs.link # all code tabs change simultaneously + +# Customization +copyright: © 2023 Ultralytics Inc. All rights reserved. +extra: + # version: + # provider: mike # version drop-down menu + robots: robots.txt + analytics: + provider: google + property: G-2M5EHKC0BH + alternate: # language drop-down + - name: 🇬🇧 English + link: / + lang: en + - name: 🇨🇳 简体中文 + link: /zh/ + lang: zh + - name: 🇰🇷 한국어 + link: /ko/ + lang: ko + - name: 🇯🇵 日本語 + link: /ja/ + lang: ja + - name: 🇷🇺 Русский + link: /ru/ + lang: ru + - name: 🇩🇪 Deutsch + link: /de/ + lang: de + - name: 🇫🇷 Français + link: /fr/ + lang: fr + - name: 🇪🇸 Español + link: /es/ + lang: es + - name: 🇵🇹 Português + link: /pt/ + lang: pt + social: + - icon: fontawesome/brands/github + link: https://github.com/ultralytics + - icon: fontawesome/brands/linkedin + link: https://www.linkedin.com/company/ultralytics/ + - icon: fontawesome/brands/twitter + link: https://twitter.com/ultralytics + - icon: fontawesome/brands/youtube + link: https://www.youtube.com/ultralytics + - icon: fontawesome/brands/docker + link: https://hub.docker.com/r/ultralytics/ultralytics/ + - icon: fontawesome/brands/python + link: https://pypi.org/project/ultralytics/ + - icon: fontawesome/brands/discord + link: https://ultralytics.com/discord + +extra_css: + - 'stylesheets/style.css' + +markdown_extensions: + - admonition + - md_in_html + - tables + - attr_list + - def_list + - pymdownx.critic + - pymdownx.caret + - pymdownx.keys + - pymdownx.mark + - pymdownx.tilde + - pymdownx.details + - pymdownx.superfences + - pymdownx.inlinehilite + - pymdownx.highlight: + anchor_linenums: true + - pymdownx.snippets: + base_path: ./ + - pymdownx.emoji: + emoji_index: !!python/name:material.extensions.emoji.twemoji + emoji_generator: !!python/name:material.extensions.emoji.to_svg + - pymdownx.tabbed: + alternate_style: true + + +# Primary navigation --------------------------------------------------------------------------------------------------- +nav: + - Главная: + - Главная: index.md + - Быстрый старт: quickstart.md + - Режимы: + - modes/index.md + - Обучение: modes/train.md + - Валидация: modes/val.md + - Прогнозирование: modes/predict.md + - Экспорт: modes/export.md + - Отслеживание: modes/track.md + - Бенчмаркинг: modes/benchmark.md + - Задачи: + - tasks/index.md + - Обнаружение: tasks/detect.md + - Сегментация: tasks/segment.md + - Классификация: tasks/classify.md + - Поза: tasks/pose.md + - Быстрый старт: quickstart.md + - Режимы: + - modes/index.md + - Обучение: modes/train.md + - Валидация: modes/val.md + - Прогнозирование: modes/predict.md + - Экспорт: modes/export.md + - Отслеживание: modes/track.md + - Бенчмаркинг: modes/benchmark.md + - Задачи: + - tasks/index.md + - Обнаружение: tasks/detect.md + - Сегментация: tasks/segment.md + - Классификация: tasks/classify.md + - Поза: tasks/pose.md + - Модели: + - models/index.md + - Данные: + - datasets/index.md + +# Plugins including 301 redirects navigation --------------------------------------------------------------------------- +plugins: + - search: + lang: ru + - ultralytics: + add_desc: False + add_image: True + add_share_buttons: True + default_image: https://github.com/ultralytics/ultralytics/assets/26833433/6d09221c-c52a-4234-9a5d-b862e93c6529 diff --git a/docs/mkdocs_zh.yml b/docs/mkdocs_zh.yml index 6400c220..752fe043 100644 --- a/docs/mkdocs_zh.yml +++ b/docs/mkdocs_zh.yml @@ -1,8 +1,8 @@ # Ultralytics YOLO 🚀, AGPL-3.0 license site_name: Ultralytics YOLOv8 文档 +site_description: 探索Ultralytics YOLOv8，这是一款尖端的实时对象检测和图像分割模型，适用于各种应用和硬件平台。 site_url: https://docs.ultralytics.com/zh/ -site_description: Explore Ultralytics YOLOv8, a cutting-edge real-time object detection and image segmentation model for various applications and hardware platforms. site_author: Ultralytics repo_url: https://github.com/ultralytics/ultralytics edit_uri: https://github.com/ultralytics/ultralytics/tree/main/docs/zh/ @@ -65,12 +65,33 @@ extra: provider: google property: G-2M5EHKC0BH alternate: # language drop-down - - name: English + - name: 🇬🇧 English link: / lang: en - - name: 简体中文 + - name: 🇨🇳 简体中文 link: /zh/ lang: zh + - name: 🇰🇷 한국어 + link: /ko/ + lang: ko + - name: 🇯🇵 日本語 + link: /ja/ + lang: ja + - name: 🇷🇺 Русский + link: /ru/ + lang: ru + - name: 🇩🇪 Deutsch + link: /de/ + lang: de + - name: 🇫🇷 Français + link: /fr/ + lang: fr + - name: 🇪🇸 Español + link: /es/ + lang: es + - name: 🇵🇹 Português + link: /pt/ + lang: pt social: - icon: fontawesome/brands/github link: https://github.com/ultralytics @@ -149,7 +170,10 @@ nav: - 分割: tasks/segment.md - 分类: tasks/classify.md - 姿态: tasks/pose.md - + - 模型: + - models/index.md + - 数据集: + - datasets/index.md # Plugins including 301 redirects navigation --------------------------------------------------------------------------- plugins: diff --git a/docs/pt/datasets/index.md b/docs/pt/datasets/index.md new file mode 100644 index 00000000..758ae5f1 --- /dev/null +++ b/docs/pt/datasets/index.md @@ -0,0 +1,127 @@ +--- +comments: true +description: Explore diversos conjuntos de dados de visão computacional suportados pela Ultralytics para detecção de objetos, segmentação, estimativa de pose, classificação de imagens e rastreamento de múltiplos objetos. +keywords: visão computacional, conjuntos de dados, Ultralytics, YOLO, detecção de objetos, segmentação de instância, estimativa de pose, classificação de imagens, rastreamento de múltiplos objetos +--- + +# Visão Geral de Conjuntos de Dados + +A Ultralytics oferece suporte para diversos conjuntos de dados para facilitar tarefas de visão computacional, como detecção, segmentação de instância, estimativa de pose, classificação e rastreamento de múltiplos objetos. Abaixo está uma lista dos principais conjuntos de dados da Ultralytics, seguidos por um resumo de cada tarefa de visão computacional e os respectivos conjuntos de dados. + +!!! note + + 🚧 Nossa documentação multilíngue está atualmente em construção e estamos trabalhando arduamente para melhorá-la. Obrigado pela sua paciência! 🙏 + +## [Conjuntos de Dados de Detecção](../../datasets/detect/index.md) + +A técnica de detecção de objetos com caixas delimitadoras envolve detectar e localizar objetos em uma imagem desenhando uma caixa delimitadora ao redor de cada objeto. + +- [Argoverse](../../datasets/detect/argoverse.md): Um conjunto de dados contendo dados de rastreamento 3D e previsão de movimento de ambientes urbanos com anotações detalhadas. +- [COCO](../../datasets/detect/coco.md): Um conjunto de dados em grande escala projetado para detecção de objetos, segmentação e legendagem com mais de 200 mil imagens etiquetadas. +- [COCO8](../../datasets/detect/coco8.md): Contém as primeiras 4 imagens do COCO train e COCO val, adequado para testes rápidos. +- [Global Wheat 2020](../../datasets/detect/globalwheat2020.md): Um conjunto de dados de imagens de espiga de trigo coletadas ao redor do mundo para tarefas de detecção e localização de objetos. +- [Objects365](../../datasets/detect/objects365.md): Um conjunto de dados de alta qualidade de grande escala para detecção de objetos com 365 categorias e mais de 600 mil imagens anotadas. +- [OpenImagesV7](../../datasets/detect/open-images-v7.md): Um conjunto de dados abrangente do Google com 1,7 milhão de imagens de treino e 42 mil imagens de validação. +- [SKU-110K](../../datasets/detect/sku-110k.md): Um conjunto de dados apresentando detecção de objetos densos em ambientes de varejo com mais de 11 mil imagens e 1,7 milhão de caixas delimitadoras. +- [VisDrone](../../datasets/detect/visdrone.md): Um conjunto de dados que contém informação de detecção de objetos e rastreamento de múltiplos objetos a partir de imagens capturadas por drones com mais de 10 mil imagens e sequências de vídeo. +- [VOC](../../datasets/detect/voc.md): O conjunto de dados Visual Object Classes (VOC) Pascal para detecção de objetos e segmentação com 20 classes de objetos e mais de 11 mil imagens. +- [xView](../../datasets/detect/xview.md): Um conjunto de dados para detecção de objetos em imagens aéreas com 60 categorias de objetos e mais de 1 milhão de objetos anotados. + +## [Conjuntos de Dados de Segmentação de Instância](../../datasets/segment/index.md) + +A segmentação de instância é uma técnica de visão computacional que identifica e localiza objetos em uma imagem ao nível de pixel. + +- [COCO](../../datasets/segment/coco.md): Um conjunto de dados em grande escala projetado para detecção de objetos, tarefas de segmentação e legendagem com mais de 200 mil imagens etiquetadas. +- [COCO8-seg](../../datasets/segment/coco8-seg.md): Um conjunto de dados menor para tarefas de segmentação de instâncias, contendo um subconjunto de 8 imagens COCO com anotações de segmentação. + +## [Estimativa de Pose](../../datasets/pose/index.md) + +A estimativa de pose é uma técnica usada para determinar a pose do objeto em relação à câmera ou ao sistema de coordenadas do mundo. + +- [COCO](../../datasets/pose/coco.md): Um conjunto de dados em grande escala com anotações de pose humana projetado para tarefas de estimativa de pose. +- [COCO8-pose](../../datasets/pose/coco8-pose.md): Um conjunto de dados menor para tarefas de estimativa de pose, contendo um subconjunto de 8 imagens COCO com anotações de pose humana. +- [Tiger-pose](../../datasets/pose/tiger-pose.md): Um conjunto de dados compacto consistindo de 263 imagens focadas em tigres, anotadas com 12 pontos-chave por tigre para tarefas de estimativa de pose. + +## [Classificação](../../datasets/classify/index.md) + +Classificação de imagens é uma tarefa de visão computacional que envolve categorizar uma imagem em uma ou mais classes ou categorias predefinidas com base em seu conteúdo visual. + +- [Caltech 101](../../datasets/classify/caltech101.md): Um conjunto de dados contendo imagens de 101 categorias de objetos para tarefas de classificação de imagens. +- [Caltech 256](../../datasets/classify/caltech256.md): Uma versão estendida do Caltech 101 com 256 categorias de objetos e imagens mais desafiadoras. +- [CIFAR-10](../../datasets/classify/cifar10.md): Um conjunto de dados de 60 mil imagens coloridas de 32x32 em 10 classes, com 6 mil imagens por classe. +- [CIFAR-100](../../datasets/classify/cifar100.md): Uma versão estendida do CIFAR-10 com 100 categorias de objetos e 600 imagens por classe. +- [Fashion-MNIST](../../datasets/classify/fashion-mnist.md): Um conjunto de dados consistindo de 70 mil imagens em escala de cinza de 10 categorias de moda para tarefas de classificação de imagens. +- [ImageNet](../../datasets/classify/imagenet.md): Um conjunto de dados em grande escala para detecção de objetos e classificação de imagens com mais de 14 milhões de imagens e 20 mil categorias. +- [ImageNet-10](../../datasets/classify/imagenet10.md): Um subconjunto menor do ImageNet com 10 categorias para experimentação e teste mais rápidos. +- [Imagenette](../../datasets/classify/imagenette.md): Um subconjunto menor do ImageNet que contém 10 classes facilmente distinguíveis para treinamento e teste mais rápidos. +- [Imagewoof](../../datasets/classify/imagewoof.md): Um subconjunto do ImageNet mais desafiador contendo 10 categorias de raças de cães para tarefas de classificação de imagens. +- [MNIST](../../datasets/classify/mnist.md): Um conjunto de dados de 70 mil imagens em escala de cinza de dígitos manuscritos para tarefas de classificação de imagens. + +## [Caixas Delimitadoras Orientadas (OBB)](../../datasets/obb/index.md) + +As Caixas Delimitadoras Orientadas (OBB) é um método em visão computacional para detectar objetos angulados em imagens usando caixas delimitadoras rotacionadas, muitas vezes aplicado em imagens aéreas e de satélite. + +- [DOTAv2](../../datasets/obb/dota-v2.md): Um popular conjunto de dados de imagens aéreas OBB com 1,7 milhão de instâncias e 11.268 imagens. + +## [Rastreamento de Múltiplos Objetos](../../datasets/track/index.md) + +O rastreamento de múltiplos objetos é uma técnica de visão computacional que envolve detectar e rastrear vários objetos ao longo do tempo em uma sequência de vídeo. + +- [Argoverse](../../datasets/detect/argoverse.md): Um conjunto de dados contendo dados de rastreamento 3D e previsão de movimento de ambientes urbanos com anotações ricas para tarefas de rastreamento de múltiplos objetos. +- [VisDrone](../../datasets/detect/visdrone.md): Um conjunto de dados que contém informação de detecção de objetos e rastreamento de múltiplos objetos a partir de imagens capturadas por drones com mais de 10 mil imagens e sequências de vídeo. + +## Contribuir com Novos Conjuntos de Dados + +Contribuir com um novo conjunto de dados envolve várias etapas para garantir que ele se alinhe bem com a infraestrutura existente. Abaixo estão as etapas necessárias: + +### Etapas para Contribuir com um Novo Conjunto de Dados + +1. **Coletar Imagens**: Reúna as imagens que pertencem ao conjunto de dados. Estas podem ser coletadas de várias fontes, como bancos de dados públicos ou sua própria coleção. + +2. **Anotar Imagens**: Anote essas imagens com caixas delimitadoras, segmentos ou pontos-chave, dependendo da tarefa. + +3. **Exportar Anotações**: Converta essas anotações no formato de arquivo *.txt YOLO que a Ultralytics suporta. + +4. **Organizar Conjunto de Dados**: Organize seu conjunto de dados na estrutura de pastas correta. Você deve ter diretórios de topo `train/` e `val/`, e dentro de cada um, um subdiretório `images/` e `labels/`. + + ``` + conjunto_de_dados/ + ├── train/ + │ ├── images/ + │ └── labels/ + └── val/ + ├── images/ + └── labels/ + ``` + +5. **Criar um Arquivo `data.yaml`**: No diretório raiz do seu conjunto de dados, crie um arquivo `data.yaml` que descreva o conjunto de dados, as classes e outras informações necessárias. + +6. **Otimizar Imagens (Opcional)**: Se você quiser reduzir o tamanho do conjunto de dados para um processamento mais eficiente, pode otimizar as imagens usando o código abaixo. Isso não é obrigatório, mas recomendado para tamanhos menores de conjunto de dados e velocidades de download mais rápidas. + +7. **Compactar Conjunto de Dados**: Compacte toda a pasta do conjunto de dados em um arquivo zip. + +8. **Documentar e PR**: Crie uma página de documentação descrevendo seu conjunto de dados e como ele se encaixa no framework existente. Depois disso, submeta um Pull Request (PR). Consulte [Diretrizes de Contribuição da Ultralytics](https://docs.ultralytics.com/help/contributing) para mais detalhes sobre como submeter um PR. + +### Exemplo de Código para Otimizar e Compactar um Conjunto de Dados + +!!! example "Otimizar e Compactar um Conjunto de Dados" + + === "Python" + + ```python + from pathlib import Path + from ultralytics.data.utils import compress_one_image + from ultralytics.utils.downloads import zip_directory + + # Definir diretório do conjunto de dados + path = Path('caminho/para/conjunto_de_dados') + + # Otimizar imagens no conjunto de dados (opcional) + for f in path.rglob('*.jpg'): + compress_one_image(f) + + # Compactar conjunto de dados em 'caminho/para/conjunto_de_dados.zip' + zip_directory(path) + ``` + +Seguindo esses passos, você poderá contribuir com um novo conjunto de dados que se integra bem com a estrutura existente da Ultralytics. diff --git a/docs/pt/index.md b/docs/pt/index.md new file mode 100644 index 00000000..f09f6679 --- /dev/null +++ b/docs/pt/index.md @@ -0,0 +1,82 @@ +--- +comments: true +description: Explore um guia completo do Ultralytics YOLOv8, um modelo de detecção de objetos e segmentação de imagens de alta velocidade e precisão. Tutoriais de instalação, previsão, treinamento e muito mais. +keywords: Ultralytics, YOLOv8, detecção de objetos, segmentação de imagens, aprendizado de máquina, aprendizado profundo, visão computacional, instalação do YOLOv8, previsão do YOLOv8, treinamento do YOLOv8, história do YOLO, licenças do YOLO +--- + +
+

+ + Banner Ultralytics YOLO +

+ GitHub da Ultralytics + + LinkedIn da Ultralytics + + Twitter da Ultralytics + + YouTube da Ultralytics + + TikTok da Ultralytics + + Instagram da Ultralytics + + Discord da Ultralytics +
+
+ Integração Contínua da Ultralytics + Cobertura de Código da Ultralytics + Citação do YOLOv8 + Contagem de Pulls no Docker +
+ Executar no Gradient + Abrir no Colab + Abrir no Kaggle +
+ +Apresentamos o [Ultralytics](https://ultralytics.com) [YOLOv8](https://github.com/ultralytics/ultralytics), a mais recente versão do aclamado modelo de detecção de objetos em tempo real e segmentação de imagens. O YOLOv8 é baseado nos mais recentes avanços do aprendizado profundo e visão computacional, oferecendo um desempenho sem paralelo em termos de velocidade e precisão. Seu design simplificado o torna adequado para várias aplicações e facilmente adaptável a diferentes plataformas de hardware, desde dispositivos de borda até APIs na nuvem. + +Explore os Documentos do YOLOv8, um recurso abrangente projetado para ajudá-lo a entender e utilizar suas características e capacidades. Seja você um praticante experiente de aprendizado de máquina ou novo no campo, este hub tem como objetivo maximizar o potencial do YOLOv8 em seus projetos + +!!! note + + 🚧 Nossa documentação em vários idiomas está atualmente em construção e estamos trabalhando arduamente para aprimorá-la. Agradecemos sua paciência! 🙏 + +## Por Onde Começar + +- **Instalar** `ultralytics` com pip e começar a funcionar em minutos   [:material-clock-fast: Começar](quickstart.md){ .md-button } +- **Prever** novas imagens e vídeos com o YOLOv8   [:octicons-image-16: Prever em Imagens](modes/predict.md){ .md-button } +- **Treinar** um novo modelo YOLOv8 em seu próprio conjunto de dados personalizado   [:fontawesome-solid-brain: Treinar um Modelo](modes/train.md){ .md-button } +- **Explorar** tarefas do YOLOv8 como segmentar, classificar, estimar pose e rastrear   [:material-magnify-expand: Explorar Tarefas](tasks/index.md){ .md-button } + +

+
+ +
+ Assistir: Como Treinar um Modelo YOLOv8 em Seu Conjunto de Dados Personalizado no Google Colab. +

+ +## YOLO: Uma Breve História + +[YOLO](https://arxiv.org/abs/1506.02640) (You Only Look Once), um popular modelo de detecção de objetos e segmentação de imagens, foi desenvolvido por Joseph Redmon e Ali Farhadi na Universidade de Washington. Lançado em 2015, o YOLO rapidamente ganhou popularidade por sua alta velocidade e precisão. + +- [YOLOv2](https://arxiv.org/abs/1612.08242), lançado em 2016, aprimorou o modelo original incorporando normalização em lote, caixas âncora e aglomerados dimensionais. +- [YOLOv3](https://pjreddie.com/media/files/papers/YOLOv3.pdf), lançado em 2018, melhorou ainda mais o desempenho do modelo usando uma rede dorsal mais eficiente, múltiplas âncoras e pooling piramidal espacial. +- [YOLOv4](https://arxiv.org/abs/2004.10934) foi lançado em 2020, introduzindo inovações como a ampliação de dados Mosaic, uma nova cabeça de detecção sem âncoras e uma nova função de perda. +- [YOLOv5](https://github.com/ultralytics/yolov5) melhorou ainda mais o desempenho do modelo e adicionou novos recursos, como otimização de hiperparâmetros, rastreamento integrado de experimentos e exportação automática para formatos de exportação populares. +- [YOLOv6](https://github.com/meituan/YOLOv6) foi disponibilizado em código aberto por [Meituan](https://about.meituan.com/) em 2022 e está em uso em muitos dos robôs autônomos de entrega da empresa. +- [YOLOv7](https://github.com/WongKinYiu/yolov7) adicionou tarefas adicionais, como estimativa de pose no conjunto de dados de keypoints COCO. +- [YOLOv8](https://github.com/ultralytics/ultralytics), a mais recente versão do YOLO pela Ultralytics. Como um modelo de última geração, o YOLOv8 baseia-se no sucesso das versões anteriores, introduzindo novos recursos e melhorias para desempenho, flexibilidade e eficiência aprimorados. O YOLOv8 suporta uma gama completa de tarefas de IA de visão, incluindo [detecção](tasks/detect.md), [segmentação](tasks/segment.md), [estimativa de pose](tasks/pose.md), [rastreamento](modes/track.md) e [classificação](tasks/classify.md). Essa versatilidade permite que os usuários aproveitem as capacidades do YOLOv8 em diversas aplicações e domínios. + +## Licenças YOLO: Como o YOLO da Ultralytics é licenciado? + +A Ultralytics oferece duas opções de licença para acomodar casos de uso diversos: + +- **Licença AGPL-3.0**: Essa licença de código aberto [aprovada pela OSI](https://opensource.org/licenses/) é ideal para estudantes e entusiastas, promovendo colaboração aberta e compartilhamento de conhecimento. Veja o arquivo [LICENSE](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) para mais detalhes. +- **Licença Empresarial**: Projetada para uso comercial, esta licença permite a integração perfeita do software Ultralytics e modelos de IA em bens e serviços comerciais, contornando os requisitos de código aberto da AGPL-3.0. Se o seu cenário envolver a incorporação de nossas soluções em uma oferta comercial, entre em contato através do [Licenciamento da Ultralytics](https://ultralytics.com/license). + +Nossa estratégia de licenciamento é projetada para garantir que qualquer melhoria em nossos projetos de código aberto retorne à comunidade. Mantemos os princípios de código aberto próximos ao nosso coração ❤️, e nossa missão é garantir que nossas contribuições possam ser utilizadas e expandidas de formas que beneficiem todos. diff --git a/docs/pt/models/index.md b/docs/pt/models/index.md new file mode 100644 index 00000000..a33191a1 --- /dev/null +++ b/docs/pt/models/index.md @@ -0,0 +1,94 @@ +--- +comments: true +description: Explore a diversificada gama de modelos da família YOLO, SAM, MobileSAM, FastSAM, YOLO-NAS e RT-DETR suportados pela Ultralytics. Comece com exemplos de uso tanto para CLI quanto para Python. +keywords: Ultralytics, documentação, YOLO, SAM, MobileSAM, FastSAM, YOLO-NAS, RT-DETR, modelos, arquiteturas, Python, CLI +--- + +# Modelos Suportados pela Ultralytics + +Bem-vindo à documentação de modelos da Ultralytics! Oferecemos suporte para uma ampla gama de modelos, cada um adaptado para tarefas específicas como [detecção de objetos](../tasks/detect.md), [segmentação de instâncias](../tasks/segment.md), [classificação de imagens](../tasks/classify.md), [estimativa de pose](../tasks/pose.md) e [rastreamento de múltiplos objetos](../modes/track.md). Se você está interessado em contribuir com sua arquitetura de modelo para a Ultralytics, confira nosso [Guia de Contribuição](../../help/contributing.md). + +!!! note + + 🚧 Nossa documentação multilíngue está atualmente em construção e estamos trabalhando duro para melhorá-la. Obrigado pela sua paciência! 🙏 + +## Modelos em Destaque + +Aqui estão alguns dos principais modelos suportados: + +1. **[YOLOv3](../../models/yolov3.md)**: A terceira iteração da família de modelos YOLO, originalmente por Joseph Redmon, conhecida por suas capacidades eficientes de detecção de objetos em tempo real. +2. **[YOLOv4](../../models/yolov4.md)**: Uma atualização nativa do darknet para o YOLOv3, lançada por Alexey Bochkovskiy em 2020. +3. **[YOLOv5](../../models/yolov5.md)**: Uma versão aprimorada da arquitetura YOLO pela Ultralytics, oferecendo melhores trade-offs de desempenho e velocidade comparado às versões anteriores. +4. **[YOLOv6](../../models/yolov6.md)**: Lançado pela [Meituan](https://about.meituan.com/) em 2022, e em uso em muitos dos robôs autônomos de entrega da empresa. +5. **[YOLOv7](../../models/yolov7.md)**: Modelos YOLO atualizados lançados em 2022 pelos autores do YOLOv4. +6. **[YOLOv8](../../models/yolov8.md)**: A versão mais recente da família YOLO, com capacidades aprimoradas como segmentação de instâncias, estimativa de pose/pontos-chave e classificação. +7. **[Segment Anything Model (SAM)](../../models/sam.md)**: Modelo de Segment Everything (SAM) do Meta. +8. **[Mobile Segment Anything Model (MobileSAM)](../../models/mobile-sam.md)**: MobileSAM para aplicações móveis, pela Universidade Kyung Hee. +9. **[Fast Segment Anything Model (FastSAM)](../../models/fast-sam.md)**: FastSAM pelo Grupo de Análise de Imagem e Vídeo, Instituto de Automação, Academia Chinesa de Ciências. +10. **[YOLO-NAS](../../models/yolo-nas.md)**: Modelos YOLO de Pesquisa de Arquitetura Neural (NAS). +11. **[Realtime Detection Transformers (RT-DETR)](../../models/rtdetr.md)**: Modelos do Transformer de Detecção em Tempo Real (RT-DETR) da PaddlePaddle da Baidu. + +

+
+ +
+ Assista: Execute modelos YOLO da Ultralytics em apenas algumas linhas de código. +

+ +## Começando: Exemplos de Uso + +!!! example "" + + === "Python" + + Modelos `*.pt` pré-treinados com PyTorch, bem como arquivos de configuração `*.yaml`, podem ser passados para as classes `YOLO()`, `SAM()`, `NAS()` e `RTDETR()` para criar uma instância de modelo em Python: + + ```python + from ultralytics import YOLO + + # Carregar um modelo YOLOv8n pré-treinado no COCO + model = YOLO('yolov8n.pt') + + # Exibir informações do modelo (opcional) + model.info() + + # Treinar o modelo no conjunto de dados de exemplo COCO8 por 100 épocas + results = model.train(data='coco8.yaml', epochs=100, imgsz=640) + + # Executar inferência com o modelo YOLOv8n na imagem 'bus.jpg' + results = model('path/to/bus.jpg') + ``` + + === "CLI" + + Comandos CLI estão disponíveis para executar diretamente os modelos: + + ```bash + # Carregar um modelo YOLOv8n pré-treinado no COCO e treiná-lo no conjunto de dados de exemplo COCO8 por 100 épocas + yolo train model=yolov8n.pt data=coco8.yaml epochs=100 imgsz=640 + + # Carregar um modelo YOLOv8n pré-treinado no COCO e executar inferência na imagem 'bus.jpg' + yolo predict model=yolov8n.pt source=path/to/bus.jpg + ``` + +## Contribuindo com Novos Modelos + +Interessado em contribuir com o seu modelo para a Ultralytics? Ótimo! Estamos sempre abertos à expansão de nosso portfólio de modelos. + +1. **Fork no Repositório**: Comece fazendo um fork do [repositório GitHub da Ultralytics](https://github.com/ultralytics/ultralytics). + +2. **Clone o Seu Fork**: Clone o seu fork para a sua máquina local e crie uma nova branch para trabalhar. + +3. **Implemente Seu Modelo**: Adicione o seu modelo seguindo os padrões de codificação e diretrizes fornecidos em nosso [Guia de Contribuição](../../help/contributing.md). + +4. **Teste Completamente**: Certifique-se de testar seu modelo rigorosamente, isoladamente e como parte do pipeline. + +5. **Crie um Pull Request**: Uma vez que esteja satisfeito com seu modelo, crie um pull request para o repositório principal para revisão. + +6. **Revisão de Código & Merge**: Após a revisão, se o seu modelo atender os nossos critérios, ele será combinado com o repositório principal. + +Para etapas detalhadas, consulte nosso [Guia de Contribuição](../../help/contributing.md). diff --git a/docs/pt/modes/benchmark.md b/docs/pt/modes/benchmark.md new file mode 100644 index 00000000..a6598fe9 --- /dev/null +++ b/docs/pt/modes/benchmark.md @@ -0,0 +1,94 @@ +--- +comments: true +description: Aprenda a avaliar a velocidade e a precisão do YOLOv8 em diversos formatos de exportação; obtenha informações sobre métricas mAP50-95, accuracy_top5 e mais. +keywords: Ultralytics, YOLOv8, benchmarking, perfilagem de velocidade, perfilagem de precisão, mAP50-95, accuracy_top5, ONNX, OpenVINO, TensorRT, formatos de exportação YOLO +--- + +# Benchmarking de Modelos com o Ultralytics YOLO + +Ecossistema Ultralytics YOLO e integrações + +## Introdução + +Uma vez que seu modelo esteja treinado e validado, o próximo passo lógico é avaliar seu desempenho em diversos cenários do mundo real. O modo de benchmark no Ultralytics YOLOv8 serve a esse propósito, oferecendo uma estrutura robusta para avaliar a velocidade e a precisão do seu modelo em uma gama de formatos de exportação. + +## Por Que o Benchmarking é Crucial? + +- **Decisões Informadas:** Obtenha insights sobre o equilíbrio entre velocidade e precisão. +- **Alocação de Recursos:** Entenda como diferentes formatos de exportação se comportam em diferentes hardwares. +- **Otimização:** Aprenda qual formato de exportação oferece o melhor desempenho para o seu caso específico. +- **Eficiência de Custos:** Faça uso mais eficiente dos recursos de hardware com base nos resultados do benchmark. + +### Métricas Chave no Modo de Benchmark + +- **mAP50-95:** Para detecção de objetos, segmentação e estimativa de pose. +- **accuracy_top5:** Para classificação de imagens. +- **Tempo de Inferência:** Tempo levado para cada imagem em milissegundos. + +### Formatos de Exportação Suportados + +- **ONNX:** Para desempenho ótimo em CPU +- **TensorRT:** Para eficiência máxima em GPU +- **OpenVINO:** Para otimização em hardware Intel +- **CoreML, TensorFlow SavedModel e Mais:** Para uma variedade de necessidades de implantação. + +!!! dica "Dica" + + * Exporte para ONNX ou OpenVINO para acelerar até 3x a velocidade em CPU. + * Exporte para TensorRT para acelerar até 5x em GPU. + +## Exemplos de Uso + +Execute benchmarks do YOLOv8n em todos os formatos de exportação suportados incluindo ONNX, TensorRT etc. Consulte a seção Argumentos abaixo para ver uma lista completa de argumentos de exportação. + +!!! exemplo "" + + === "Python" + + ```python + from ultralytics.utils.benchmarks import benchmark + + # Benchmark na GPU + benchmark(model='yolov8n.pt', data='coco8.yaml', imgsz=640, half=False, device=0) + ``` + === "CLI" + + ```bash + yolo benchmark model=yolov8n.pt data='coco8.yaml' imgsz=640 half=False device=0 + ``` + +## Argumentos + +Argumentos como `model`, `data`, `imgsz`, `half`, `device` e `verbose` proporcionam aos usuários flexibilidade para ajustar os benchmarks às suas necessidades específicas e comparar o desempenho de diferentes formatos de exportação com facilidade. + +| Chave | Valor | Descrição | +|-----------|---------|----------------------------------------------------------------------------------------| +| `model` | `None` | caminho para o arquivo do modelo, ou seja, yolov8n.pt, yolov8n.yaml | +| `data` | `None` | caminho para o YAML com dataset de benchmarking (sob o rótulo `val`) | +| `imgsz` | `640` | tamanho da imagem como um escalar ou lista (h, w), ou seja, (640, 480) | +| `half` | `False` | quantização FP16 | +| `int8` | `False` | quantização INT8 | +| `device` | `None` | dispositivo para execução, ou seja, dispositivo cuda=0 ou device=0,1,2,3 ou device=cpu | +| `verbose` | `False` | não continuar em erro (bool), ou limiar mínimo para val (float) | + +## Formatos de Exportação + +Os benchmarks tentarão executar automaticamente em todos os possíveis formatos de exportação listados abaixo. + +| Formato | Argumento `format` | Modelo | Metadados | Argumentos | +|-----------------------------------------------------------------------|--------------------|---------------------------|-----------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [Modelo Salvo do TF](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | ✅ | `imgsz`, `keras` | +| [GraphDef do TF](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | ✅ | `imgsz`, `half` | + +Veja os detalhes completos de `exportação` na página [Export](https://docs.ultralytics.com/modes/export/). diff --git a/docs/pt/modes/export.md b/docs/pt/modes/export.md new file mode 100644 index 00000000..3cf226a4 --- /dev/null +++ b/docs/pt/modes/export.md @@ -0,0 +1,108 @@ +--- +comments: true +description: Guia passo a passo sobre como exportar seus modelos YOLOv8 para vários formatos como ONNX, TensorRT, CoreML e mais para implantação. Explore agora! +keywords: YOLO, YOLOv8, Ultralytics, Exportação de modelo, ONNX, TensorRT, CoreML, TensorFlow SavedModel, OpenVINO, PyTorch, exportar modelo +--- + +# Exportação de Modelo com Ultralytics YOLO + +Ecossistema Ultralytics YOLO e integrações + +## Introdução + +O objetivo final de treinar um modelo é implantá-lo para aplicações no mundo real. O modo de exportação no Ultralytics YOLOv8 oferece uma ampla gama de opções para exportar seu modelo treinado para diferentes formatos, tornando-o implantável em várias plataformas e dispositivos. Este guia abrangente visa orientá-lo através das nuances da exportação de modelos, mostrando como alcançar a máxima compatibilidade e performance. + +

+
+ +
+ Assista: Como Exportar Modelo Treinado Customizado do Ultralytics YOLOv8 e Executar Inferência ao Vivo na Webcam. +

+ +## Por Que Escolher o Modo de Exportação do YOLOv8? + +- **Versatilidade:** Exporte para múltiplos formatos incluindo ONNX, TensorRT, CoreML e mais. +- **Performance:** Ganhe até 5x aceleração em GPU com TensorRT e 3x aceleração em CPU com ONNX ou OpenVINO. +- **Compatibilidade:** Torne seu modelo universalmente implantável em numerosos ambientes de hardware e software. +- **Facilidade de Uso:** Interface de linha de comando simples e API Python para exportação rápida e direta de modelos. + +### Principais Recursos do Modo de Exportação + +Aqui estão algumas das funcionalidades de destaque: + +- **Exportação com Um Clique:** Comandos simples para exportação em diferentes formatos. +- **Exportação em Lote:** Exporte modelos capazes de inferência em lote. +- **Inferência Otimizada:** Modelos exportados são otimizados para tempos de inferência mais rápidos. +- **Vídeos Tutoriais:** Guias e tutoriais detalhados para uma experiência de exportação tranquila. + +!!! dica "Dica" + + * Exporte para ONNX ou OpenVINO para até 3x aceleração em CPU. + * Exporte para TensorRT para até 5x aceleração em GPU. + +## Exemplos de Uso + +Exporte um modelo YOLOv8n para um formato diferente como ONNX ou TensorRT. Veja a seção de Argumentos abaixo para uma lista completa dos argumentos de exportação. + +!!! exemplo "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Carregar um modelo + model = YOLO('yolov8n.pt') # carrega um modelo oficial + model = YOLO('caminho/para/best.pt') # carrega um modelo treinado personalizado + + # Exportar o modelo + model.export(format='onnx') + ``` + === "CLI" + + ```bash + yolo export model=yolov8n.pt format=onnx # exporta modelo oficial + yolo export model=caminho/para/best.pt format=onnx # exporta modelo treinado personalizado + ``` + +## Argumentos + +Configurações de exportação para modelos YOLO referem-se às várias configurações e opções usadas para salvar ou exportar o modelo para uso em outros ambientes ou plataformas. Essas configurações podem afetar a performance, tamanho e compatibilidade do modelo com diferentes sistemas. Algumas configurações comuns de exportação de YOLO incluem o formato do arquivo de modelo exportado (por exemplo, ONNX, TensorFlow SavedModel), o dispositivo em que o modelo será executado (por exemplo, CPU, GPU) e a presença de recursos adicionais como máscaras ou múltiplos rótulos por caixa. Outros fatores que podem afetar o processo de exportação incluem a tarefa específica para a qual o modelo está sendo usado e os requisitos ou restrições do ambiente ou plataforma alvo. É importante considerar e configurar cuidadosamente essas configurações para garantir que o modelo exportado seja otimizado para o caso de uso pretendido e possa ser usado eficazmente no ambiente alvo. + +| Chave | Valor | Descrição | +|-------------|-----------------|---------------------------------------------------------------------| +| `format` | `'torchscript'` | formato para exportação | +| `imgsz` | `640` | tamanho da imagem como escalar ou lista (h, w), ou seja, (640, 480) | +| `keras` | `False` | usar Keras para exportação TF SavedModel | +| `optimize` | `False` | TorchScript: otimizar para mobile | +| `half` | `False` | quantização FP16 | +| `int8` | `False` | quantização INT8 | +| `dynamic` | `False` | ONNX/TensorRT: eixos dinâmicos | +| `simplify` | `False` | ONNX/TensorRT: simplificar modelo | +| `opset` | `None` | ONNX: versão do opset (opcional, padrão para a mais recente) | +| `workspace` | `4` | TensorRT: tamanho do espaço de trabalho (GB) | +| `nms` | `False` | CoreML: adicionar NMS | + +## Formatos de Exportação + +Os formatos de exportação disponíveis para YOLOv8 estão na tabela abaixo. Você pode exportar para qualquer formato usando o argumento `format`, ou seja, `format='onnx'` ou `format='engine'`. + +| Formato | Argumento `format` | Modelo | Metadados | Argumentos | +|--------------------------------------------------------------------|--------------------|---------------------------|-----------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | ✅ | `imgsz`, `half` | diff --git a/docs/pt/modes/index.md b/docs/pt/modes/index.md new file mode 100644 index 00000000..b4503e90 --- /dev/null +++ b/docs/pt/modes/index.md @@ -0,0 +1,73 @@ +--- +comments: true +description: Da treinamento a rastreamento, aproveite ao máximo o YOLOv8 da Ultralytics. Obtenha insights e exemplos para cada modo suportado, incluindo validação, exportação e benchmarking. +keywords: Ultralytics, YOLOv8, Aprendizado de Máquina, Detecção de Objetos, Treinamento, Validação, Predição, Exportação, Rastreamento, Benchmarking +--- + +# Modos Ultralytics YOLOv8 + +Ecossistema e integrações do Ultralytics YOLO + +## Introdução + +O Ultralytics YOLOv8 não é apenas mais um modelo de detecção de objetos; é um framework versátil projetado para cobrir todo o ciclo de vida dos modelos de aprendizado de máquina — desde a ingestão de dados e treinamento do modelo até a validação, implantação e rastreamento no mundo real. Cada modo serve a um propósito específico e é projetado para oferecer a flexibilidade e eficiência necessárias para diferentes tarefas e casos de uso. + +

+
+ +
+ Assista: Tutorial dos Modos Ultralytics: Treinar, Validar, Prever, Exportar e Benchmark. +

+ +### Visão Geral dos Modos + +Entender os diferentes **modos** que o Ultralytics YOLOv8 suporta é crítico para tirar o máximo proveito de seus modelos: + +- **Modo Treino**: Ajuste fino do seu modelo em conjuntos de dados personalizados ou pré-carregados. +- **Modo Validação (Val)**: Um checkpoint pós-treinamento para validar o desempenho do modelo. +- **Modo Predição (Predict)**: Libere o poder preditivo do seu modelo em dados do mundo real. +- **Modo Exportação (Export)**: Prepare seu modelo para implantação em vários formatos. +- **Modo Rastreamento (Track)**: Estenda seu modelo de detecção de objetos para aplicações de rastreamento em tempo real. +- **Modo Benchmarking**: Analise a velocidade e precisão do seu modelo em diversos ambientes de implantação. + +Este guia abrangente visa fornecer uma visão geral e insights práticos para cada modo, ajudando você a aproveitar o potencial total do YOLOv8. + +## [Treinar](train.md) + +O modo Treinar é utilizado para treinar um modelo YOLOv8 em um conjunto de dados personalizado. Neste modo, o modelo é treinado usando o conjunto de dados especificado e os hiperparâmetros escolhidos. O processo de treinamento envolve otimizar os parâmetros do modelo para que ele possa prever com precisão as classes e localizações de objetos em uma imagem. + +[Exemplos de Treino](train.md){ .md-button .md-button--primary} + +## [Validar](val.md) + +O modo Validar é utilizado para validar um modelo YOLOv8 após ter sido treinado. Neste modo, o modelo é avaliado em um conjunto de validação para medir sua precisão e desempenho de generalização. Este modo pode ser usado para ajustar os hiperparâmetros do modelo para melhorar seu desempenho. + +[Exemplos de Validação](val.md){ .md-button .md-button--primary} + +## [Prever](predict.md) + +O modo Prever é utilizado para fazer previsões usando um modelo YOLOv8 treinado em novas imagens ou vídeos. Neste modo, o modelo é carregado de um arquivo de checkpoint, e o usuário pode fornecer imagens ou vídeos para realizar a inferência. O modelo prevê as classes e localizações dos objetos nas imagens ou vídeos fornecidos. + +[Exemplos de Predição](predict.md){ .md-button .md-button--primary} + +## [Exportar](export.md) + +O modo Exportar é utilizado para exportar um modelo YOLOv8 para um formato que possa ser utilizado para implantação. Neste modo, o modelo é convertido para um formato que possa ser utilizado por outras aplicações de software ou dispositivos de hardware. Este modo é útil ao implantar o modelo em ambientes de produção. + +[Exemplos de Exportação](export.md){ .md-button .md-button--primary} + +## [Rastrear](track.md) + +O modo Rastrear é utilizado para rastrear objetos em tempo real usando um modelo YOLOv8. Neste modo, o modelo é carregado de um arquivo de checkpoint, e o usuário pode fornecer um fluxo de vídeo ao vivo para realizar o rastreamento de objetos em tempo real. Este modo é útil para aplicações como sistemas de vigilância ou carros autônomos. + +[Exemplos de Rastreamento](track.md){ .md-button .md-button--primary} + +## [Benchmark](benchmark.md) + +O modo Benchmark é utilizado para fazer um perfil da velocidade e precisão de vários formatos de exportação para o YOLOv8. Os benchmarks fornecem informações sobre o tamanho do formato exportado, suas métricas `mAP50-95` (para detecção de objetos, segmentação e pose) ou `accuracy_top5` (para classificação), e o tempo de inferência em milissegundos por imagem em diversos formatos de exportação, como ONNX, OpenVINO, TensorRT e outros. Essas informações podem ajudar os usuários a escolher o formato de exportação ótimo para seu caso de uso específico, com base em seus requisitos de velocidade e precisão. + +[Exemplos de Benchmark](benchmark.md){ .md-button .md-button--primary} diff --git a/docs/pt/modes/predict.md b/docs/pt/modes/predict.md new file mode 100644 index 00000000..f7f12951 --- /dev/null +++ b/docs/pt/modes/predict.md @@ -0,0 +1,226 @@ +--- +comments: true +description: Descubra como usar o modo predict do YOLOv8 para diversas tarefas. Aprenda sobre diferentes fontes de inferência, como imagens, vídeos e formatos de dados. +keywords: Ultralytics, YOLOv8, modo predict, fontes de inferência, tarefas de previsão, modo de streaming, processamento de imagens, processamento de vídeo, aprendizado de máquina, IA +--- + +# Predição de Modelo com Ultralytics YOLO + +Ecossistema e integrações do Ultralytics YOLO + +## Introdução + +No mundo do aprendizado de máquina e visão computacional, o processo de fazer sentido a partir de dados visuais é chamado de 'inferência' ou 'predição'. O Ultralytics YOLOv8 oferece um recurso poderoso conhecido como **modo predict** que é personalizado para inferência em tempo real de alto desempenho em uma ampla gama de fontes de dados. + +

+
+ +
+ Assista: Como Extrair as Saídas do Modelo Ultralytics YOLOv8 para Projetos Personalizados. +

+ +## Aplicações no Mundo Real + +| Manufatura | Esportes | Segurança | +|:-----------------------------------------------------------------------------------------------------------------------------------------------:|:------------------------------------------------------------------------------------------------------------------------------------:|:----------------------------------------------------------------------------------------------------------------------------------:| +| ![Detecção de Peças de Reposição de Veículo](https://github.com/RizwanMunawar/ultralytics/assets/62513924/a0f802a8-0776-44cf-8f17-93974a4a28a1) | ![Detecção de Jogador de Futebol](https://github.com/RizwanMunawar/ultralytics/assets/62513924/7d320e1f-fc57-4d7f-a691-78ee579c3442) | ![Detecção de Queda de Pessoas](https://github.com/RizwanMunawar/ultralytics/assets/62513924/86437c4a-3227-4eee-90ef-9efb697bdb43) | +| Detecção de Peças de Reposição de Veículo | Detecção de Jogador de Futebol | Detecção de Queda de Pessoas | + +## Por Que Usar o Ultralytics YOLO para Inferência? + +Aqui está o porquê de você considerar o modo predict do YOLOv8 para suas diversas necessidades de inferência: + +- **Versatilidade:** Capaz de fazer inferências em imagens, vídeos e até transmissões ao vivo. +- **Desempenho:** Projetado para processamento em tempo real e de alta velocidade sem sacrificar a precisão. +- **Facilidade de Uso:** Interfaces Python e CLI intuitivas para implantação e testes rápidos. +- **Altamente Customizável:** Várias configurações e parâmetros para ajustar o comportamento de inferência do modelo de acordo com suas necessidades específicas. + +### Recursos Chave do Modo Predict + +O modo predict do YOLOv8 é projetado para ser robusto e versátil, apresentando: + +- **Compatibilidade com Múltiplas Fontes de Dados:** Se seus dados estão na forma de imagens individuais, uma coleção de imagens, arquivos de vídeo ou transmissões de vídeo em tempo real, o modo predict atende a todas as necessidades. +- **Modo de Streaming:** Use o recurso de streaming para gerar um gerador eficiente de memória de objetos `Results`. Ative isso definindo `stream=True` no método de chamada do preditor. +- **Processamento em Lote:** A capacidade de processar várias imagens ou quadros de vídeo em um único lote, acelerando ainda mais o tempo de inferência. +- **Integração Amigável:** Integração fácil com pipelines de dados existentes e outros componentes de software, graças à sua API flexível. + +Os modelos Ultralytics YOLO retornam ou uma lista de objetos `Results` em Python, ou um gerador em Python eficiente de memória de objetos `Results` quando `stream=True` é passado para o modelo durante a inferência: + +!!! exemplo "Predict" + + === "Retorna uma lista com `stream=False`" + ```python + from ultralytics import YOLO + + # Carrega um modelo + model = YOLO('yolov8n.pt') # modelo YOLOv8n pré-treinado + + # Executa a inferência em lote em uma lista de imagens + results = model(['im1.jpg', 'im2.jpg']) # retorna uma lista de objetos Results + + # Processa a lista de resultados + for result in results: + boxes = result.boxes # Objeto Boxes para saídas de bbox + masks = result.masks # Objeto Masks para saídas de máscaras de segmentação + keypoints = result.keypoints # Objeto Keypoints para saídas de pose + probs = result.probs # Objeto Probs para saídas de classificação + ``` + + === "Retorna um gerador com `stream=True`" + ```python + from ultralytics import YOLO + + # Carrega um modelo + model = YOLO('yolov8n.pt') # modelo YOLOv8n pré-treinado + + # Executa a inferência em lote em uma lista de imagens + results = model(['im1.jpg', 'im2.jpg'], stream=True) # retorna um gerador de objetos Results + + # Processa o gerador de resultados + for result in results: + boxes = result.boxes # Objeto Boxes para saídas de bbox + masks = result.masks # Objeto Masks para saídas de máscaras de segmentação + keypoints = result.keypoints # Objeto Keypoints para saídas de pose + probs = result.probs # Objeto Probs para saídas de classificação + ``` + +## Fontes de Inferência + +O YOLOv8 pode processar diferentes tipos de fontes de entrada para inferência, conforme mostrado na tabela abaixo. As fontes incluem imagens estáticas, transmissões de vídeo e vários formatos de dados. A tabela também indica se cada fonte pode ser usada no modo de streaming com o argumento `stream=True` ✅. O modo de streaming é benéfico para processar vídeos ou transmissões ao vivo, pois cria um gerador de resultados em vez de carregar todos os quadros na memória. + +!!! dica "Dica" + + Use `stream=True` para processar vídeos longos ou grandes conjuntos de dados para gerenciar a memória de forma eficiente. Quando `stream=False`, os resultados de todos os quadros ou pontos de dados são armazenados na memória, o que pode aumentar rapidamente e causar erros de falta de memória para grandes entradas. Em contraste, `stream=True` utiliza um gerador, que mantém apenas os resultados do quadro atual ou ponto de dados na memória, reduzindo significativamente o consumo de memória e prevenindo problemas de falta dela. + +| Fonte | Argumento | Tipo | Notas | +|-----------------|--------------------------------------------|-----------------|-------------------------------------------------------------------------------------------------------------------------| +| imagem | `'image.jpg'` | `str` ou `Path` | Arquivo de imagem único. | +| URL | `'https://ultralytics.com/images/bus.jpg'` | `str` | URL para uma imagem. | +| captura de tela | `'screen'` | `str` | Captura uma captura de tela. | +| PIL | `Image.open('im.jpg')` | `PIL.Image` | Formato HWC com canais RGB. | +| OpenCV | `cv2.imread('im.jpg')` | `np.ndarray` | Formato HWC com canais BGR `uint8 (0-255)`. | +| numpy | `np.zeros((640,1280,3))` | `np.ndarray` | Formato HWC com canais BGR `uint8 (0-255)`. | +| torch | `torch.zeros(16,3,320,640)` | `torch.Tensor` | Formato BCHW com canais RGB `float32 (0.0-1.0)`. | +| CSV | `'sources.csv'` | `str` ou `Path` | Arquivo CSV contendo caminhos para imagens, vídeos ou diretórios. | +| vídeo ✅ | `'video.mp4'` | `str` ou `Path` | Arquivo de vídeo em formatos como MP4, AVI, etc. | +| diretório ✅ | `'path/'` | `str` ou `Path` | Caminho para um diretório contendo imagens ou vídeos. | +| glob ✅ | `'path/*.jpg'` | `str` | Padrão glob para combinar vários arquivos. Use o caractere `*` como curinga. | +| YouTube ✅ | `'https://youtu.be/LNwODJXcvt4'` | `str` | URL para um vídeo do YouTube. | +| stream ✅ | `'rtsp://example.com/media.mp4'` | `str` | URL para protocolos de streaming como RTSP, RTMP, TCP ou um endereço IP. | +| multi-stream ✅ | `'list.streams'` | `str` ou `Path` | Arquivo de texto `*.streams` com uma URL de stream por linha, ou seja, 8 streams serão executados em lote de tamanho 8. | + +Abaixo estão exemplos de código para usar cada tipo de fonte: + +!!! exemplo "Fontes de previsão" + + === "imagem" + Executa a inferência em um arquivo de imagem. + ```python + from ultralytics import YOLO + + # Carrega um modelo YOLOv8n pré-treinado + model = YOLO('yolov8n.pt') + + # Define o caminho para o arquivo de imagem + source = 'caminho/para/imagem.jpg' + + # Executa a inferência na fonte + results = model(source) # lista de objetos Results + ``` + + === "captura de tela" + Executa a inferência no conteúdo atual da tela como uma captura de tela. + ```python + from ultralytics import YOLO + + # Carrega um modelo YOLOv8n pré-treinado + model = YOLO('yolov8n.pt') + + # Define a captura de tela atual como fonte + source = 'screen' + + # Executa a inferência na fonte + results = model(source) # lista de objetos Results + ``` + + === "URL" + Executa a inferência em uma imagem ou vídeo hospedado remotamente via URL. + ```python + from ultralytics import YOLO + + # Carrega um modelo YOLOv8n pré-treinado + model = YOLO('yolov8n.pt') + + # Define a URL remota da imagem ou vídeo + source = 'https://ultralytics.com/images/bus.jpg' + + # Executa a inferência na fonte + results = model(source) # lista de objetos Results + ``` + + === "PIL" + Executa a inferência em uma imagem aberta com a Biblioteca de Imagens do Python (PIL). + ```python + from PIL import Image + from ultralytics import YOLO + + # Carrega um modelo YOLOv8n pré-treinado + model = YOLO('yolov8n.pt') + + # Abre uma imagem usando PIL + source = Image.open('caminho/para/imagem.jpg') + + # Executa a inferência na fonte + results = model(source) # lista de objetos Results + ``` + + === "OpenCV" + Executa a inferência em uma imagem lida com OpenCV. + ```python + import cv2 + from ultralytics import YOLO + + # Carrega um modelo YOLOv8n pré-treinado + model = YOLO('yolov8n.pt') + + # Lê uma imagem usando OpenCV + source = cv2.imread('caminho/para/imagem.jpg') + + # Executa a inferência na fonte + results = model(source) # lista de objetos Results + ``` + + === "numpy" + Executa a inferência em uma imagem representada como um array numpy. + ```python + import numpy as np + from ultralytics import YOLO + + # Carrega um modelo YOLOv8n pré-treinado + model = YOLO('yolov8n.pt') + + # Cria um array random de numpy com forma HWC (640, 640, 3) com valores no intervalo [0, 255] e tipo uint8 + source = np.random.randint(low=0, high=255, size=(640, 640, 3), dtype='uint8') + + # Executa a inferência na fonte + results = model(source) # lista de objetos Results + ``` + + === "torch" + Executa a inferência em uma imagem representada como um tensor PyTorch. + ```python + import torch + from ultralytics import YOLO + + # Carrega um modelo YOLOv8n pré-treinado + model = YOLO('yolov8n.pt') + + # Cria um tensor random de torch com forma BCHW (1, 3, 640, 640) com valores no intervalo [0, 1] e tipo float32 + source = torch.rand(1, 3, 640, 640, dtype=torch.float32) + + # Executa a inferência na fonte + results = model(source) # lista de objetos Results diff --git a/docs/pt/modes/track.md b/docs/pt/modes/track.md new file mode 100644 index 00000000..657eedbd --- /dev/null +++ b/docs/pt/modes/track.md @@ -0,0 +1,200 @@ +--- +comments: true +description: Aprenda a usar o Ultralytics YOLO para rastreamento de objetos em fluxos de vídeo. Guias para usar diferentes rastreadores e personalizar configurações de rastreador. +keywords: Ultralytics, YOLO, rastreamento de objetos, fluxos de vídeo, BoT-SORT, ByteTrack, guia em Python, guia CLI +--- + +# Rastreamento de Múltiplos Objetos com Ultralytics YOLO + +Exemplos de rastreamento de múltiplos objetos + +Rastreamento de objetos no âmbito da análise de vídeo é uma tarefa crucial que não apenas identifica a localização e classe dos objetos dentro do quadro, mas também mantém um ID único para cada objeto detectado à medida que o vídeo avança. As aplicações são ilimitadas — variando desde vigilância e segurança até análises esportivas em tempo real. + +## Por Que Escolher Ultralytics YOLO para Rastreamento de Objetos? + +A saída dos rastreadores da Ultralytics é consistente com a detecção de objetos padrão, mas com o valor agregado dos IDs dos objetos. Isso facilita o rastreamento de objetos em fluxos de vídeo e a realização de análises subsequentes. Aqui está o porquê de considerar usar Ultralytics YOLO para suas necessidades de rastreamento de objetos: + +- **Eficiência:** Processa fluxos de vídeo em tempo real sem comprometer a precisão. +- **Flexibilidade:** Suporta múltiplos algoritmos de rastreamento e configurações. +- **Facilidade de Uso:** Simples API em Python e opções CLI para rápida integração e implantação. +- **Personalização:** Fácil de usar com modelos YOLO treinados personalizados, permitindo integração em aplicações específicas de domínio. + +

+
+ +
+ Assistir: Detecção e Rastreamento de Objetos com Ultralytics YOLOv8. +

+ +## Aplicações no Mundo Real + +| Transporte | Varejo | Aquicultura | +|:------------------------------------------------------------------------------------------------------------------------------:|:-----------------------------------------------------------------------------------------------------------------------------:|:----------------------------------------------------------------------------------------------------------------------------:| +| ![Rastreamento de Veículos](https://github.com/RizwanMunawar/ultralytics/assets/62513924/ee6e6038-383b-4f21-ac29-b2a1c7d386ab) | ![Rastreamento de Pessoas](https://github.com/RizwanMunawar/ultralytics/assets/62513924/93bb4ee2-77a0-4e4e-8eb6-eb8f527f0527) | ![Rastreamento de Peixes](https://github.com/RizwanMunawar/ultralytics/assets/62513924/a5146d0f-bfa8-4e0a-b7df-3c1446cd8142) | +| Rastreamento de Veículos | Rastreamento de Pessoas | Rastreamento de Peixes | + +## Características em Destaque + +Ultralytics YOLO estende suas funcionalidades de detecção de objetos para fornecer rastreamento de objetos robusto e versátil: + +- **Rastreamento em Tempo Real:** Acompanha objetos de forma contínua em vídeos de alta taxa de quadros. +- **Suporte a Múltiplos Rastreadores:** Escolha dentre uma variedade de algoritmos de rastreamento estabelecidos. +- **Configurações de Rastreador Personalizáveis:** Adapte o algoritmo de rastreamento para atender requisitos específicos ajustando vários parâmetros. + +## Rastreadores Disponíveis + +Ultralytics YOLO suporta os seguintes algoritmos de rastreamento. Eles podem ser ativados passando o respectivo arquivo de configuração YAML, como `tracker=tracker_type.yaml`: + +* [BoT-SORT](https://github.com/NirAharon/BoT-SORT) - Use `botsort.yaml` para ativar este rastreador. +* [ByteTrack](https://github.com/ifzhang/ByteTrack) - Use `bytetrack.yaml` para ativar este rastreador. + +O rastreador padrão é o BoT-SORT. + +## Rastreamento + +Para executar o rastreador em fluxos de vídeo, use um modelo Detect, Segment ou Pose treinado, como YOLOv8n, YOLOv8n-seg e YOLOv8n-pose. + +!!! exemplo "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Carregar um modelo oficial ou personalizado + model = YOLO('yolov8n.pt') # Carregar um modelo Detect oficial + model = YOLO('yolov8n-seg.pt') # Carregar um modelo Segment oficial + model = YOLO('yolov8n-pose.pt') # Carregar um modelo Pose oficial + model = YOLO('caminho/para/melhor.pt') # Carregar um modelo treinado personalizado + + # Realizar rastreamento com o modelo + results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True) # Rastreamento com rastreador padrão + results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml") # Rastreamento com o rastreador ByteTrack + ``` + + === "CLI" + + ```bash + # Realizar rastreamento com vários modelos usando a interface de linha de comando + yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" # Modelo Detect oficial + yolo track model=yolov8n-seg.pt source="https://youtu.be/LNwODJXcvt4" # Modelo Segment oficial + yolo track model=yolov8n-pose.pt source="https://youtu.be/LNwODJXcvt4" # Modelo Pose oficial + yolo track model=caminho/para/melhor.pt source="https://youtu.be/LNwODJXcvt4" # Modelo treinado personalizado + + # Rastrear usando o rastreador ByteTrack + yolo track model=caminho/para/melhor.pt tracker="bytetrack.yaml" + ``` + +Como pode ser visto no uso acima, o rastreamento está disponível para todos os modelos Detect, Segment e Pose executados em vídeos ou fontes de streaming. + +## Configuração + +### Argumentos de Rastreamento + +A configuração de rastreamento compartilha propriedades com o modo Predict, como `conf`, `iou`, e `show`. Para mais configurações, consulte a página de [Predict](https://docs.ultralytics.com/modes/predict/) model page. + +!!! exemplo "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Configurar os parâmetros de rastreamento e executar o rastreador + model = YOLO('yolov8n.pt') + results = model.track(source="https://youtu.be/LNwODJXcvt4", conf=0.3, iou=0.5, show=True) + ``` + + === "CLI" + + ```bash + # Configurar parâmetros de rastreamento e executar o rastreador usando a interface de linha de comando + yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" conf=0.3, iou=0.5 show + ``` + +### Seleção de Rastreador + +A Ultralytics também permite que você use um arquivo de configuração de rastreador modificado. Para fazer isso, simplesmente faça uma cópia de um arquivo de configuração de rastreador (por exemplo, `custom_tracker.yaml`) de [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers) e modifique quaisquer configurações (exceto `tracker_type`) conforme suas necessidades. + +!!! exemplo "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Carregar o modelo e executar o rastreador com um arquivo de configuração personalizado + model = YOLO('yolov8n.pt') + results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker='custom_tracker.yaml') + ``` + + === "CLI" + + ```bash + # Carregar o modelo e executar o rastreador com um arquivo de configuração personalizado usando a interface de linha de comando + yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" tracker='custom_tracker.yaml' + ``` + +Para uma lista completa de argumentos de rastreamento, consulte a página [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers). + +## Exemplos em Python + +### Loop de Persistência de Rastreamentos + +Aqui está um script em Python usando OpenCV (`cv2`) e YOLOv8 para executar rastreamento de objetos em quadros de vídeo. Este script ainda pressupõe que você já instalou os pacotes necessários (`opencv-python` e `ultralytics`). O argumento `persist=True` indica ao rastreador que a imagem ou quadro atual é o próximo de uma sequência e que espera rastreamentos da imagem anterior na imagem atual. + +!!! exemplo "Loop de fluxo com rastreamento" + + ```python + import cv2 + from ultralytics import YOLO + + # Carregar o modelo YOLOv8 + model = YOLO('yolov8n.pt') + + # Abrir o arquivo de vídeo + video_path = "caminho/para/video.mp4" + cap = cv2.VideoCapture(video_path) + + # Repetir através dos quadros de vídeo + while cap.isOpened(): + # Ler um quadro do vídeo + success, frame = cap.read() + + if success: + # Executar rastreamento YOLOv8 no quadro, persistindo rastreamentos entre quadros + results = model.track(frame, persist=True) + + # Visualizar os resultados no quadro + annotated_frame = results[0].plot() + + # Exibir o quadro anotado + cv2.imshow("Rastreamento YOLOv8", annotated_frame) + + # Interromper o loop se 'q' for pressionado + if cv2.waitKey(1) & 0xFF == ord("q"): + break + else: + # Interromper o loop se o fim do vídeo for atingido + break + + # Liberar o objeto de captura de vídeo e fechar a janela de exibição + cap.release() + cv2.destroyAllWindows() + ``` + +Note a mudança de `model(frame)` para `model.track(frame)`, que habilita o rastreamento de objetos ao invés de detecção simples. Este script modificado irá executar o rastreador em cada quadro do vídeo, visualizar os resultados e exibi-los em uma janela. O loop pode ser encerrado pressionando 'q'. + +## Contribuir com Novos Rastreadores + +Você é proficiente em rastreamento de múltiplos objetos e implementou ou adaptou com sucesso um algoritmo de rastreamento com Ultralytics YOLO? Convidamos você a contribuir para nossa seção de Rastreadores em [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers)! Suas aplicações do mundo real e soluções podem ser inestimáveis para usuários trabalhando em tarefas de rastreamento. + +Ao contribuir para esta seção, você ajuda a expandir o escopo de soluções de rastreamento disponíveis dentro do framework Ultralytics YOLO, adicionando outra camada de funcionalidade e utilidade para a comunidade. + +Para iniciar sua contribuição, por favor, consulte nosso [Guia de Contribuição](https://docs.ultralytics.com/help/contributing) para instruções completas sobre como enviar um Pedido de Pull (PR) 🛠️. Estamos ansiosos para ver o que você traz para a mesa! + +Juntos, vamos aprimorar as capacidades de rastreamento do ecossistema Ultralytics YOLO 🙏! diff --git a/docs/pt/modes/train.md b/docs/pt/modes/train.md new file mode 100644 index 00000000..c09cfc3d --- /dev/null +++ b/docs/pt/modes/train.md @@ -0,0 +1,206 @@ +--- +comments: true +description: Guia passo a passo para treinar modelos YOLOv8 com a YOLO da Ultralytics, incluindo exemplos de treinamento com uma única GPU e múltiplas GPUs +keywords: Ultralytics, YOLOv8, YOLO, detecção de objetos, modo de treino, conjunto de dados personalizado, treinamento com GPU, multi-GPU, hiperparâmetros, exemplos de CLI, exemplos em Python +--- + +# Treinamento de Modelos com a YOLO da Ultralytics + +Ecossistema e integrações da YOLO da Ultralytics + +## Introdução + +O treinamento de um modelo de aprendizado profundo envolve fornecer dados e ajustar seus parâmetros para que ele possa fazer previsões precisas. O modo de treino na YOLOv8 da Ultralytics é projetado para um treinamento eficaz e eficiente de modelos de detecção de objetos, aproveitando totalmente as capacidades do hardware moderno. Este guia visa cobrir todos os detalhes que você precisa para começar a treinar seus próprios modelos usando o robusto conjunto de recursos da YOLOv8. + +

+
+ +
+ Assista: Como Treinar um modelo YOLOv8 no Seu Conjunto de Dados Personalizado no Google Colab. +

+ +## Por Que Escolher a YOLO da Ultralytics para Treinamento? + +Aqui estão algumas razões convincentes para optar pelo modo de Treino da YOLOv8: + +- **Eficiência:** Aproveite ao máximo seu hardware, seja em um setup com uma única GPU ou expandindo para múltiplas GPUs. +- **Versatilidade:** Treine em conjuntos de dados personalizados, além dos já disponíveis, como COCO, VOC e ImageNet. +- **Facilidade de Uso:** Interfaces de linha de comando (CLI) e em Python simples, porém poderosas, para uma experiência de treinamento direta. +- **Flexibilidade de Hiperparâmetros:** Uma ampla gama de hiperparâmetros personalizáveis para ajustar o desempenho do modelo. + +### Principais Recursos do Modo de Treino + +Os seguintes são alguns recursos notáveis ​​do modo de Treino da YOLOv8: + +- **Download Automático de Datasets:** Datasets padrões como COCO, VOC e ImageNet são baixados automaticamente na primeira utilização. +- **Suporte a Multi-GPU:** Escalone seus esforços de treinamento de maneira uniforme entre várias GPUs para acelerar o processo. +- **Configuração de Hiperparâmetros:** Opção de modificar hiperparâmetros através de arquivos de configuração YAML ou argumentos de CLI. +- **Visualização e Monitoramento:** Acompanhamento em tempo real das métricas de treinamento e visualização do processo de aprendizagem para obter melhores insights. + +!!! dica "Dica" + + * Conjuntos de dados YOLOv8 como COCO, VOC, ImageNet e muitos outros são baixados automaticamente na primeira utilização, ou seja, `yolo train data=coco.yaml` + +## Exemplos de Uso + +Treine o YOLOv8n no conjunto de dados COCO128 por 100 épocas com tamanho de imagem de 640. O dispositivo de treinamento pode ser especificado usando o argumento `device`. Se nenhum argumento for passado, a GPU `device=0` será usado se disponível, caso contrário, `device=cpu` será usado. Veja a seção Argumentos abaixo para uma lista completa dos argumentos de treinamento. + +!!! exemplo "Exemplo de Treinamento em Uma Única GPU e CPU" + + O dispositivo é determinado automaticamente. Se uma GPU estiver disponível, ela será usada, caso contrário, o treinamento começará na CPU. + + === "Python" + + ```python + from ultralytics import YOLO + + # Carregar um modelo + model = YOLO('yolov8n.yaml') # construir um novo modelo a partir do YAML + model = YOLO('yolov8n.pt') # carregar um modelo pré-treinado (recomendado para treinamento) + model = YOLO('yolov8n.yaml').load('yolov8n.pt') # construir a partir do YAML e transferir pesos + + # Treinar o modelo + results = model.train(data='coco128.yaml', epochs=100, imgsz=640) + ``` + + === "CLI" + + ```bash + # Construir um novo modelo a partir do YAML e começar o treinamento do zero + yolo detect train data=coco128.yaml model=yolov8n.yaml epochs=100 imgsz=640 + + # Começar o treinamento a partir de um modelo *.pt pré-treinado + yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 + + # Construir um novo modelo a partir do YAML, transferir pesos pré-treinados para ele e começar o treinamento + yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640 + ``` + +### Treinamento com Multi-GPU + +O treinamento com múltiplas GPUs permite uma utilização mais eficiente dos recursos de hardware disponíveis, distribuindo a carga de treinamento entre várias GPUs. Esse recurso está disponível por meio da API do Python e da interface de linha de comando. Para habilitar o treinamento com várias GPUs, especifique os IDs dos dispositivos de GPU que deseja usar. + +!!! exemplo "Exemplo de Treinamento com Multi-GPU" + + Para treinar com 2 GPUs, dispositivos CUDA 0 e 1 use os seguintes comandos. Expanda para GPUs adicionais conforme necessário. + + === "Python" + + ```python + from ultralytics import YOLO + + # Carregar um modelo + model = YOLO('yolov8n.pt') # carregar um modelo pré-treinado (recomendado para treinamento) + + # Treinar o modelo com 2 GPUs + results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device=[0, 1]) + ``` + + === "CLI" + + ```bash + # Começar o treinamento a partir de um modelo *.pt pré-treinado usando as GPUs 0 e 1 + yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=0,1 + ``` + +### Treinamento com Apple M1 e M2 MPS + +Com a integração do suporte para os chips Apple M1 e M2 nos modelos YOLO da Ultralytics, agora é possível treinar seus modelos em dispositivos que utilizam o poderoso framework Metal Performance Shaders (MPS). O MPS oferece uma forma de alto desempenho de executar tarefas de computação e processamento de imagens no silício personalizado da Apple. + +Para habilitar o treinamento nos chips Apple M1 e M2, você deve especificar 'mps' como seu dispositivo ao iniciar o processo de treinamento. Abaixo está um exemplo de como você pode fazer isso em Python e via linha de comando: + +!!! exemplo "Exemplo de Treinamento com MPS" + + === "Python" + + ```python + from ultralytics import YOLO + + # Carregar um modelo + model = YOLO('yolov8n.pt') # carregar um modelo pré-treinado (recomendado para treinamento) + + # Treinar o modelo com MPS + results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device='mps') + ``` + + === "CLI" + + ```bash + # Começar o treinamento a partir de um modelo *.pt pré-treinado usando MPS + yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=mps + ``` + +Ao aproveitar o poder computacional dos chips M1/M2, isso possibilita o processamento mais eficiente das tarefas de treinamento. Para orientações mais detalhadas e opções avançadas de configuração, consulte a [documentação do PyTorch MPS](https://pytorch.org/docs/stable/notes/mps.html). + +## Registro de Logs + +Ao treinar um modelo YOLOv8, você pode achar valioso acompanhar o desempenho do modelo ao longo do tempo. É aqui que o registro de logs se torna útil. O YOLO da Ultralytics oferece suporte para três tipos de loggers - Comet, ClearML e TensorBoard. + +Para usar um logger, selecione-o no menu suspenso no trecho de código acima e execute-o. O logger escolhido será instalado e inicializado. + +### Comet + +[Comet](https://www.comet.ml/site/) é uma plataforma que permite a cientistas de dados e desenvolvedores rastrear, comparar, explicar e otimizar experimentos e modelos. Oferece funcionalidades como métricas em tempo real, diffs de código e acompanhamento de hiperparâmetros. + +Para usar o Comet: + +!!! exemplo "" + + === "Python" + ```python + # pip install comet_ml + import comet_ml + + comet_ml.init() + ``` + +Lembre-se de fazer login na sua conta Comet no site deles e obter sua chave de API. Você precisará adicionar isso às suas variáveis de ambiente ou ao seu script para registrar seus experimentos. + +### ClearML + +[ClearML](https://www.clear.ml/) é uma plataforma de código aberto que automatiza o rastreamento de experimentos e ajuda com o compartilhamento eficiente de recursos. É projetada para ajudar as equipes a gerenciar, executar e reproduzir seus trabalhos de ML de maneira mais eficiente. + +Para usar o ClearML: + +!!! exemplo "" + + === "Python" + ```python + # pip install clearml + import clearml + + clearml.browser_login() + ``` + +Após executar este script, você precisará fazer login na sua conta ClearML no navegador e autenticar sua sessão. + +### TensorBoard + +[TensorBoard](https://www.tensorflow.org/tensorboard) é um kit de ferramentas de visualização para TensorFlow. Permite visualizar o seu gráfico TensorFlow, plotar métricas quantitativas sobre a execução do seu gráfico e mostrar dados adicionais como imagens que passam por ele. + +Para usar o TensorBoard em [Google Colab](https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb): + +!!! exemplo "" + + === "CLI" + ```bash + load_ext tensorboard + tensorboard --logdir ultralytics/runs # substitua pelo diretório 'runs' + ``` + +Para usar o TensorBoard localmente, execute o comando abaixo e veja os resultados em http://localhost:6006/: + +!!! exemplo "" + + === "CLI" + ```bash + tensorboard --logdir ultralytics/runs # substitua pelo diretório 'runs' + ``` + +Isso irá carregar o TensorBoard e direcioná-lo para o diretório onde seus logs de treinamento estão salvos. + +Depois de configurar o seu logger, você pode então prosseguir com o treinamento do seu modelo. Todas as métricas de treinamento serão registradas automaticamente na sua plataforma escolhida, e você pode acessar esses logs para monitorar o desempenho do seu modelo ao longo do tempo, comparar diferentes modelos e identificar áreas para melhoria. diff --git a/docs/pt/modes/val.md b/docs/pt/modes/val.md new file mode 100644 index 00000000..75435bfc --- /dev/null +++ b/docs/pt/modes/val.md @@ -0,0 +1,86 @@ +--- +comments: true +description: Guia para Validação de Modelos YOLOv8. Aprenda como avaliar o desempenho dos seus modelos YOLO utilizando configurações e métricas de validação com exemplos em Python e CLI. +keywords: Ultralytics, Documentação YOLO, YOLOv8, validação, avaliação de modelo, hiperparâmetros, precisão, métricas, Python, CLI +--- + +# Validação de Modelos com Ultralytics YOLO + +Ecossistema e integrações do Ultralytics YOLO + +## Introdução + +A validação é um passo crítico no pipeline de aprendizado de máquina, permitindo que você avalie a qualidade dos seus modelos treinados. O modo Val no Ultralytics YOLOv8 fornece um robusto conjunto de ferramentas e métricas para avaliar o desempenho dos seus modelos de detecção de objetos. Este guia serve como um recurso completo para entender como usar efetivamente o modo Val para garantir que seus modelos sejam precisos e confiáveis. + +## Por Que Validar com o Ultralytics YOLO? + +Aqui estão as vantagens de usar o modo Val no YOLOv8: + +- **Precisão:** Obtenha métricas precisas como mAP50, mAP75 e mAP50-95 para avaliar seu modelo de forma abrangente. +- **Conveniência:** Utilize recursos integrados que lembram as configurações de treinamento, simplificando o processo de validação. +- **Flexibilidade:** Valide seu modelo com os mesmos ou diferentes conjuntos de dados e tamanhos de imagem. +- **Ajuste de Hiperparâmetros:** Utilize as métricas de validação para refinar seu modelo e obter um desempenho melhor. + +### Principais Recursos do Modo Val + +Estas são as funcionalidades notáveis oferecidas pelo modo Val do YOLOv8: + +- **Configurações Automatizadas:** Os modelos lembram suas configurações de treinamento para validação direta. +- **Suporte Multi-Métrico:** Avalie seu modelo com base em uma variedade de métricas de precisão. +- **API em Python e CLI:** Escolha entre a interface de linha de comando ou API em Python com base na sua preferência de validação. +- **Compatibilidade de Dados:** Funciona perfeitamente com conjuntos de dados usados durante a fase de treinamento, bem como conjuntos de dados personalizados. + +!!! tip "Dica" + + * Os modelos YOLOv8 lembram automaticamente suas configurações de treinamento, então você pode validar um modelo no mesmo tamanho de imagem e no conjunto de dados original facilmente com apenas `yolo val model=yolov8n.pt` ou `model('yolov8n.pt').val()` + +## Exemplos de Uso + +Validar a precisão do modelo YOLOv8n treinado no conjunto de dados COCO128. Nenhum argumento precisa ser passado, pois o `model` retém os dados de treinamento e argumentos como atributos do modelo. Veja a seção de Argumentos abaixo para uma lista completa dos argumentos de exportação. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Carregar um modelo + model = YOLO('yolov8n.pt') # carregar um modelo oficial + model = YOLO('path/to/best.pt') # carregar um modelo personalizado + + # Validar o modelo + metrics = model.val() # nenhum argumento necessário, conjunto de dados e configurações lembrados + metrics.box.map # map50-95 + metrics.box.map50 # map50 + metrics.box.map75 # map75 + metrics.box.maps # uma lista contém map50-95 de cada categoria + ``` + === "CLI" + + ```bash + yolo detect val model=yolov8n.pt # validar modelo oficial + yolo detect val model=path/to/best.pt # validar modelo personalizado + ``` + +## Argumentos + +As configurações de validação para os modelos YOLO referem-se aos vários hiperparâmetros e configurações usados para avaliar o desempenho do modelo em um conjunto de dados de validação. Essas configurações podem afetar o desempenho, velocidade e precisão do modelo. Algumas configurações comuns de validação do YOLO incluem o tamanho do lote, a frequência com que a validação é realizada durante o treinamento e as métricas usadas para avaliar o desempenho do modelo. Outros fatores que podem afetar o processo de validação incluem o tamanho e a composição do conjunto de dados de validação e a tarefa específica para a qual o modelo está sendo usado. É importante ajustar e experimentar cuidadosamente essas configurações para garantir que o modelo apresente um bom desempenho no conjunto de dados de validação e para detectar e prevenir o sobreajuste. + +| Chave | Valor | Descrição | +|---------------|---------|-----------------------------------------------------------------------------------| +| `data` | `None` | caminho para o arquivo de dados, ex. coco128.yaml | +| `imgsz` | `640` | tamanho das imagens de entrada como inteiro | +| `batch` | `16` | número de imagens por lote (-1 para AutoBatch) | +| `save_json` | `False` | salvar resultados em arquivo JSON | +| `save_hybrid` | `False` | salvar versão híbrida das etiquetas (etiquetas + previsões adicionais) | +| `conf` | `0.001` | limite de confiança do objeto para detecção | +| `iou` | `0.6` | limiar de interseção sobre união (IoU) para NMS | +| `max_det` | `300` | número máximo de detecções por imagem | +| `half` | `True` | usar precisão meia (FP16) | +| `device` | `None` | dispositivo para execução, ex. dispositivo cuda=0/1/2/3 ou device=cpu | +| `dnn` | `False` | usar OpenCV DNN para inferência ONNX | +| `plots` | `False` | mostrar gráficos durante o treinamento | +| `rect` | `False` | val retangular com cada lote colado para minimizar o preenchimento | +| `split` | `val` | divisão do conjunto de dados para usar na validação, ex. 'val', 'test' ou 'train' | +| diff --git a/docs/pt/quickstart.md b/docs/pt/quickstart.md new file mode 100644 index 00000000..2fc5174a --- /dev/null +++ b/docs/pt/quickstart.md @@ -0,0 +1,187 @@ +--- +comments: true +description: Explore os diversos métodos para instalar o Ultralytics usando pip, conda, git e Docker. Aprenda a usar o Ultralytics com a interface de linha de comando ou dentro dos seus projetos Python. +keywords: Instalação do Ultralytics, pip install Ultralytics, Docker install Ultralytics, interface de linha de comando do Ultralytics, interface Python do Ultralytics +--- + +## Instalação do Ultralytics + +O Ultralytics oferece diversos métodos de instalação, incluindo pip, conda e Docker. Instale o YOLOv8 através do pacote `ultralytics` pip para a versão estável mais recente ou clonando o [repositório GitHub do Ultralytics](https://github.com/ultralytics/ultralytics) para obter a versão mais atualizada. O Docker pode ser usado para executar o pacote em um contêiner isolado, evitando a instalação local. + +!!! example "Instalar" + + === "Pip install (recomendado)" + Instale o pacote `ultralytics` usando pip, ou atualize uma instalação existente executando `pip install -U ultralytics`. Visite o Índice de Pacotes Python (PyPI) para mais detalhes sobre o pacote `ultralytics`: [https://pypi.org/project/ultralytics/](https://pypi.org/project/ultralytics/). + + [![PyPI version](https://badge.fury.io/py/ultralytics.svg)](https://badge.fury.io/py/ultralytics) [![Downloads](https://static.pepy.tech/badge/ultralytics)](https://pepy.tech/project/ultralytics) + + ```bash + # Instalar o pacote ultralytics do PyPI + pip install ultralytics + ``` + + Você também pode instalar o pacote `ultralytics` diretamente do [repositório](https://github.com/ultralytics/ultralytics) GitHub. Isso pode ser útil se você desejar a versão de desenvolvimento mais recente. Certifique-se de ter a ferramenta de linha de comando Git instalada no seu sistema. O comando `@main` instala a branch `main` e pode ser modificado para outra branch, ou seja, `@my-branch`, ou removido completamente para padrão na branch `main`. + + ```bash + # Instalar o pacote ultralytics do GitHub + pip install git+https://github.com/ultralytics/ultralytics.git@main + ``` + + + === "Conda install" + Conda é um gerenciador de pacotes alternativo ao pip que também pode ser usado para instalação. Visite Anaconda para mais detalhes em [https://anaconda.org/conda-forge/ultralytics](https://anaconda.org/conda-forge/ultralytics). O repositório de feedstock do Ultralytics para atualizar o pacote conda está em [https://github.com/conda-forge/ultralytics-feedstock/](https://github.com/conda-forge/ultralytics-feedstock/). + + + [![Conda Recipe](https://img.shields.io/badge/recipe-ultralytics-green.svg)](https://anaconda.org/conda-forge/ultralytics) [![Conda Downloads](https://img.shields.io/conda/dn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics) [![Conda Version](https://img.shields.io/conda/vn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics) [![Conda Platforms](https://img.shields.io/conda/pn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics) + + ```bash + # Instalar o pacote ultralytics usando conda + conda install -c conda-forge ultralytics + ``` + + !!! note + + Se você está instalando em um ambiente CUDA a prática recomendada é instalar `ultralytics`, `pytorch` e `pytorch-cuda` no mesmo comando para permitir que o gerenciador de pacotes conda resolva quaisquer conflitos, ou instalar `pytorch-cuda` por último para permitir que ele substitua o pacote específico para CPU `pytorch`, se necessário. + ```bash + # Instalar todos os pacotes juntos usando conda + conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics + ``` + + ### Imagem Docker Conda + + As imagens Docker Conda do Ultralytics também estão disponíveis em [DockerHub](https://hub.docker.com/r/ultralytics/ultralytics). Estas imagens são baseadas em [Miniconda3](https://docs.conda.io/projects/miniconda/en/latest/) e são um modo simples de começar a usar `ultralytics` em um ambiente Conda. + + ```bash + # Definir o nome da imagem como uma variável + t=ultralytics/ultralytics:latest-conda + + # Puxar a imagem mais recente do ultralytics do Docker Hub + sudo docker pull $t + + # Executar a imagem ultralytics em um contêiner com suporte a GPU + sudo docker run -it --ipc=host --gpus all $t # todas as GPUs + sudo docker run -it --ipc=host --gpus '"device=2,3"' $t # especificar GPUs + ``` + + === "Git clone" + Clone o repositório `ultralytics` se você está interessado em contribuir para o desenvolvimento ou deseja experimentar com o código-fonte mais recente. Após clonar, navegue até o diretório e instale o pacote em modo editável `-e` usando pip. + ```bash + # Clonar o repositório ultralytics + git clone https://github.com/ultralytics/ultralytics + + # Navegar para o diretório clonado + cd ultralytics + + # Instalar o pacote em modo editável para desenvolvimento + pip install -e . + ``` + +Veja o arquivo [requirements.txt](https://github.com/ultralytics/ultralytics/blob/main/requirements.txt) do `ultralytics` para uma lista de dependências. Note que todos os exemplos acima instalam todas as dependências necessárias. + +!!! tip "Dica" + + Os requisitos do PyTorch variam pelo sistema operacional e pelos requisitos de CUDA, então é recomendado instalar o PyTorch primeiro seguindo as instruções em [https://pytorch.org/get-started/locally](https://pytorch.org/get-started/locally). + + + Instruções de Instalação do PyTorch + + +## Use o Ultralytics com CLI + +A interface de linha de comando (CLI) do Ultralytics permite comandos simples de uma única linha sem a necessidade de um ambiente Python. O CLI não requer personalização ou código Python. Você pode simplesmente rodar todas as tarefas do terminal com o comando `yolo`. Confira o [Guia CLI](../usage/cli.md) para aprender mais sobre o uso do YOLOv8 pela linha de comando. + +!!! example + + === "Sintaxe" + + Os comandos `yolo` do Ultralytics usam a seguinte sintaxe: + ```bash + yolo TAREFA MODO ARGUMENTOS + + Onde TAREFA (opcional) é um entre [detect, segment, classify] + MODO (obrigatório) é um entre [train, val, predict, export, track] + ARGUMENTOS (opcional) são qualquer número de pares personalizados 'arg=valor' como 'imgsz=320' que substituem os padrões. + ``` + Veja todos os ARGUMENTOS no guia completo de [Configuração](../usage/cfg.md) ou com `yolo cfg` + + === "Train" + + Treinar um modelo de detecção por 10 épocas com uma taxa de aprendizado inicial de 0.01 + ```bash + yolo train data=coco128.yaml model=yolov8n.pt epochs=10 lr0=0.01 + ``` + + === "Predict" + + Prever um vídeo do YouTube usando um modelo de segmentação pré-treinado com tamanho de imagem 320: + ```bash + yolo predict model=yolov8n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320 + ``` + + === "Val" + + Validar um modelo de detecção pré-treinado com tamanho de lote 1 e tamanho de imagem 640: + ```bash + yolo val model=yolov8n.pt data=coco128.yaml batch=1 imgsz=640 + ``` + + === "Export" + + Exportar um modelo de classificação YOLOv8n para formato ONNX com tamanho de imagem 224 por 128 (nenhuma TAREFA necessária) + ```bash + yolo export model=yolov8n-cls.pt format=onnx imgsz=224,128 + ``` + + === "Special" + + Executar comandos especiais para ver versão, visualizar configurações, rodar verificações e mais: + ```bash + yolo help + yolo checks + yolo version + yolo settings + yolo copy-cfg + yolo cfg + ``` + +!!! warning "Aviso" + + Argumentos devem ser passados como pares `arg=valor`, separados por um sinal de igual `=` e delimitados por espaços ` ` entre pares. Não use prefixos de argumentos `--` ou vírgulas `,` entre os argumentos. + + - `yolo predict model=yolov8n.pt imgsz=640 conf=0.25`   ✅ + - `yolo predict model yolov8n.pt imgsz 640 conf 0.25`   ❌ + - `yolo predict --model yolov8n.pt --imgsz 640 --conf 0.25`   ❌ + +[Guia CLI](../usage/cli.md){ .md-button .md-button--primary} + +## Use o Ultralytics com Python + +A interface Python do YOLOv8 permite uma integração tranquila em seus projetos Python, tornando fácil carregar, executar e processar a saída do modelo. Projetada com simplicidade e facilidade de uso em mente, a interface Python permite que os usuários implementem rapidamente detecção de objetos, segmentação e classificação em seus projetos. Isto torna a interface Python do YOLOv8 uma ferramenta inestimável para qualquer pessoa buscando incorporar essas funcionalidades em seus projetos Python. + +Por exemplo, os usuários podem carregar um modelo, treiná-lo, avaliar o seu desempenho em um conjunto de validação e até exportá-lo para o formato ONNX com apenas algumas linhas de código. Confira o [Guia Python](../usage/python.md) para aprender mais sobre o uso do YOLOv8 dentro dos seus projetos Python. + +!!! example + + ```python + from ultralytics import YOLO + + # Criar um novo modelo YOLO do zero + model = YOLO('yolov8n.yaml') + + # Carregar um modelo YOLO pré-treinado (recomendado para treinamento) + model = YOLO('yolov8n.pt') + + # Treinar o modelo usando o conjunto de dados 'coco128.yaml' por 3 épocas + results = model.train(data='coco128.yaml', epochs=3) + + # Avaliar o desempenho do modelo no conjunto de validação + results = model.val() + + # Realizar detecção de objetos em uma imagem usando o modelo + results = model('https://ultralytics.com/images/bus.jpg') + + # Exportar o modelo para formato ONNX + success = model.export(format='onnx') + ``` + +[Guia Python](../usage/python.md){.md-button .md-button--primary} diff --git a/docs/pt/tasks/classify.md b/docs/pt/tasks/classify.md new file mode 100644 index 00000000..67c735b3 --- /dev/null +++ b/docs/pt/tasks/classify.md @@ -0,0 +1,172 @@ +--- +comments: true +description: Aprenda sobre modelos YOLOv8 Classify para classificação de imagens. Obtenha informações detalhadas sobre Lista de Modelos Pré-treinados e como Treinar, Validar, Prever e Exportar modelos. +keywords: Ultralytics, YOLOv8, Classificação de Imagem, Modelos Pré-treinados, YOLOv8n-cls, Treinamento, Validação, Previsão, Exportação de Modelo +--- + +# Classificação de Imagens + +Exemplos de classificação de imagens + +A classificação de imagens é a tarefa mais simples das três e envolve classificar uma imagem inteira em uma de um conjunto de classes pré-definidas. + +A saída de um classificador de imagem é um único rótulo de classe e uma pontuação de confiança. A classificação de imagem é útil quando você precisa saber apenas a qual classe uma imagem pertence e não precisa conhecer a localização dos objetos dessa classe ou o formato exato deles. + +!!! tip "Dica" + + Os modelos YOLOv8 Classify usam o sufixo `-cls`, ou seja, `yolov8n-cls.pt` e são pré-treinados na [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml). + +## [Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8) + +Aqui são mostrados os modelos pré-treinados YOLOv8 Classify. Modelos de Detecção, Segmentação e Pose são pré-treinados no dataset [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), enquanto que os modelos de Classificação são pré-treinados no dataset [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml). + +[Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) são baixados automaticamente do último lançamento da Ultralytics [release](https://github.com/ultralytics/assets/releases) no primeiro uso. + +| Modelo | Tamanho
(pixels) | acurácia
top1 | acurácia
top5 | Velocidade
CPU ONNX
(ms) | Velocidade
A100 TensorRT
(ms) | parâmetros
(M) | FLOPs
(B) a 640 | +|----------------------------------------------------------------------------------------------|--------------------------|-----------------------|-----------------------|-------------------------------------|------------------------------------------|------------------------|-------------------------| +| [YOLOv8n-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-cls.pt) | 224 | 66.6 | 87.0 | 12.9 | 0.31 | 2.7 | 4.3 | +| [YOLOv8s-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-cls.pt) | 224 | 72.3 | 91.1 | 23.4 | 0.35 | 6.4 | 13.5 | +| [YOLOv8m-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-cls.pt) | 224 | 76.4 | 93.2 | 85.4 | 0.62 | 17.0 | 42.7 | +| [YOLOv8l-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-cls.pt) | 224 | 78.0 | 94.1 | 163.0 | 0.87 | 37.5 | 99.7 | +| [YOLOv8x-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-cls.pt) | 224 | 78.4 | 94.3 | 232.0 | 1.01 | 57.4 | 154.8 | + +- Os valores de **acc** são as acurácias dos modelos no conjunto de validação do dataset [ImageNet](https://www.image-net.org/). +
Reproduza com `yolo val classify data=path/to/ImageNet device=0` +- **Velocidade** média observada sobre imagens de validação da ImageNet usando uma instância [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/). +
Reproduza com `yolo val classify data=path/to/ImageNet batch=1 device=0|cpu` + +## Treino + +Treine o modelo YOLOv8n-cls no dataset MNIST160 por 100 épocas com tamanho de imagem 64. Para uma lista completa de argumentos disponíveis, veja a página de [Configuração](../../usage/cfg.md). + +!!! exemplo "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Carregar um modelo + model = YOLO('yolov8n-cls.yaml') # construir um novo modelo a partir do YAML + model = YOLO('yolov8n-cls.pt') # carregar um modelo pré-treinado (recomendado para treino) + model = YOLO('yolov8n-cls.yaml').load('yolov8n-cls.pt') # construir a partir do YAML e transferir pesos + + # Treinar o modelo + results = model.train(data='mnist160', epochs=100, imgsz=64) + ``` + + === "CLI" + + ```bash + # Construir um novo modelo a partir do YAML e começar treino do zero + yolo classify train data=mnist160 model=yolov8n-cls.yaml epochs=100 imgsz=64 + + # Começar treino de um modelo pré-treinado *.pt + yolo classify train data=mnist160 model=yolov8n-cls.pt epochs=100 imgsz=64 + + # Construir um novo modelo do YAML, transferir pesos pré-treinados e começar treino + yolo classify train data=mnist160 model=yolov8n-cls.yaml pretrained=yolov8n-cls.pt epochs=100 imgsz=64 + ``` + +### Formato do dataset + +O formato do dataset de classificação YOLO pode ser encontrado em detalhes no [Guia de Datasets](../../datasets/classify/index.md). + +## Val + +Valide a acurácia do modelo YOLOv8n-cls treinado no dataset MNIST160. Não é necessário passar argumento, pois o `modelo` retém seus dados de treinamento e argumentos como atributos do modelo. + +!!! exemplo "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Carregar um modelo + model = YOLO('yolov8n-cls.pt') # carregar um modelo oficial + model = YOLO('path/to/best.pt') # carregar um modelo personalizado + + # Validar o modelo + metrics = model.val() # sem argumentos necessários, dataset e configurações lembrados + metrics.top1 # acurácia top1 + metrics.top5 # acurácia top5 + ``` + === "CLI" + + ```bash + yolo classify val model=yolov8n-cls.pt # validar modelo oficial + yolo classify val model=path/to/best.pt # validar modelo personalizado + ``` + +## Previsão + +Use um modelo YOLOv8n-cls treinado para realizar previsões em imagens. + +!!! exemplo "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Carregar um modelo + model = YOLO('yolov8n-cls.pt') # carregar um modelo oficial + model = YOLO('path/to/best.pt') # carregar um modelo personalizado + + # Prever com o modelo + results = model('https://ultralytics.com/images/bus.jpg') # prever em uma imagem + ``` + === "CLI" + + ```bash + yolo classify predict model=yolov8n-cls.pt source='https://ultralytics.com/images/bus.jpg' # prever com modelo oficial + yolo classify predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # prever com modelo personalizado + ``` + +Veja detalhes completos do modo de `previsão` na página [Predict](https://docs.ultralytics.com/modes/predict/). + +## Exportar + +Exporte um modelo YOLOv8n-cls para um formato diferente, como ONNX, CoreML, etc. + +!!! exemplo "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Carregar um modelo + model = YOLO('yolov8n-cls.pt') # carregar um modelo oficial + model = YOLO('path/to/best.pt') # carregar um modelo treinado personalizado + + # Exportar o modelo + model.export(format='onnx') + ``` + === "CLI" + + ```bash + yolo export model=yolov8n-cls.pt format=onnx # exportar modelo oficial + yolo export model=path/to/best.pt format=onnx # exportar modelo treinado personalizado + ``` + +Os formatos de exportação YOLOv8-cls disponíveis estão na tabela abaixo. Você pode prever ou validar diretamente nos modelos exportados, ou seja, `yolo predict model=yolov8n-cls.onnx`. Exemplos de uso são mostrados para seu modelo após a conclusão da exportação. + +| Formato | Argumento `format` | Modelo | Metadata | Argumentos | +|--------------------------------------------------------------------|--------------------|-------------------------------|----------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n-cls.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-cls.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-cls.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-cls_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-cls.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-cls.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-cls_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-cls.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-cls.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-cls_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-cls_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-cls_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-cls_ncnn_model/` | ✅ | `imgsz`, `half` | + +Veja detalhes completos da `exportação` na página [Export](https://docs.ultralytics.com/modes/export/). diff --git a/docs/pt/tasks/detect.md b/docs/pt/tasks/detect.md new file mode 100644 index 00000000..e4e3d05f --- /dev/null +++ b/docs/pt/tasks/detect.md @@ -0,0 +1,185 @@ +--- +comments: true +description: Documentação oficial do YOLOv8 por Ultralytics. Aprenda como treinar, validar, predizer e exportar modelos em vários formatos. Incluindo estatísticas detalhadas de desempenho. +keywords: YOLOv8, Ultralytics, detecção de objetos, modelos pré-treinados, treinamento, validação, predição, exportação de modelos, COCO, ImageNet, PyTorch, ONNX, CoreML +--- + +# Detecção de Objetos + +Exemplos de detecção de objetos + +Detecção de objetos é uma tarefa que envolve identificar a localização e a classe de objetos em uma imagem ou fluxo de vídeo. + +A saída de um detector de objetos é um conjunto de caixas delimitadoras que cercam os objetos na imagem, junto com rótulos de classe e pontuações de confiança para cada caixa. A detecção de objetos é uma boa escolha quando você precisa identificar objetos de interesse em uma cena, mas não precisa saber exatamente onde o objeto está ou seu formato exato. + +

+
+ +
+ Assista: Detecção de Objetos com Modelo Pre-treinado Ultralytics YOLOv8. +

+ +!!! tip "Dica" + + Os modelos YOLOv8 Detect são os modelos padrão do YOLOv8, ou seja, `yolov8n.pt` e são pré-treinados no [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml). + +## [Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8) + +Os modelos pré-treinados YOLOv8 Detect são mostrados aqui. Os modelos Detect, Segment e Pose são pré-treinados no dataset [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), enquanto os modelos Classify são pré-treinados no dataset [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml). + +Os [Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) são baixados automaticamente a partir do último lançamento da Ultralytics [release](https://github.com/ultralytics/assets/releases) no primeiro uso. + +| Modelo | Tamanho
(pixels) | mAPval
50-95 | Velocidade
CPU ONNX
(ms) | Velocidade
A100 TensorRT
(ms) | Parâmetros
(M) | FLOPs
(B) | +|--------------------------------------------------------------------------------------|--------------------------|----------------------|-------------------------------------|------------------------------------------|------------------------|-------------------| +| [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n.pt) | 640 | 37.3 | 80.4 | 0.99 | 3.2 | 8.7 | +| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s.pt) | 640 | 44.9 | 128.4 | 1.20 | 11.2 | 28.6 | +| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m.pt) | 640 | 50.2 | 234.7 | 1.83 | 25.9 | 78.9 | +| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l.pt) | 640 | 52.9 | 375.2 | 2.39 | 43.7 | 165.2 | +| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x.pt) | 640 | 53.9 | 479.1 | 3.53 | 68.2 | 257.8 | + +- Os valores de **mAPval** são para um único modelo e uma única escala no dataset [COCO val2017](http://cocodataset.org). +
Reproduza usando `yolo val detect data=coco.yaml device=0` +- A **Velocidade** é média tirada sobre as imagens do COCO val num [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) + instância. +
Reproduza usando `yolo val detect data=coco128.yaml batch=1 device=0|cpu` + +## Treinar + +Treine o YOLOv8n no dataset COCO128 por 100 épocas com tamanho de imagem 640. Para uma lista completa de argumentos disponíveis, veja a página [Configuração](../../usage/cfg.md). + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Carregar um modelo + model = YOLO('yolov8n.yaml') # construir um novo modelo pelo YAML + model = YOLO('yolov8n.pt') # carregar um modelo pré-treinado (recomendado para treinamento) + model = YOLO('yolov8n.yaml').load('yolov8n.pt') # construir pelo YAML e transferir pesos + + # Treinar o modelo + results = model.train(data='coco128.yaml', epochs=100, imgsz=640) + ``` + === "CLI" + + ```bash + # Construir um novo modelo pelo YAML e começar o treinamento do zero + yolo detect train data=coco128.yaml model=yolov8n.yaml epochs=100 imgsz=640 + + # Começar o treinamento a partir de um modelo pré-treinado *.pt + yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 + + # Construir um novo modelo pelo YAML, transferir pesos pré-treinados e começar o treinamento + yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640 + ``` + +### Formato do Dataset + +O formato do dataset de detecção do YOLO pode ser encontrado em detalhes no [Guia de Datasets](../../datasets/detect/index.md). Para converter seu dataset existente de outros formatos (como COCO, etc.) para o formato YOLO, por favor utilize a ferramenta [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) da Ultralytics. + +## Validar + +Valide a precisão do modelo YOLOv8n treinado no dataset COCO128. Não é necessário passar nenhum argumento, pois o `modelo` mantém seus `dados` de treino e argumentos como atributos do modelo. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Carregar um modelo + model = YOLO('yolov8n.pt') # carregar um modelo oficial + model = YOLO('caminho/para/best.pt') # carregar um modelo personalizado + + # Validar o modelo + metrics = model.val() # sem a necessidade de argumentos, dataset e configurações lembradas + metrics.box.map # map50-95 + metrics.box.map50 # map50 + metrics.box.map75 # map75 + metrics.box.maps # uma lista contém map50-95 de cada categoria + ``` + === "CLI" + + ```bash + yolo detect val model=yolov8n.pt # validação do modelo oficial + yolo detect val model=caminho/para/best.pt # validação do modelo personalizado + ``` + +## Predizer + +Use um modelo YOLOv8n treinado para fazer predições em imagens. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Carregar um modelo + model = YOLO('yolov8n.pt') # carregar um modelo oficial + model = YOLO('caminho/para/best.pt') # carregar um modelo personalizado + + # Predizer com o modelo + results = model('https://ultralytics.com/images/bus.jpg') # predizer em uma imagem + ``` + === "CLI" + + ```bash + yolo detect predict model=yolov8n.pt source='https://ultralytics.com/images/bus.jpg' # predizer com modelo oficial + yolo detect predict model=caminho/para/best.pt source='https://ultralytics.com/images/bus.jpg' # predizer com modelo personalizado + ``` + +Veja os detalhes completos do modo `predict` na página [Predição](https://docs.ultralytics.com/modes/predict/). + +## Exportar + +Exporte um modelo YOLOv8n para um formato diferente, como ONNX, CoreML, etc. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Carregar um modelo + model = YOLO('yolov8n.pt') # carregar um modelo oficial + model = YOLO('caminho/para/best.pt') # carregar um modelo treinado personalizado + + # Exportar o modelo + model.export(format='onnx') + ``` + === "CLI" + + ```bash + yolo export model=yolov8n.pt format=onnx # exportar modelo oficial + yolo export model=caminho/para/best.pt format=onnx # exportar modelo treinado personalizado + ``` + +Os formatos de exportação YOLOv8 disponíveis estão na tabela abaixo. Você pode fazer predições ou validar diretamente em modelos exportados, ou seja, `yolo predict model=yolov8n.onnx`. Exemplos de uso são mostrados para o seu modelo após a exportação ser concluída. + +| Formato | Argumento `format` | Modelo | Metadados | Argumentos | +|--------------------------------------------------------------------|--------------------|---------------------------|-----------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | ✅ | `imgsz`, `half` | + +Veja os detalhes completos de `exportar` na página [Exportação](https://docs.ultralytics.com/modes/export/). diff --git a/docs/pt/tasks/index.md b/docs/pt/tasks/index.md new file mode 100644 index 00000000..9a597937 --- /dev/null +++ b/docs/pt/tasks/index.md @@ -0,0 +1,55 @@ +--- +comments: true +description: Aprenda sobre as principais tarefas de visão computacional que o YOLOv8 pode realizar, incluindo detecção, segmentação, classificação e estimativa de pose. Entenda seus usos em seus projetos de IA. +keywords: Ultralytics, YOLOv8, Detecção, Segmentação, Classificação, Estimativa de Pose, Framework de IA, Tarefas de Visão Computacional +--- + +# Tarefas do Ultralytics YOLOv8 + +
+Tarefas suportadas pelo Ultralytics YOLO + +YOLOv8 é um framework de IA que suporta múltiplas tarefas de **visão computacional**. O framework pode ser usado para realizar [detecção](detect.md), [segmentação](segment.md), [classificação](classify.md) e estimativa de [pose](pose.md). Cada uma dessas tarefas tem um objetivo e caso de uso diferente. + +!!! note + + 🚧 Nossa documentação multilíngue está atualmente em construção e estamos trabalhando para aprimorá-la. Agradecemos sua paciência! 🙏 + +

+
+ +
+ Assista: Explore as Tarefas do Ultralytics YOLO: Detecção de Objetos, Segmentação, Rastreamento e Estimativa de Pose. +

+ +## [Detecção](detect.md) + +A detecção é a principal tarefa suportada pelo YOLOv8. Envolve detectar objetos em uma imagem ou quadro de vídeo e desenhar caixas delimitadoras ao redor deles. Os objetos detectados são classificados em diferentes categorias com base em suas características. YOLOv8 pode detectar múltiplos objetos em uma única imagem ou quadro de vídeo com alta precisão e velocidade. + +[Exemplos de Detecção](detect.md){ .md-button .md-button--primary} + +## [Segmentação](segment.md) + +Segmentação é uma tarefa que envolve segmentar uma imagem em diferentes regiões com base no conteúdo da imagem. Cada região recebe um rótulo com base em seu conteúdo. Essa tarefa é útil em aplicações como segmentação de imagens e imagiologia médica. YOLOv8 usa uma variante da arquitetura U-Net para realizar a segmentação. + +[Exemplos de Segmentação](segment.md){ .md-button .md-button--primary} + +## [Classificação](classify.md) + +Classificação é uma tarefa que envolve classificar uma imagem em diferentes categorias. YOLOv8 pode ser usado para classificar imagens com base em seu conteúdo. Utiliza uma variante da arquitetura EfficientNet para realizar a classificação. + +[Exemplos de Classificação](classify.md){ .md-button .md-button--primary} + +## [Pose](pose.md) + +A detecção de pose/pontos-chave é uma tarefa que envolve detectar pontos específicos em uma imagem ou quadro de vídeo. Esses pontos são chamados de keypoints e são usados para rastrear movimento ou estimar poses. YOLOv8 pode detectar keypoints em uma imagem ou quadro de vídeo com alta precisão e velocidade. + +[Exemplos de Pose](pose.md){ .md-button .md-button--primary} + +## Conclusão + +YOLOv8 suporta múltiplas tarefas, incluindo detecção, segmentação, classificação e detecção de keypoints. Cada uma dessas tarefas tem objetivos e casos de uso diferentes. Ao entender as diferenças entre essas tarefas, você pode escolher a tarefa apropriada para sua aplicação de visão computacional. diff --git a/docs/pt/tasks/pose.md b/docs/pt/tasks/pose.md new file mode 100644 index 00000000..18c20379 --- /dev/null +++ b/docs/pt/tasks/pose.md @@ -0,0 +1,188 @@ +--- +comments: true +description: Aprenda a usar o Ultralytics YOLOv8 para tarefas de estimativa de pose. Encontre modelos pré-treinados, aprenda a treinar, validar, prever e exportar seu próprio modelo. +keywords: Ultralytics, YOLO, YOLOv8, estimativa de pose, detecção de pontos-chave, detecção de objetos, modelos pré-treinados, aprendizado de máquina, inteligência artificial +--- + +# Estimativa de Pose + +Exemplos de estimativa de pose + +A estimativa de pose é uma tarefa que envolve identificar a localização de pontos específicos em uma imagem, geralmente referidos como pontos-chave. Os pontos-chave podem representar várias partes do objeto como articulações, pontos de referência ou outras características distintas. As localizações dos pontos-chave são geralmente representadas como um conjunto de coordenadas 2D `[x, y]` ou 3D `[x, y, visível]`. + +A saída de um modelo de estimativa de pose é um conjunto de pontos que representam os pontos-chave em um objeto na imagem, geralmente junto com os escores de confiança para cada ponto. A estimativa de pose é uma boa escolha quando você precisa identificar partes específicas de um objeto em uma cena, e sua localização relativa entre si. + +

+
+ +
+ Assista: Estimativa de Pose com Ultralytics YOLOv8. +

+ +!!! tip "Dica" + + Modelos YOLOv8 _pose_ usam o sufixo `-pose`, isto é `yolov8n-pose.pt`. Esses modelos são treinados no conjunto de dados [COCO keypoints](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco-pose.yaml) e são adequados para uma variedade de tarefas de estimativa de pose. + +## [Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8) + +Os modelos YOLOv8 Pose pré-treinados são mostrados aqui. Os modelos Detect, Segment e Pose são pré-treinados no conjunto de dados [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), enquanto os modelos Classify são pré-treinados no conjunto de dados [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml). + +[Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) são baixados automaticamente do último lançamento da Ultralytics [release](https://github.com/ultralytics/assets/releases) no primeiro uso. + +| Modelo | tamanho
(pixels) | mAPpose
50-95 | mAPpose
50 | Velocidade
CPU ONNX
(ms) | Velocidade
A100 TensorRT
(ms) | parâmetros
(M) | FLOPs
(B) | +|------------------------------------------------------------------------------------------------------|--------------------------|-----------------------|--------------------|-------------------------------------|------------------------------------------|------------------------|-------------------| +| [YOLOv8n-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-pose.pt) | 640 | 50.4 | 80.1 | 131.8 | 1.18 | 3.3 | 9.2 | +| [YOLOv8s-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-pose.pt) | 640 | 60.0 | 86.2 | 233.2 | 1.42 | 11.6 | 30.2 | +| [YOLOv8m-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-pose.pt) | 640 | 65.0 | 88.8 | 456.3 | 2.00 | 26.4 | 81.0 | +| [YOLOv8l-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-pose.pt) | 640 | 67.6 | 90.0 | 784.5 | 2.59 | 44.4 | 168.6 | +| [YOLOv8x-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose.pt) | 640 | 69.2 | 90.2 | 1607.1 | 3.73 | 69.4 | 263.2 | +| [YOLOv8x-pose-p6](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose-p6.pt) | 1280 | 71.6 | 91.2 | 4088.7 | 10.04 | 99.1 | 1066.4 | + +- **mAPval** valores são para um único modelo em escala única no conjunto de dados [COCO Keypoints val2017](http://cocodataset.org) + . +
Reproduza `yolo val pose data=coco-pose.yaml device=0` +- **Velocidade** média em imagens COCO val usando uma instância [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) + . +
Reproduza `yolo val pose data=coco8-pose.yaml batch=1 device=0|cpu` + +## Treinar + +Treine um modelo YOLOv8-pose no conjunto de dados COCO128-pose. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Carregar um modelo + model = YOLO('yolov8n-pose.yaml') # construir um novo modelo a partir do YAML + model = YOLO('yolov8n-pose.pt') # carregar um modelo pré-treinado (recomendado para treinamento) + model = YOLO('yolov8n-pose.yaml').load('yolov8n-pose.pt') # construir a partir do YAML e transferir pesos + + # Treinar o modelo + results = model.train(data='coco8-pose.yaml', epochs=100, imgsz=640) + ``` + === "CLI" + + ```bash + # Construir um novo modelo a partir do YAML e começar o treinamento do zero + yolo pose train data=coco8-pose.yaml model=yolov8n-pose.yaml epochs=100 imgsz=640 + + # Começar treinamento de um modelo *.pt pré-treinado + yolo pose train data=coco8-pose.yaml model=yolov8n-pose.pt epochs=100 imgsz=640 + + # Construir um novo modelo a partir do YAML, transferir pesos pré-treinados para ele e começar o treinamento + yolo pose train data=coco8-pose.yaml model=yolov8n-pose.yaml pretrained=yolov8n-pose.pt epochs=100 imgsz=640 + ``` + +### Formato do conjunto de dados + +O formato do conjunto de dados de pose YOLO pode ser encontrado em detalhes no [Guia de Conjuntos de Dados](../../datasets/pose/index.md). Para converter seu conjunto de dados existente de outros formatos (como COCO etc.) para o formato YOLO, por favor, use a ferramenta [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) da Ultralytics. + +## Validar + +Valide a acurácia do modelo YOLOv8n-pose treinado no conjunto de dados COCO128-pose. Não é necessário passar nenhum argumento, pois o `model` +retém seus `data` de treinamento e argumentos como atributos do modelo. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Carregar um modelo + model = YOLO('yolov8n-pose.pt') # carregar um modelo oficial + model = YOLO('caminho/para/melhor.pt') # carregar um modelo personalizado + + # Validar o modelo + metrics = model.val() # nenhum argumento necessário, conjunto de dados e configurações lembradas + metrics.box.map # map50-95 + metrics.box.map50 # map50 + metrics.box.map75 # map75 + metrics.box.maps # uma lista contém map50-95 de cada categoria + ``` + === "CLI" + + ```bash + yolo pose val model=yolov8n-pose.pt # validar modelo oficial + yolo pose val model=caminho/para/melhor.pt # validar modelo personalizado + ``` + +## Prever + +Use um modelo YOLOv8n-pose treinado para executar previsões em imagens. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Carregar um modelo + model = YOLO('yolov8n-pose.pt') # carregar um modelo oficial + model = YOLO('caminho/para/melhor.pt') # carregar um modelo personalizado + + # Prever com o modelo + results = model('https://ultralytics.com/images/bus.jpg') # prever em uma imagem + ``` + === "CLI" + + ```bash + yolo pose predict model=yolov8n-pose.pt source='https://ultralytics.com/images/bus.jpg' # prever com modelo oficial + yolo pose predict model=caminho/para/melhor.pt source='https://ultralytics.com/images/bus.jpg' # prever com modelo personalizado + ``` + +Veja detalhes completos do modo `predict` na página [Prever](https://docs.ultralytics.com/modes/predict/). + +## Exportar + +Exporte um modelo YOLOv8n Pose para um formato diferente como ONNX, CoreML, etc. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Carregar um modelo + model = YOLO('yolov8n-pose.pt') # carregar um modelo oficial + model = YOLO('caminho/para/melhor.pt') # carregar um modelo treinado personalizado + + # Exportar o modelo + model.export(format='onnx') + ``` + === "CLI" + + ```bash + yolo export model=yolov8n-pose.pt format=onnx # exportar modelo oficial + yolo export model=caminho/para/melhor.pt format=onnx # exportar modelo treinado personalizado + ``` + +Os formatos de exportação YOLOv8-pose disponíveis estão na tabela abaixo. Você pode prever ou validar diretamente em modelos exportados, ou seja, `yolo predict model=yolov8n-pose.onnx`. Exemplos de uso são mostrados para o seu modelo após a conclusão da exportação. + +| Formato | Argumento `format` | Modelo | Metadados | Argumentos | +|--------------------------------------------------------------------|--------------------|--------------------------------|-----------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n-pose.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-pose.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-pose.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-pose_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-pose.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-pose.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-pose_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-pose.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-pose.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-pose_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-pose_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-pose_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-pose_ncnn_model/` | ✅ | `imgsz`, `half` | + +Veja detalhes completos da `exportação` na página [Exportar](https://docs.ultralytics.com/modes/export/). diff --git a/docs/pt/tasks/segment.md b/docs/pt/tasks/segment.md new file mode 100644 index 00000000..a6a4f7b9 --- /dev/null +++ b/docs/pt/tasks/segment.md @@ -0,0 +1,188 @@ +--- +comments: true +description: Aprenda a usar modelos de segmentação de instâncias com o Ultralytics YOLO. Instruções sobre treinamento, validação, previsão de imagem e exportação de modelo. +keywords: yolov8, segmentação de instâncias, Ultralytics, conjunto de dados COCO, segmentação de imagem, detecção de objeto, treinamento de modelo, validação de modelo, previsão de imagem, exportação de modelo +--- + +# Segmentação de Instâncias + +Exemplos de segmentação de instâncias + +A segmentação de instâncias vai além da detecção de objetos e envolve a identificação de objetos individuais em uma imagem e a sua segmentação do resto da imagem. + +A saída de um modelo de segmentação de instâncias é um conjunto de máscaras ou contornos que delineiam cada objeto na imagem, juntamente com rótulos de classe e pontuações de confiança para cada objeto. A segmentação de instâncias é útil quando você precisa saber não apenas onde os objetos estão em uma imagem, mas também qual é a forma exata deles. + +

+
+ +
+ Assista: Executar Segmentação com o Modelo Treinado Ultralytics YOLOv8 em Python. +

+ +!!! tip "Dica" + + Modelos YOLOv8 Segment usam o sufixo `-seg`, ou seja, `yolov8n-seg.pt` e são pré-treinados no [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml). + +## [Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8) + +Os modelos Segment pré-treinados do YOLOv8 estão mostrados aqui. Os modelos Detect, Segment e Pose são pré-treinados no conjunto de dados [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), enquanto os modelos Classify são pré-treinados no conjunto de dados [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml). + +[Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) são baixados automaticamente do último lançamento da Ultralytics [release](https://github.com/ultralytics/assets/releases) na primeira utilização. + +| Modelo | Tamanho
(pixels) | mAPbox
50-95 | mAPmáscara
50-95 | Velocidade
CPU ONNX
(ms) | Velocidade
A100 TensorRT
(ms) | Parâmetros
(M) | FLOPs
(B) | +|----------------------------------------------------------------------------------------------|--------------------------|----------------------|--------------------------|-------------------------------------|------------------------------------------|------------------------|-------------------| +| [YOLOv8n-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-seg.pt) | 640 | 36.7 | 30.5 | 96.1 | 1.21 | 3.4 | 12.6 | +| [YOLOv8s-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-seg.pt) | 640 | 44.6 | 36.8 | 155.7 | 1.47 | 11.8 | 42.6 | +| [YOLOv8m-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-seg.pt) | 640 | 49.9 | 40.8 | 317.0 | 2.18 | 27.3 | 110.2 | +| [YOLOv8l-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-seg.pt) | 640 | 52.3 | 42.6 | 572.4 | 2.79 | 46.0 | 220.5 | +| [YOLOv8x-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-seg.pt) | 640 | 53.4 | 43.4 | 712.1 | 4.02 | 71.8 | 344.1 | + +- Os valores de **mAPval** são para um único modelo em uma única escala no conjunto de dados [COCO val2017](http://cocodataset.org). +
Reproduza por meio de `yolo val segment data=coco.yaml device=0` +- **Velocidade** média em imagens COCO val usando uma instância [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/). +
Reproduza por meio de `yolo val segment data=coco128-seg.yaml batch=1 device=0|cpu` + +## Treinar + +Treine o modelo YOLOv8n-seg no conjunto de dados COCO128-seg por 100 épocas com tamanho de imagem 640. Para uma lista completa de argumentos disponíveis, consulte a página [Configuração](../../usage/cfg.md). + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Carregar um modelo + model = YOLO('yolov8n-seg.yaml') # construir um novo modelo a partir do YAML + model = YOLO('yolov8n-seg.pt') # carregar um modelo pré-treinado (recomendado para treinamento) + model = YOLO('yolov8n-seg.yaml').load('yolov8n.pt') # construir a partir do YAML e transferir os pesos + + # Treinar o modelo + results = model.train(data='coco128-seg.yaml', epochs=100, imgsz=640) + ``` + === "CLI" + + ```bash + # Construir um novo modelo a partir do YAML e começar o treinamento do zero + yolo segment train data=coco128-seg.yaml model=yolov8n-seg.yaml epochs=100 imgsz=640 + + # Começar o treinamento a partir de um modelo *.pt pré-treinado + yolo segment train data=coco128-seg.yaml model=yolov8n-seg.pt epochs=100 imgsz=640 + + # Construir um novo modelo a partir do YAML, transferir pesos pré-treinados para ele e começar o treinamento + yolo segment train data=coco128-seg.yaml model=yolov8n-seg.yaml pretrained=yolov8n-seg.pt epochs=100 imgsz=640 + ``` + +### Formato do conjunto de dados + +O formato do conjunto de dados de segmentação YOLO pode ser encontrado em detalhes no [Guia de Conjuntos de Dados](../../datasets/segment/index.md). Para converter seu conjunto de dados existente de outros formatos (como COCO etc.) para o formato YOLO, utilize a ferramenta [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) da Ultralytics. + +## Val + +Valide a acurácia do modelo YOLOv8n-seg treinado no conjunto de dados COCO128-seg. Não é necessário passar nenhum argumento, pois o `modelo` retém seus `dados` de treino e argumentos como atributos do modelo. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Carregar um modelo + model = YOLO('yolov8n-seg.pt') # carregar um modelo oficial + model = YOLO('path/to/best.pt') # carregar um modelo personalizado + + # Validar o modelo + metrics = model.val() # sem necessidade de argumentos, conjunto de dados e configurações são lembrados + metrics.box.map # map50-95(B) + metrics.box.map50 # map50(B) + metrics.box.map75 # map75(B) + metrics.box.maps # uma lista contendo map50-95(B) de cada categoria + metrics.seg.map # map50-95(M) + metrics.seg.map50 # map50(M) + metrics.seg.map75 # map75(M) + metrics.seg.maps # uma lista contendo map50-95(M) de cada categoria + ``` + === "CLI" + + ```bash + yolo segment val model=yolov8n-seg.pt # val modelo oficial + yolo segment val model=path/to/best.pt # val modelo personalizado + ``` + +## Prever + +Use um modelo YOLOv8n-seg treinado para realizar previsões em imagens. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Carregar um modelo + model = YOLO('yolov8n-seg.pt') # carregar um modelo oficial + model = YOLO('path/to/best.pt') # carregar um modelo personalizado + + # Realizar previsão com o modelo + results = model('https://ultralytics.com/images/bus.jpg') # prever em uma imagem + ``` + === "CLI" + + ```bash + yolo segment predict model=yolov8n-seg.pt source='https://ultralytics.com/images/bus.jpg' # previsão com modelo oficial + yolo segment predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # previsão com modelo personalizado + ``` + +Veja detalhes completos do modo `predict` na página [Prever](https://docs.ultralytics.com/modes/predict/). + +## Exportar + +Exporte um modelo YOLOv8n-seg para um formato diferente como ONNX, CoreML, etc. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Carregar um modelo + model = YOLO('yolov8n-seg.pt') # carregar um modelo oficial + model = YOLO('path/to/best.pt') # carregar um modelo treinado personalizado + + # Exportar o modelo + model.export(format='onnx') + ``` + === "CLI" + + ```bash + yolo export model=yolov8n-seg.pt format=onnx # exportar modelo oficial + yolo export model=path/to/best.pt format=onnx # exportar modelo treinado personalizado + ``` + +Os formatos de exportação disponíveis para YOLOv8-seg estão na tabela abaixo. Você pode prever ou validar diretamente em modelos exportados, ou seja, `yolo predict model=yolov8n-seg.onnx`. Exemplos de uso são mostrados para o seu modelo após a conclusão da exportação. + +| Formato | Argumento `format` | Modelo | Metadados | Argumentos | +|--------------------------------------------------------------------|--------------------|-------------------------------|-----------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n-seg.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-seg.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-seg.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-seg_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-seg.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-seg.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-seg_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-seg.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-seg.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-seg_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-seg_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-seg_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-seg_ncnn_model/` | ✅ | `imgsz`, `half` | + +Veja detalhes completos da `exportação` na página [Exportar](https://docs.ultralytics.com/modes/export/). diff --git a/docs/ru/datasets/index.md b/docs/ru/datasets/index.md new file mode 100644 index 00000000..1230bd0f --- /dev/null +++ b/docs/ru/datasets/index.md @@ -0,0 +1,127 @@ +--- +comments: true +description: Изучение различных наборов данных компьютерного зрения, поддерживаемых Ultralytics, для задач объектного обнаружения, сегментации, оценки поз, классификации изображений и многократного отслеживания объектов. +keywords: компьютерное зрение, наборы данных, Ultralytics, YOLO, обнаружение объектов, индивидуальная сегментация, оценка позы, классификация изображений, многократное отслеживание объектов +--- + +# Обзор наборов данных + +Ultralytics предоставляет поддержку различных наборов данных для выполнения задач компьютерного зрения, таких как обнаружение объектов, индивидуальная сегментация, оценка поз, классификация и многократное отслеживание объектов. Ниже приведен список основных наборов данных Ultralytics, а затем представлены описание каждой задачи компьютерного зрения и соответствующие наборы данных. + +!!! note + + 🚧 Наша многоязычная документация в настоящее время находится в стадии разработки, и мы усердно работаем над ее улучшением. Спасибо за терпение! 🙏 + +## [Наборы данных для обнаружения](../../datasets/detect/index.md) + +Обнаружение объектов с помощью ограничивающих рамок - это метод компьютерного зрения, который включает обнаружение и локализацию объектов на изображении путем рисования вокруг каждого объекта прямоугольной рамки. + +- [Argoverse](../../datasets/detect/argoverse.md): Набор данных, содержащий данные о 3D отслеживании и прогнозировании движения из городских условий с подробными аннотациями. +- [COCO](../../datasets/detect/coco.md): Масштабный набор данных, предназначенный для обнаружения объектов, сегментации и аннотирования с более чем 200 тыс. помеченных изображений. +- [COCO8](../../datasets/detect/coco8.md): Содержит первые 4 изображения из наборов COCO train и COCO val, подходит для быстрых тестов. +- [Global Wheat 2020](../../datasets/detect/globalwheat2020.md): Набор данных из изображений колосьев пшеницы, собранных со всего мира для задач обнаружения и локализации объектов. +- [Objects365](../../datasets/detect/objects365.md): Качественный набор данных большого масштаба для обнаружения объектов с 365 категориями объектов и более чем 600 тыс. помеченных изображений. +- [OpenImagesV7](../../datasets/detect/open-images-v7.md): Обширный набор данных от Google с 1,7 млн. изображений для обучения и 42 тыс. изображений для проверки. +- [SKU-110K](../../datasets/detect/sku-110k.md): Набор данных для плотного обнаружения объектов в розничной торговле с более чем 11 тыс. изображений и 1,7 млн. ограничивающих рамок. +- [VisDrone](../../datasets/detect/visdrone.md): Набор данных, содержащий данные для обнаружения объектов и многократного отслеживания из изображений, полученных с дронов, с более чем 10 тыс. изображений и видеопоследовательностей. +- [VOC](../../datasets/detect/voc.md): Набор данных Pascal Visual Object Classes (VOC) для обнаружения объектов и сегментации с 20 категориями объектов и более чем 11 тыс. изображений. +- [xView](../../datasets/detect/xview.md): Набор данных для обнаружения объектов на изображениях с воздуха с 60 категориями объектов и более чем 1 млн. аннотированных объектов. + +## [Наборы данных для индивидуальной сегментации](../../datasets/segment/index.md) + +Индивидуальная сегментация - это метод компьютерного зрения, включающий идентификацию и локализацию объектов на изображении на уровне пикселей. + +- [COCO](../../datasets/segment/coco.md): Масштабный набор данных, разработанный для задач обнаружения объектов, сегментации и аннотирования с более чем 200 тыс. помеченных изображений. +- [COCO8-seg](../../datasets/segment/coco8-seg.md): Уменьшенный набор данных для задач индивидуальной сегментации, содержащий подмножество из 8 изображений COCO с аннотациями сегментации. + +## [Оценка поз](../../datasets/pose/index.md) + +Оценка позы - это техника, используемая для определения позы объекта относительно камеры или системы координат мира. + +- [COCO](../../datasets/pose/coco.md): Масштабный набор данных с аннотациями человеческой позы, разработанный для задач оценки позы. +- [COCO8-pose](../../datasets/pose/coco8-pose.md): Уменьшенный набор данных для задач оценки позы, содержащий подмножество из 8 изображений COCO с аннотациями позы человека. +- [Tiger-pose](../../datasets/pose/tiger-pose.md): Компактный набор данных из 263 изображений, сфокусированных на тиграх, аннотированных 12 ключевыми точками на тигре для задач оценки позы. + +## [Классификация](../../datasets/classify/index.md) + +Классификация изображений - это задача компьютерного зрения, которая включает категоризацию изображения в один или несколько заранее определенных классов или категорий на основе его визуального содержания. + +- [Caltech 101](../../datasets/classify/caltech101.md): Набор данных, содержащий изображения 101 категории объектов для задач классификации изображений. +- [Caltech 256](../../datasets/classify/caltech256.md): Расширенная версия Caltech 101 с 256 категориями объектов и более сложными изображениями. +- [CIFAR-10](../../datasets/classify/cifar10.md): Набор данных из 60 тыс. цветных изображений размером 32x32 в 10 классах, по 6 тыс. изображений на класс. +- [CIFAR-100](../../datasets/classify/cifar100.md): Расширенная версия CIFAR-10 со 100 категориями объектов и 600 изображениями на класс. +- [Fashion-MNIST](../../datasets/classify/fashion-mnist.md): Набор данных из 70 тыс. изображений в оттенках серого 10 модных категорий для задач классификации изображений. +- [ImageNet](../../datasets/classify/imagenet.md): Масштабный набор данных для обнаружения объектов и классификации изображений с более чем 14 млн. изображений и 20 тыс. категорий. +- [ImageNet-10](../../datasets/classify/imagenet10.md): Уменьшенное подмножество ImageNet с 10 категориями для более быстрого экспериментирования и тестирования. +- [Imagenette](../../datasets/classify/imagenette.md): Уменьшенное подмножество ImageNet, содержащее 10 легко различаемых классов для более быстрого обучения и тестирования. +- [Imagewoof](../../datasets/classify/imagewoof.md): Более сложное подмножество ImageNet, содержащее 10 категорий пород собак для задач классификации изображений. +- [MNIST](../../datasets/classify/mnist.md): Набор данных из 70 тыс. изображений в оттенках серого рукописных цифр для задач классификации изображений. + +## [Ориентированные Ограничивающие Рамки (OBB)](../../datasets/obb/index.md) + +Ориентированные ограничивающие рамки (OBB) - это метод в компьютерном зрении для обнаружения наклонных объектов на изображениях с использованием повернутых ограничивающих рамок, часто применяемый к аэрофотосъемке и спутниковым изображениям. + +- [DOTAv2](../../datasets/obb/dota-v2.md): Популярный набор данных аэрофотосъемки OBB с 1,7 миллионами инста nces и 11,268 изображениями. + +## [Многократное отслеживание объектов](../../datasets/track/index.md) + +Многократное отслеживание объектов - это техника компьютерного зрения, которая включает обнаружение и отслеживание нескольких объектов во времени в видеопоследовательности. + +- [Argoverse](../../datasets/detect/argoverse.md): Набор данных, содержащий данные о 3D отслеживании и прогнозировании движения из городских условий с подробными аннотациями для задач многократного отслеживания объектов. +- [VisDrone](../../datasets/detect/visdrone.md): Набор данных, содержащий данные для обнаружения объектов и многократного отслеживания из изображений, полученных с дронов, с более чем 10 тыс. изображений и видеопоследовательностей. + +## Внесение новых наборов данных + +Внесение нового набора данных включает несколько шагов для обеспечения его соответствия существующей инфраструктуре. Ниже приведены необходимые шаги: + +### Шаги для внесения нового набора данных + +1. **Сбор изображений**: Соберите изображения, которые принадлежат набору данных. Их можно собрать из различных источников, таких как публичные базы данных или ваш собственный сбор. + +2. **Аннотация изображений**: Пометьте эти изображения ограничивающими рамками, сегментами или ключевыми точками в зависимости от задачи. + +3. **Экспорт аннотаций**: Конвертируйте эти аннотации в формат файлов YOLO *.txt, который поддерживается Ultralytics. + +4. **Организация набора данных**: Распределите ваш набор данных в правильную структуру папок. У вас должны быть каталоги верхнего уровня `train/` и `val/`, и в каждом из них подкаталоги `images/` и `labels/`. + + ``` + dataset/ + ├── train/ + │ ├── images/ + │ └── labels/ + └── val/ + ├── images/ + └── labels/ + ``` + +5. **Создание файла `data.yaml`**: В корневой директории вашего набора данных создайте файл `data.yaml`, который описывает набор данных, классы и другую необходимую информацию. + +6. **Оптимизация изображений (опционально)**: Если вы хотите уменьшить размер набора данных для более эффективной обработки, вы можете оптимизировать изображения с помощью приведенного ниже кода. Это не является обязательным, но рекомендуется для уменьшения размеров набора данных и ускорения скорости загрузки. + +7. **Архивация набора данных**: Сжать всю папку набора данных в zip-файл. + +8. **Документация и Pull Request (PR)**: Создайте страницу документации, описывающую ваш набор данных и его соответствие существующей структуре. После этого отправьте Pull Request. Смотрите [Руководство по внесению вклада в Ultralytics](https://docs.ultralytics.com/help/contributing) для получения более подробной информации о том, как отправить PR. + +### Пример кода для оптимизации и архивации набора данных + +!!! example "Оптимизация и архивация набора данных" + + === "Python" + + ```python + from pathlib import Path + from ultralytics.data.utils import compress_one_image + from ultralytics.utils.downloads import zip_directory + + # Определите директорию набора данных + path = Path('path/to/dataset') + + # Оптимизация изображений в наборе данных (опционально) + for f in path.rglob('*.jpg'): + compress_one_image(f) + + # Архивация набора данных в 'path/to/dataset.zip' + zip_directory(path) + ``` + +Следуя этим шагам, вы сможете внести новый набор данных, который хорошо интегрируется с существующей структурой Ultralytics. diff --git a/docs/ru/index.md b/docs/ru/index.md new file mode 100644 index 00000000..c565e945 --- /dev/null +++ b/docs/ru/index.md @@ -0,0 +1,82 @@ +--- +comments: true +description: Изучите полное руководство по Ultralytics YOLOv8, модели обнаружения объектов и сегментации изображений с высокой скоростью и точностью. Учебники по установке, предсказаниям, тренировке и многое другое. +keywords: Ultralytics, YOLOv8, обнаружение объектов, сегментация изображений, машинное обучение, глубокое обучение, компьютерное зрение, установка YOLOv8, предсказание YOLOv8, тренировка YOLOv8, история YOLO, лицензии YOLO +--- + +
+

+ + Ultralytics YOLO banner +

+ GitHub Ultralytics + + LinkedIn Ultralytics + + Twitter Ultralytics + + YouTube Ultralytics + + TikTok Ultralytics + + Instagram Ultralytics + + Discord Ultralytics +
+
+ CI Ultralytics + Покрытие кода Ultralytics + Цитирование YOLOv8 + Загрузки Docker +
+ Запустить на Gradient + Открыть в Colab + Открыть в Kaggle +
+ +Представляем [Ultralytics](https://ultralytics.com) [YOLOv8](https://github.com/ultralytics/ultralytics) — последнюю версию знаменитой модели для обнаружения объектов в реальном времени и сегментации изображений. YOLOv8 основан на передовом прогрессе в области глубокого обучения и компьютерного зрения и предлагает непревзойденную производительность в отношении скорости и точности. Его оптимизированная конструкция делает его подходящим для различных приложений и легко адаптируемым к различным аппаратным платформам, от устройств на краю сети до облачных API. + +Исследуйте документацию YOLOv8 — обширный ресурс, разработанный, чтобы помочь вам понять и использовать его функции и возможности. Независимо от того, являетесь ли вы опытным практиком машинного обучения или новичком в этой области, этот центр ресурсов нацелен на максимальное раскрытие потенциала YOLOv8 в ваших проектах. + +!!! note + + 🚧 Наша многоязычная документация в настоящее время находится в стадии разработки, и мы усердно работаем над ее улучшением. Спасибо за ваше терпение! 🙏 + +## С чего начать + +- **Установите** `ultralytics` с помощью pip и приступайте к работе за несколько минут   [:material-clock-fast: Начать работу](quickstart.md){ .md-button } +- **Предскажите** новые изображения и видео с помощью YOLOv8   [:octicons-image-16: Предсказания для изображений](modes/predict.md){ .md-button } +- **Тренируйте** новую модель YOLOv8 на своих собственных наборах данных   [:fontawesome-solid-brain: Тренировать модель](modes/train.md){ .md-button } +- **Исследуйте** задачи YOLOv8, такие как сегментация, классификация, оценка позы и отслеживание   [:material-magnify-expand: Исследовать задачи](tasks/index.md){ .md-button } + +

+
+ +
+ Смотрите: Как тренировать модель YOLOv8 на своем пользовательском наборе данных в Google Colab. +

+ +## YOLO: Краткая история + +[YOLO](https://arxiv.org/abs/1506.02640) (You Only Look Once — «Смотришь только один раз»), популярная модель для обнаружения объектов и сегментации изображений, была разработана Джозефом Редмоном и Али Фархади из Вашингтонского университета. Запущенная в 2015 году, YOLO быстро обрела популярность благодаря своей высокой скорости и точности. + +- [YOLOv2](https://arxiv.org/abs/1612.08242), выпущенная в 2016 году, улучшила оригинальную модель, включив в себя пакетную нормализацию, якорные окна и кластеры размеров. +- [YOLOv3](https://pjreddie.com/media/files/papers/YOLOv3.pdf), запущенная в 2018 году, дополнительно улучшила производительность модели, используя более эффективную основную сеть, множество якорей и пирамидальное пространственное пулинг. +- [YOLOv4](https://arxiv.org/abs/2004.10934) была выпущена в 2020 году, представив такие инновации, как увеличение данных Mosaic, новую свободную от якорьной голову детектирования и новую функцию потерь. +- [YOLOv5](https://github.com/ultralytics/yolov5) дальше улучшила производительность модели и добавила новые функции, такие как оптимизация гиперпараметров, интегрированнное отслеживание экспериментов и автоматический экспорт в популярные форматы. +- [YOLOv6](https://github.com/meituan/YOLOv6) была опубликована в открытом доступе компанией [Meituan](https://about.meituan.com/) в 2022 году и используется во многих автономных роботах доставки компании. +- [YOLOv7](https://github.com/WongKinYiu/yolov7) добавила дополнительные задачи, такие как оценка позы по набору данных ключевых точек COCO. +- [YOLOv8](https://github.com/ultralytics/ultralytics) — последняя версия YOLO от Ultralytics. Будучи передовой, современной моделью, YOLOv8 основана на успехе предыдущих версий, внедряя новые функции и усовершенствования для повышения производительности, гибкости и эффективности. YOLOv8 поддерживает полный спектр задач в области компьютерного зрения, включая [обнаружение](tasks/detect.md), [сегментацию](tasks/segment.md), [оценку позы](tasks/pose.md), [отслеживание](modes/track.md) и [классификацию](tasks/classify.md). Это многосторонность позволяет пользователям использовать возможности YOLOv8 в самых разнообразных приложениях и сферах деятельности. + +## Лицензии YOLO: Как лицензируется YOLO от Ultralytics? + +Ultralytics предлагает два варианта лицензирования для удовлетворения разнообразных сценариев использования: + +- **Лицензия AGPL-3.0**: Эта одобренная [OSI](https://opensource.org/licenses/) лицензия с открытым исходным кодом идеально подходит для студентов и энтузиастов, способствуя открытому сотрудничеству и обмену знаниями. Подробную информацию смотрите в файле [LICENSE](https://github.com/ultralytics/ultralytics/blob/main/LICENSE). +- **Корпоративная лицензия**: Разработанная для коммерческого использования, эта лицензия позволяет беспрепятственно интегрировать программное обеспечение и AI-модели Ultralytics в товары и услуги коммерческого назначения, обходя требования открытого исходного кода AGPL-3.0. Если ваш сценарий включает внедрение наших решений в коммерческое предложение, обратитесь через [Лицензирование Ultralytics](https://ultralytics.com/license). + +Наша стратегия лицензирования разработана, чтобы обеспечить возврат усовершенствований наших проектов с открытым исходным кодом обществу. Мы твердо привержены принципам открытого исходного кода ❤️ и наша миссия заключается в гарантировании того, что наши вклады могут быть использованы и расширены таким образом, который будет полезен для всех. diff --git a/docs/ru/models/index.md b/docs/ru/models/index.md new file mode 100644 index 00000000..ea582434 --- /dev/null +++ b/docs/ru/models/index.md @@ -0,0 +1,94 @@ +--- +comments: true +description: Изучите разнообразные модели семейства YOLO, SAM, MobileSAM, FastSAM, YOLO-NAS и RT-DETR, поддерживаемые Ultralytics. Начните с примеров использования в командной строке и Python. +keywords: Ultralytics, документация, YOLO, SAM, MobileSAM, FastSAM, YOLO-NAS, RT-DETR, модели, архитектуры, Python, CLI +--- + +# Модели, поддерживаемые Ultralytics + +Добро пожаловать в документацию по моделям Ultralytics! Мы поддерживаем широкий спектр моделей, каждая из которых адаптирована для конкретных задач, таких как [обнаружение объектов](../tasks/detect.md), [сегментация на уровне экземпляров](../tasks/segment.md), [классификация изображений](../tasks/classify.md), [оценка позы](../tasks/pose.md) и [множественное отслеживание объектов](../modes/track.md). Если вы заинтересованы в добавлении архитектуры вашей модели в Ultralytics, ознакомьтесь с нашим [Руководством для участников](../../help/contributing.md). + +!!! note + + 🚧 Наша многоязычная документация в настоящее время находится в стадии разработки, и мы усердно работаем над ее улучшением. Спасибо за ваше терпение! 🙏 + +## Основные модели + +Вот некоторые ключевые модели, поддерживаемые нами: + +1. **[YOLOv3](../../models/yolov3.md)**: Третье поколение семейства моделей YOLO, созданное Джозефом Редмоном, известное своей эффективной способностью обнаружения объектов в реальном времени. +2. **[YOLOv4](../../models/yolov4.md)**: Обновление YOLOv3, оптимизированное для darknet, выпущенное Алексеем Бочковским в 2020 году. +3. **[YOLOv5](../../models/yolov5.md)**: Улучшенная версия архитектуры YOLO от Ultralytics, предлагающая лучшие компромиссы производительности и скорости по сравнению с предыдущими версиями. +4. **[YOLOv6](../../models/yolov6.md)**: Выпущена компанией [Meituan](https://about.meituan.com/) в 2022 году и используется во многих роботах автономной доставки компании. +5. **[YOLOv7](../../models/yolov7.md)**: Обновленные модели YOLO, выпущенные в 2022 году авторами YOLOv4. +6. **[YOLOv8](../../models/yolov8.md)**: Последняя версия семейства YOLO с расширенными возможностями, такими как сегментация на уровне экземпляров, оценка позы/ключевых точек и классификация. +7. **[Segment Anything Model (SAM)](../../models/sam.md)**: Модель Segment Anything от Meta (SAM). +8. **[Mobile Segment Anything Model (MobileSAM)](../../models/mobile-sam.md)**: MobileSAM для мобильных приложений от Университета Кён Хи. +9. **[Fast Segment Anything Model (FastSAM)](../../models/fast-sam.md)**: FastSAM от Группы анализа изображений и видео, Института автоматики, Китайская академия наук. +10. **[YOLO-NAS](../../models/yolo-nas.md)**: Модели YOLO с поиском архитектуры нейронных сетей (NAS). +11. **[Realtime Detection Transformers (RT-DETR)](../../models/rtdetr.md)**: Модели Realtime Detection Transformer (RT-DETR) от Baidu на основе PaddlePaddle. + +

+
+ +
+ Смотрите: Запуск моделей YOLO от Ultralytics всего в несколько строк кода. +

+ +## Начало работы: Примеры использования + +!!! example "" + + === "Python" + + Предварительно обученные модели PyTorch `*.pt` а также файлы конфигурации `*.yaml` могут быть переданы в классы `YOLO()`, `SAM()`, `NAS()` и `RTDETR()` для создания экземпляра модели в Python: + + ```python + from ultralytics import YOLO + + # Загрузка модели YOLOv8n, предварительно обученной на COCO + model = YOLO('yolov8n.pt') + + # Отображение информации о модели (необязательно) + model.info() + + # Обучение модели на примерном наборе данных COCO8 в течение 100 эпох + results = model.train(data='coco8.yaml', epochs=100, imgsz=640) + + # Запуск использования модели YOLOv8n на изображении 'bus.jpg' + results = model('path/to/bus.jpg') + ``` + + === "CLI" + + Команды CLI доступны для непосредственного запуска моделей: + + ```bash + # Загрузка и обучение модели YOLOv8n, предварительно обученной на COCO, на примерном наборе данных COCO8 в течение 100 эпох + yolo train model=yolov8n.pt data=coco8.yaml epochs=100 imgsz=640 + + # Загрузка и запуск использования модели YOLOv8n, предварительно обученной на COCO, на изображении 'bus.jpg' + yolo predict model=yolov8n.pt source=path/to/bus.jpg + ``` + +## Вклад в новые модели + +Заинтересованы в добавлении вашей модели в Ultralytics? Замечательно! Мы всегда открыты для расширения нашего портфолио моделей. + +1. **Создать форк репозитория**: Начните с создания форка [репозитория Ultralytics на GitHub](https://github.com/ultralytics/ultralytics). + +2. **Клонировать ваш форк**: Клонируйте ваш форк на локальный компьютер и создайте новую ветку для работы. + +3. **Реализовать вашу модель**: Добавьте вашу модель, следуя стандартам кодирования и руководящим принципам, приведенным в нашем [Руководстве для участников](../../help/contributing.md). + +4. **Тщательно протестировать**: Убедитесь, что ваша модель тестируется тщательно как самостоятельно, так и как часть нашего конвейера. + +5. **Создать запрос на добавление**: После того, как будете удовлетворены вашей моделью, создайте запрос на добавление в основной репозиторий для рассмотрения. + +6. **Код-ревью и слияние**: После рецензирования, если ваша модель соответствует нашим критериям, она будет добавлена в основной репозиторий. + +Для более подробных шагов, смотрите наше [Руководство для участников](../../help/contributing.md). diff --git a/docs/ru/modes/benchmark.md b/docs/ru/modes/benchmark.md new file mode 100644 index 00000000..ea6e794d --- /dev/null +++ b/docs/ru/modes/benchmark.md @@ -0,0 +1,94 @@ +--- +comments: true +description: Узнайте, как профилировать скорость и точность YOLOv8 в различных форматах экспорта; получите информацию о метриках mAP50-95, accuracy_top5 и др. +keywords: Ultralytics, YOLOv8, бенчмаркинг, профилирование скорости, профилирование точности, mAP50-95, accuracy_top5, ONNX, OpenVINO, TensorRT, форматы экспорта YOLO +--- + +# Бенчмаркинг моделей с Ultralytics YOLO + +Экосистема и интеграции Ultralytics YOLO + +## Введение + +После того, как ваша модель обучена и валидирована, следующим логическим шагом является оценка ее производительности в различных реальных сценариях. Режим бенчмаркинга в Ultralytics YOLOv8 служит этой цели, предоставляя надежный инструментарий для оценки скорости и точности вашей модели в ряде форматов экспорта. + +## Почему бенчмаркинг критичен? + +- **Обоснованные решения:** Получение представления о компромиссе между скоростью и точностью. +- **Распределение ресурсов:** Понимание производительности различных форматов экспорта на разном оборудовании. +- **Оптимизация:** Выяснение, какой формат экспорта предлагает лучшую производительность для вашего конкретного случая. +- **Эффективность затрат:** Сделайте использование аппаратных ресурсов более эффективным на основе результатов бенчмаркинга. + +### Ключевые метрики в режиме бенчмаркинга + +- **mAP50-95:** Для детектирования объектов, сегментации и оценки поз. +- **accuracy_top5:** Для классификации изображений. +- **Время инференса:** Время, затрачиваемое на каждое изображение в миллисекундах. + +### Поддерживаемые форматы экспорта + +- **ONNX:** Для оптимальной производительности ЦП +- **TensorRT:** Для максимальной эффективности GPU +- **OpenVINO:** Для оптимизации под аппаратное обеспечение Intel +- **CoreML, TensorFlow SavedModel и другие:** Для разнообразных потребностей развертывания. + +!!! tip "Совет" + + * Экспортируйте в ONNX или OpenVINO для ускорения процессора до 3 раз. + * Экспортируйте в TensorRT для ускорения GPU до 5 раз. + +## Примеры использования + +Запустите бенчмарк YOLOv8n на всех поддерживаемых форматах экспорта, включая ONNX, TensorRT и т. д. Смотрите раздел Аргументы ниже для полного списка параметров экспорта. + +!!! example "" + + === "Python" + + ```python + from ultralytics.utils.benchmarks import benchmark + + # Бенчмарк на GPU + benchmark(model='yolov8n.pt', data='coco8.yaml', imgsz=640, half=False, device=0) + ``` + === "CLI" + + ```bash + yolo benchmark model=yolov8n.pt data='coco8.yaml' imgsz=640 half=False device=0 + ``` + +## Аргументы + +Аргументы, такие как `model`, `data`, `imgsz`, `half`, `device` и `verbose`, предоставляют пользователям гибкость для тонкой настройки бенчмарков под их конкретные потребности и сравнения производительности различных форматов экспорта с легкостью. + +| Ключ | Значение | Описание | +|-----------|----------|----------------------------------------------------------------------------------| +| `model` | `None` | путь к файлу модели, например yolov8n.pt, yolov8n.yaml | +| `data` | `None` | путь к YAML, ссылающемуся на набор данных для бенчмаркинга (под меткой `val`) | +| `imgsz` | `640` | размер изображения как скаляр или список (h, w), например (640, 480) | +| `half` | `False` | квантование FP16 | +| `int8` | `False` | квантование INT8 | +| `device` | `None` | устройство для запуска, например cuda device=0 или device=0,1,2,3 или device=cpu | +| `verbose` | `False` | не продолжать при ошибке (bool), или пороговое значение для `val` (float) | + +## Форматы экспорта + +Бенчмарки попытаются автоматически запустить для всех возможных форматов экспорта ниже. + +| Формат | Аргумент `format` | Модель | Метаданные | Аргументы | +|--------------------------------------------------------------------|-------------------|---------------------------|------------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | ✅ | `imgsz`, `half` | + +Смотрите полную информацию о `export` на странице [Экспорт](https://docs.ultralytics.com/modes/export/). diff --git a/docs/ru/modes/export.md b/docs/ru/modes/export.md new file mode 100644 index 00000000..f03eaa29 --- /dev/null +++ b/docs/ru/modes/export.md @@ -0,0 +1,108 @@ +--- +comments: true +description: Пошаговое руководство по экспорту ваших моделей YOLOv8 в различные форматы, такие как ONNX, TensorRT, CoreML и другие, для развертывания. Изучите сейчас!. +keywords: YOLO, YOLOv8, Ultralytics, Экспорт модели, ONNX, TensorRT, CoreML, TensorFlow SavedModel, OpenVINO, PyTorch, экспорт модели +--- + +# Экспорт модели с Ultralytics YOLO + +Экосистема и интеграции Ultralytics YOLO + +## Введение + +Основная цель тренировки модели — её развертывание для реальных приложений. Режим экспорта в Ultralytics YOLOv8 предлагает множество вариантов для экспорта обученной модели в различные форматы, обеспечивая возможность развертывания на разных платформах и устройствах. Это исчерпывающее руководство направлено на то, чтобы провести вас через тонкости экспорта моделей, демонстрируя, как достичь максимальной совместимости и производительности. + +

+
+ +
+ Смотрите: Как экспортировать обученную пользовательскую модель Ultralytics YOLOv8 и запустить живое воспроизведение на веб-камере. +

+ +## Почему стоит выбрать режим экспорта YOLOv8? + +- **Универсальность:** Экспорт в несколько форматов, включая ONNX, TensorRT, CoreML и другие. +- **Производительность:** Увеличение скорости на GPU до 5 раз с TensorRT и ускорение на CPU до 3 раз с ONNX или OpenVINO. +- **Совместимость:** Сделайте вашу модель универсально развертываемой в различных аппаратных и программных средах. +- **Простота использования:** Простой интерфейс командной строки и Python API для быстрого и простого экспорта моделей. + +### Ключевые особенности режима экспорта + +Вот некоторые из ключевых функций: + +- **Экспорт одним кликом:** Простые команды для экспорта в разные форматы. +- **Пакетный экспорт:** Экспорт моделей, способных к пакетной обработке. +- **Оптимизированное предсказание:** Экспортированные модели оптимизированы для более быстрого предсказания. +- **Учебные видео:** Глубокие руководства и обучающие видео для гладкого опыта экспорта. + +!!! tip "Совет" + + * Экспортируйте в ONNX или OpenVINO для ускорения CPU до 3 раз. + * Экспортируйте в TensorRT для увеличения скорости на GPU до 5 раз. + +## Примеры использования + +Экспорт модели YOLOv8n в другой формат, например ONNX или TensorRT. Смотрите раздел Аргументы ниже для полного списка аргументов экспорта. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Загрузите модель + model = YOLO('yolov8n.pt') # загрузка официальной модели + model = YOLO('path/to/best.pt') # загрузка обученной пользовательской модели + + # Экспорт модели + model.export(format='onnx') + ``` + === "CLI" + + ```bash + yolo export model=yolov8n.pt format=onnx # экспорт официальной модели + yolo export model=path/to/best.pt format=onnx # экспорт обученной пользовательской модели + ``` + +## Аргументы + +Настройки экспорта моделей YOLO относятся к различным конфигурациям и опциям, используемым для сохранения или экспорта модели для использования в других средах или платформах. Эти настройки могут влиять на производительность модели, размер и совместимость с разными системами. Некоторые общие настройки экспорта YOLO включают формат экспортируемого файла модели (например, ONNX, TensorFlow SavedModel), устройство, на котором будет запущена модель (например, CPU, GPU), а также наличие дополнительных функций, таких как маски или несколько меток на коробку. Другие факторы, которые могут повлиять на процесс экспорта, включают конкретное задание, для которого используется модель, и требования или ограничения целевой среды или платформы. Важно тщательно рассмотреть и настроить эти параметры, чтобы убедиться, что экспортированная модель оптимизирована для предполагаемого использования и может быть эффективно использована в целевой среде. + +| Ключ | Значение | Описание | +|-------------|-----------------|---------------------------------------------------------------------------| +| `format` | `'torchscript'` | формат для экспорта | +| `imgsz` | `640` | размер изображения в виде скаляра или списка (h, w), например, (640, 480) | +| `keras` | `False` | использовать Keras для экспорта TF SavedModel | +| `optimize` | `False` | TorchScript: оптимизация для мобильных устройств | +| `half` | `False` | квантование FP16 | +| `int8` | `False` | квантование INT8 | +| `dynamic` | `False` | ONNX/TensorRT: динамические оси | +| `simplify` | `False` | ONNX/TensorRT: упрощение модели | +| `opset` | `None` | ONNX: версия набора операций (необязательный, по умолчанию последний) | +| `workspace` | `4` | TensorRT: размер рабочей области (ГБ) | +| `nms` | `False` | CoreML: добавление NMS | + +## Форматы экспорта + +Доступные форматы экспорта YOLOv8 указаны в таблице ниже. Вы можете экспортировать в любой формат, используя аргумент `format`, например, `format='onnx'` или `format='engine'`. + +| Формат | Аргумент `format` | Модель | Метаданные | Аргументы | +|--------------------------------------------------------------------|-------------------|---------------------------|------------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | ✅ | `imgsz`, `half` | diff --git a/docs/ru/modes/index.md b/docs/ru/modes/index.md new file mode 100644 index 00000000..7f2a9575 --- /dev/null +++ b/docs/ru/modes/index.md @@ -0,0 +1,73 @@ +--- +comments: true +description: От обучения до отслеживания - используйте все возможности YOLOv8 от Ultralytics. Получите информацию и примеры для каждого поддерживаемого режима, включая проверку, экспорт и бенчмаркинг. +keywords: Ultralytics, YOLOv8, Машинное обучение, Обнаружение объектов, Обучение, Проверка, Предсказание, Экспорт, Отслеживание, Бенчмаркинг +--- + +# Режимы Ultralytics YOLOv8 + +Экосистема Ultralytics YOLO и интеграции + +## Введение + +Ultralytics YOLOv8 - это не просто еще одна модель обнаружения объектов; это многофункциональная платформа, предназначенная для охвата всего жизненного цикла моделей машинного обучения - от ввода данных и обучения модели до валидации, развертывания и отслеживания в реальном мире. Каждый режим служит определенной цели и разработан, чтобы предложить вам гибкость и эффективность, необходимую для различных задач и сценариев использования. + +

+
+ +
+ Смотрите: Руководство по режимам Ultralytics: Обучение, Проверка, Предсказание, Экспорт и Бенчмаркинг. +

+ +### Обзор режимов + +Понимание различных **режимов**, которые поддерживает Ultralytics YOLOv8, критически важно для эффективного использования ваших моделей: + +- **Режим обучения (Train mode)**: Настройте вашу модель на пользовательские или предзагруженные наборы данных. +- **Режим проверки (Val mode)**: Контрольная точка после обучения для валидации производительности модели. +- **Режим предсказания (Predict mode)**: Раскройте предсказательную мощь вашей модели на данных из реального мира. +- **Режим экспорта (Export mode)**: Подготовьте вашу модель к развертыванию в различных форматах. +- **Режим отслеживания (Track mode)**: Расширьте вашу модель обнаружения объектов до приложений отслеживания в реальном времени. +- **Режим бенчмаркинга (Benchmark mode)**: Проанализируйте скорость и точность вашей модели в разнообразных средах развертывания. + +Это исчерпывающее руководство направлено на то, чтобы дать вам обзор и практические сведения о каждом режиме, помогая вам использовать полный потенциал YOLOv8. + +## [Обучение (Train)](train.md) + +Режим обучения используется для обучения модели YOLOv8 на пользовательском наборе данных. В этом режиме модель обучается с использованием указанного набора данных и гиперпараметров. Процесс обучения включает в себя оптимизацию параметров модели, чтобы она могла точно предсказывать классы и местоположения объектов на изображении. + +[Примеры обучения](train.md){ .md-button .md-button--primary} + +## [Проверка (Val)](val.md) + +Режим проверки используется для валидации модели YOLOv8 после ее обучения. В этом режиме модель оценивается на наборе данных для валидации, чтобы измерить ее точность и способность к обобщению. Этот режим может быть использован для настройки гиперпараметров модели с целью улучшения ее производительности. + +[Примеры проверки](val.md){ .md-button .md-button--primary} + +## [Предсказание (Predict)](predict.md) + +Режим предсказания используется для выполнения предсказаний с использованием обученной модели YOLOv8 на новых изображениях или видео. В этом режиме модель загружается из файла контрольной точки, и пользователь может предоставить изображения или видео для выполнения вывода. Модель предсказывает классы и местоположения объектов во входных изображениях или видео. + +[Примеры предсказания](predict.md){ .md-button .md-button--primary} + +## [Экспорт (Export)](export.md) + +Режим экспорта используется для экспортирования модели YOLOv8 в формат, который может быть использован для развертывания. В этом режиме модель преобразуется в формат, который может быть использован другими программными приложениями или аппаратными устройствами. Этот режим полезен при развертывании модели в производственной среде. + +[Примеры экспорта](export.md){ .md-button .md-button--primary} + +## [Отслеживание (Track)](track.md) + +Режим отслеживания используется для отслеживания объектов в реальном времени с использованием модели YOLOv8. В этом режиме модель загружается из файла контрольной точки, и пользователь может предоставить прямую видеотрансляцию для выполнения отслеживания объектов в реальном времени. Этот режим полезен для приложений, таких как системы видеонаблюдения или беспилотные автомобили. + +[Примеры отслеживания](track.md){ .md-button .md-button--primary} + +## [Бенчмаркинг (Benchmark)](benchmark.md) + +Режим бенчмаркинга используется для профилирования скорости и точности различных форматов экспорта для YOLOv8. Бенчмарки предоставляют информацию о размере экспортируемого формата, его метриках `mAP50-95` (для обнаружения объектов, сегментации и позы) или метриках `accuracy_top5` (для классификации), а также время вывода в миллисекундах на изображение для различных форматов экспорта, таких как ONNX, OpenVINO, TensorRT и других. Эта информация может помочь пользователям выбрать оптимальный формат экспорта для их конкретного сценария использования на основе их требований к скорости и точности. + +[Примеры бенчмаркинга](benchmark.md){ .md-button .md-button--primary} diff --git a/docs/ru/modes/predict.md b/docs/ru/modes/predict.md new file mode 100644 index 00000000..7d00c0cc --- /dev/null +++ b/docs/ru/modes/predict.md @@ -0,0 +1,226 @@ +--- +comments: true +description: Узнайте, как использовать режим предсказаний YOLOv8 для различных задач. Изучите различные источники вывода, такие как изображения, видео и форматы данных. +keywords: Ultralytics, YOLOv8, режим предсказаний, источники вывода, задачи предсказания, режим потоковой передачи, обработка изображений, обработка видео, машинное обучение, искусственный интеллект +--- + +# Прогнозирование моделью Ultralytics YOLO + +Экосистема и интеграции Ultralytics YOLO + +## Введение + +В мире машинного обучения и компьютерного зрения процесс извлечения информации из визуальных данных называется 'выводом' или 'предсказанием'. Ultralytics YOLOv8 предлагает мощную функцию, известную как **режим предсказаний**, который предназначен для высокопроизводительного реального времени вывода на широкий спектр источников данных. + +

+
+ +
+ Смотреть: Как извлечь результаты из модели Ultralytics YOLOv8 для пользовательских проектов. +

+ +## Прикладные области + +| Производство | Спорт | Безопасность | +|:-------------------------------------------------------------------------------------------------------------------------------:|:-----------------------------------------------------------------------------------------------------------------------------:|:-------------------------------------------------------------------------------------------------------------------------------:| +| ![Обнаружение автозапчастей](https://github.com/RizwanMunawar/ultralytics/assets/62513924/a0f802a8-0776-44cf-8f17-93974a4a28a1) | ![Обнаружение футболистов](https://github.com/RizwanMunawar/ultralytics/assets/62513924/7d320e1f-fc57-4d7f-a691-78ee579c3442) | ![Обнаружение падения людей](https://github.com/RizwanMunawar/ultralytics/assets/62513924/86437c4a-3227-4eee-90ef-9efb697bdb43) | +| Обнаружение автозапчастей | Обнаружение футболистов | Обнаружение падения людей | + +## Почему стоит использовать Ultralytics YOLO для вывода? + +Вот почему вам следует рассмотреть режим предсказаний YOLOv8 для ваших различных потребностей в выводе: + +- **Универсальность:** Возможность делать выводы по изображениям, видео и даже потоковым трансляциям. +- **Производительность:** Разработан для обработки данных в реальном времени без потери точности. +- **Простота использования:** Интуитивно понятные интерфейсы Python и CLI для быстрого развертывания и тестирования. +- **Высокая настраиваемость:** Различные настройки и параметры для настройки поведения модели вывода в соответствии с вашими конкретными требованиями. + +### Ключевые особенности режима предсказаний + +Режим предсказаний YOLOv8 разработан, чтобы быть надежным и универсальным, он включает в себя: + +- **Совместимость с несколькими источниками данных:** независимо от того, представлены ли ваши данные в виде отдельных изображений, коллекции изображений, видеофайлов или потокового видео, режим предсказаний покрывает все это. +- **Режим потоковой передачи:** Используйте функцию потоковой передачи для создания генератора объектов `Results`, экономящего память. Активируйте это, установив `stream=True` в методе вызова предиктора. +- **Пакетная обработка:** Возможность обрабатывать несколько изображений или видеокадров за один пакет, что дополнительно ускоряет время вывода. +- **Дружественная интеграция:** Легко интегрируется с существующими данными и другими программными компонентами благодаря гибкому API. + +Модели Ultralytics YOLO возвращают либо список объектов `Results`, либо генератор объектов `Results` в Python, экономящий память, когда `stream=True` передается в модель во время вывода: + +!!! example "Предсказание" + + === "Вернуть список с `stream=False`" + ```python + from ultralytics import YOLO + + # Загрузка модели + model = YOLO('yolov8n.pt') # предварительно обученная модель YOLOv8n + + # Пакетный вывод на список изображений + results = model(['im1.jpg', 'im2.jpg']) # вернуть список объектов Results + + # Обработка списка результатов + for result in results: + boxes = result.boxes # Объект Boxes для вывода bbox + masks = result.masks # Объект Masks для вывода масок сегментации + keypoints = result.keypoints # Объект Keypoints для вывода поз + probs = result.probs # Объект Probs для вывода вероятностей классификации + ``` + + === "Вернуть генератор с `stream=True`" + ```python + from ultralytics import YOLO + + # Загрузка модели + model = YOLO('yolov8n.pt') # предварительно обученная модель YOLOv8n + + # Пакетный вывод на список изображений + results = model(['im1.jpg', 'im2.jpg'], stream=True) # вернуть генератор объектов Results + + # Обработка генератора результатов + for result in results: + boxes = result.boxes # Объект Boxes для вывода bbox + masks = result.masks # Объект Masks для вывода масок сегментации + keypoints = result.keypoints # Объект Keypoints для вывода поз + probs = result.probs # Объект Probs для вывода вероятностей классификации + ``` + +## Источники вывода + +YOLOv8 может обрабатывать различные типы входных источников для вывода, как показано в таблице ниже. Источники включают статические изображения, видеопотоки и различные форматы данных. В таблице также указано, можно ли использовать каждый источник в режиме потоковой передачи с аргументом `stream=True` ✅. Режим потоковой передачи полезен для обработки видео или живых трансляций, так как создает генератор результатов вместо загрузки всех кадров в память. + +!!! tip "Совет" + + Используйте `stream=True` для обработки длинных видеороликов или больших наборов данных для эффективного управления памятью. Когда `stream=False`, результаты для всех кадров или точек данных хранятся в памяти, что может быстро накопиться и вызвать ошибки переполнения памяти для больших входов. В отличие от этого, `stream=True` использует генератор, который хранит в памяти результаты только текущего кадра или точки данных, значительно сокращая потребление памяти и предотвращая проблемы с переполнением памяти. + +| Источник | Аргумент | Тип | Заметки | +|-----------------|--------------------------------------------|------------------|---------------------------------------------------------------------------------------------------------------| +| изображение | `'image.jpg'` | `str` или `Path` | Одиночный файл изображения. | +| URL | `'https://ultralytics.com/images/bus.jpg'` | `str` | URL на изображение. | +| скриншот | `'screen'` | `str` | Снять скриншот. | +| PIL | `Image.open('im.jpg')` | `PIL.Image` | Формат HWC с RGB каналами. | +| OpenCV | `cv2.imread('im.jpg')` | `np.ndarray` | Формат HWC с BGR каналами `uint8 (0-255)`. | +| numpy | `np.zeros((640,1280,3))` | `np.ndarray` | Формат HWC с BGR каналами `uint8 (0-255)`. | +| torch | `torch.zeros(16,3,320,640)` | `torch.Tensor` | Формат BCHW с RGB каналами `float32 (0.0-1.0)`. | +| CSV | `'sources.csv'` | `str` или `Path` | CSV-файл, содержащий пути к изображениям, видео или каталогам. | +| видео ✅ | `'video.mp4'` | `str` или `Path` | Видеофайл в форматах, вроде MP4, AVI и т.д. | +| каталог ✅ | `'path/'` | `str` или `Path` | Путь к каталогу, содержащему изображения или видео. | +| глоб ✅ | `'path/*.jpg'` | `str` | Шаблон глоба для сопоставления нескольких файлов. Используйте символ `*` как подстановочный. | +| YouTube ✅ | `'https://youtu.be/LNwODJXcvt4'` | `str` | URL на видео YouTube. | +| поток ✅ | `'rtsp://example.com/media.mp4'` | `str` | URL для потоковых протоколов, таких как RTSP, RTMP, TCP, или IP-адрес. | +| много-потоков ✅ | `'list.streams'` | `str` или `Path` | Текстовый файл `*.streams` с одним URL потока на строку, например, 8 потоков запустятся с пакетом размером 8. | + +Ниже приведены примеры кода для использования каждого типа источника: + +!!! example "Источники предсказаний" + + === "изображение" + Выполнить вывод на файл изображения. + ```python + from ultralytics import YOLO + + # Загрузка предварительно обученной модели YOLOv8n + model = YOLO('yolov8n.pt') + + # Определите путь к файлу изображения + source = 'path/to/image.jpg' + + # Выполнить вывод на источник + results = model(source) # список объектов Results + ``` + + === "скриншот" + Выполнить вывод на текущее содержимое экрана в виде скриншота. + ```python + from ultralytics import YOLO + + # Загрузка предварительно обученной модели YOLOv8n + model = YOLO('yolov8n.pt') + + # Определение текущего скриншота как источника + source = 'screen' + + # Выполнить вывод на источник + results = model(source) # список объектов Results + ``` + + === "URL" + Выполнить вывод на изображение или видео, размещенные удаленно по URL. + ```python + from ultralytics import YOLO + + # Загрузка предварительно обученной модели YOLOv8n + model = YOLO('yolov8n.pt') + + # Определение URL удаленного изображения или видео + source = 'https://ultralytics.com/images/bus.jpg' + + # Выполнить вывод на источник + results = model(source) # список объектов Results + ``` + + === "PIL" + Выполнение вывода на изображение, открытое с помощью Python Imaging Library (PIL). + ```python + from PIL import Image + from ultralytics import YOLO + + # Загрузка предварительно обученной модели YOLOv8n + model = YOLO('yolov8n.pt') + + # Открытие изображения с помощью PIL + source = Image.open('path/to/image.jpg') + + # Выполнение вывода на источник + results = model(source) # список объектов Results + ``` + + === "OpenCV" + Выполнение вывода на изображение, прочитанное с помощью OpenCV. + ```python + import cv2 + from ultralytics import YOLO + + # Загрузка предварительно обученной модели YOLOv8n + model = YOLO('yolov8n.pt') + + # Чтение изображения с помощью OpenCV + source = cv2.imread('path/to/image.jpg') + + # Выполнение вывода на источник + results = model(source) # список объектов Results + ``` + + === "numpy" + Выполнение вывода на изображение, представленное в виде массива numpy. + ```python + import numpy as np + from ultralytics import YOLO + + # Загрузка предварительно обученной модели YOLOv8n + model = YOLO('yolov8n.pt') + + # Создание случайного массива numpy с формой HWC (640, 640, 3) со значениями в диапазоне [0, 255] и типом uint8 + source = np.random.randint(low=0, high=255, size=(640, 640, 3), dtype='uint8') + + # Выполнение вывода на источник + results = model(source) # список объектов Results + ``` + + === "torch" + Выполнение вывода на изображение, представленное в виде тензора PyTorch. + ```python + import torch + from ultralytics import YOLO + + # Загрузка предварительно обученной модели YOLOv8n + model = YOLO('yolov8n.pt') + + # Создание случайного тензора torch с формой BCHW (1, 3, 640, 640) со значениями в диапазоне [0, 1] и типом float32 + source = torch.rand(1, 3, 640, 640, dtype=torch.float32) + + # Выполнение вывода на источник + results = model(source) # список объектов Results diff --git a/docs/ru/modes/track.md b/docs/ru/modes/track.md new file mode 100644 index 00000000..f2ac6c82 --- /dev/null +++ b/docs/ru/modes/track.md @@ -0,0 +1,200 @@ +--- +comments: true +description: Узнайте, как использовать Ultralytics YOLO для отслеживания объектов в видеопотоках. Руководства по использованию различных трекеров и настройке конфигурации трекера. +keywords: Ultralytics, YOLO, отслеживание объектов, видеопотоки, BoT-SORT, ByteTrack, руководство на Python, руководство CLI +--- + +# Множественное отслеживание объектов с помощью Ultralytics YOLO + +Примеры множественного отслеживания объектов + +Отслеживание объектов в сфере видеоаналитики является ключевой задачей, которая определяет не только местоположение и класс объектов в кадре, но также поддерживает уникальный ID для каждого обнаруженного объекта по мере развития видео. Приложения безграничны — от наблюдения и безопасности до аналитики реального времени в спорте. + +## Почему стоит выбрать Ultralytics YOLO для отслеживания объектов? + +Вывод с трекеров Ultralytics согласуется со стандартным обнаружением объектов, но имеет добавленные ID объектов. Это упрощает отслеживание объектов в видеопотоках и выполнение последующей аналитики. Вот почему вы должны рассмотреть использование Ultralytics YOLO для ваших потребностей в отслеживании объектов: + +- **Эффективность:** Обработка видеопотоков в режиме реального времени без потери точности. +- **Гибкость:** Поддержка множества алгоритмов отслеживания и конфигураций. +- **Простота использования:** Простой Python API и CLI-опции для быстрой интеграции и развертывания. +- **Настраиваемость:** Легкость использования с пользовательскими обученными моделями YOLO, позволяющая интеграцию в специфические для домена приложения. + +

+
+ +
+ Смотрите: Обнаружение объектов и отслеживание с Ultralytics YOLOv8. +

+ +## Прикладные применения + +| Транспорт | Ритейл | Аквакультура | +|:---------------------------------------------------------------------------------------------------------------------------------------:|:------------------------------------------------------------------------------------------------------------------------:|:----------------------------------------------------------------------------------------------------------------------:| +| ![Отслеживание транспортных средств](https://github.com/RizwanMunawar/ultralytics/assets/62513924/ee6e6038-383b-4f21-ac29-b2a1c7d386ab) | ![Отслеживание людей](https://github.com/RizwanMunawar/ultralytics/assets/62513924/93bb4ee2-77a0-4e4e-8eb6-eb8f527f0527) | ![Отслеживание рыб](https://github.com/RizwanMunawar/ultralytics/assets/62513924/a5146d0f-bfa8-4e0a-b7df-3c1446cd8142) | +| Отслеживание транспортных средств | Отслеживание людей | Отслеживание рыб | + +## Ключевые особенности + +Ultralytics YOLO расширяет свои возможности обнаружения объектов для обеспечения надежного и универсального отслеживания объектов: + +- **Отслеживание в реальном времени:** Безпрерывное отслеживание объектов в видео с высокой частотой кадров. +- **Поддержка множества трекеров:** Выбор из разнообразия установленных алгоритмов отслеживания. +- **Настраиваемые конфигурации трекеров:** Настройка алгоритма отслеживания для конкретных требований путем регулировки различных параметров. + +## Доступные трекеры + +Ultralytics YOLO поддерживает следующие алгоритмы отслеживания. Их можно включить, передав соответствующий YAML файл конфигурации, например `tracker=tracker_type.yaml`: + +* [BoT-SORT](https://github.com/NirAharon/BoT-SORT) - Используйте `botsort.yaml`, чтобы активировать этот трекер. +* [ByteTrack](https://github.com/ifzhang/ByteTrack) - Используйте `bytetrack.yaml`, чтобы активировать этот трекер. + +Трекер по умолчанию - BoT-SORT. + +## Отслеживание + +Для запуска трекера на видеопотоках используйте обученные модели Detect, Segment или Pose, такие как YOLOv8n, YOLOv8n-seg и YOLOv8n-pose. + +!!! пример "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Загрузите официальную или пользовательскую модель + model = YOLO('yolov8n.pt') # Загрузить официальную модель Detect + model = YOLO('yolov8n-seg.pt') # Загрузить официальную модель Segment + model = YOLO('yolov8n-pose.pt') # Загрузить официальную модель Pose + model = YOLO('path/to/best.pt') # Загрузить пользовательскую обученную модель + + # Выполнить отслеживание с помощью модели + results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True) # Отслеживание с трекером по умолчанию + results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml") # Отслеживание с трекером ByteTrack + ``` + + === "CLI" + + ```bash + # Выполнить отслеживание с различными моделями используя командный интерфейс + yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" # Официальная модель Detect + yolo track model=yolov8n-seg.pt source="https://youtu.be/LNwODJXcvt4" # Официальная модель Segment + yolo track model=yolov8n-pose.pt source="https://youtu.be/LNwODJXcvt4" # Официальная модель Pose + yolo track model=path/to/best.pt source="https://youtu.be/LNwODJXcvt4" # Пользовательская обученная модель + + # Отслеживание с использованием трекера ByteTrack + yolo track model=path/to/best.pt tracker="bytetrack.yaml" + ``` + +Как видно из вышеуказанного использования, отслеживание доступно для всех моделей Detect, Segment и Pose, работающих с видео или потоковыми источниками. + +## Конфигурация + +### Аргументы для отслеживания + +Конфигурация отслеживания имеет общие свойства с режимом Predict, такие как `conf`, `iou` и `show`. Для дальнейшей настройки обратитесь к странице модели [Predict](https://docs.ultralytics.com/modes/predict/). + +!!! пример "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Настройте параметры отслеживания и запустите трекер + model = YOLO('yolov8n.pt') + results = model.track(source="https://youtu.be/LNwODJXcvt4", conf=0.3, iou=0.5, show=True) + ``` + + === "CLI" + + ```bash + # Настройте параметры отслеживания и запустите трекер, используя командный интерфейс + yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" conf=0.3, iou=0.5 show + ``` + +### Выбор трекера + +Ultralytics также позволяет использовать измененный файл конфигурации трекера. Для этого просто сделайте копию файла конфигурации трекера (например, `custom_tracker.yaml`) из [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers) и измените любые настройки (кроме `tracker_type`) в соответствии с вашими потребностями. + +!!! пример "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Загрузите модель и запустите трекер с пользовательским файлом конфигурации + model = YOLO('yolov8n.pt') + results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker='custom_tracker.yaml') + ``` + + === "CLI" + + ```bash + # Загрузите модель и запустите трекер с пользовательским файлом конфигурации, используя командный интерфейс + yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" tracker='custom_tracker.yaml' + ``` + +Для полного списка аргументов отслеживания обратитесь к странице [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers). + +## Примеры на Python + +### Цикл сохранения следов + +Вот пример скрипта Python, использующий OpenCV (`cv2`) и YOLOv8 для выполнения отслеживания объектов на кадрах видео. В этом сценарии предполагается, что вы уже установили необходимые пакеты (`opencv-python` и `ultralytics`). Аргумент `persist=True` указывает трекеру, что текущее изображение или кадр является следующим в последовательности и ожидает, что следы с предыдущего изображения будут присутствовать в текущем изображении. + +!!! пример "Цикл с потоковым отслеживанием for-loop" + + ```python + import cv2 + from ultralytics import YOLO + + # Загрузите модель YOLOv8 + model = YOLO('yolov8n.pt') + + # Откройте видеофайл + video_path = "path/to/video.mp4" + cap = cv2.VideoCapture(video_path) + + # Цикл по кадрам видео + while cap.isOpened(): + # Чтение кадра из видео + success, frame = cap.read() + + if success: + # Выполните отслеживание YOLOv8 для кадра, сохраняя следы между кадрами + results = model.track(frame, persist=True) + + # Визуализируйте результаты на кадре + annotated_frame = results[0].plot() + + # Покажите аннотированный кадр + cv2.imshow("Отслеживание YOLOv8", annotated_frame) + + # Прервать цикл, если нажата клавиша 'q' + if cv2.waitKey(1) & 0xFF == ord("q"): + break + else: + # Прервать цикл, если достигнут конец видео + break + + # Освободите объект захвата видео и закройте окно отображения + cap.release() + cv2.destroyAllWindows() + ``` + +Обратите внимание на изменение с `model(frame)` на `model.track(frame)`, которое позволяет включить отслеживание объектов вместо простого обнаружения. Этот измененный скрипт будет выполнять трекер на каждом кадре видео, визуализировать результаты и отображать их в окне. Цикл можно завершить нажатием 'q'. + +## Содействие в новых трекерах + +Вы являетесь профессионалом в множественном отслеживании объектов и успешно реализовали или адаптировали алгоритм отслеживания с Ultralytics YOLO? Мы приглашаем вас внести свой вклад в наш раздел Trackers на [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers)! Ваши реальные приложения и решения могут быть бесценными для пользователей, работающих над задачами отслеживания. + +Внося свой вклад в этот раздел, вы помогаете расширить спектр доступных решений для отслеживания в рамках фреймворка Ultralytics YOLO, добавляя еще один уровень функциональности и полезности для сообщества. + +Чтобы начать свой вклад, пожалуйста, ознакомьтесь с нашим [Руководством для участников](https://docs.ultralytics.com/help/contributing) для получения полной инструкции по отправке Pull Request (PR) 🛠️. Мы в предвкушении увидеть, что вы принесете на стол! + +Вместе давайте улучшим возможности отслеживания экосистемы Ultralytics YOLO 🙏! diff --git a/docs/ru/modes/train.md b/docs/ru/modes/train.md new file mode 100644 index 00000000..42309c4d --- /dev/null +++ b/docs/ru/modes/train.md @@ -0,0 +1,206 @@ +--- +comments: true +description: Пошаговое руководство по обучению моделей YOLOv8 с использованием Ultralytics YOLO, включая примеры обучения на одном и нескольких GPU +keywords: Ultralytics, YOLOv8, YOLO, обнаружение объектов, режим обучения, настраиваемый набор данных, обучение на GPU, много-GPU, гиперпараметры, примеры CLI, примеры Python +--- + +# Обучение моделей с помощью Ultralytics YOLO + +Экосистема и интеграции Ultralytics YOLO + +## Введение + +Обучение глубокой обучающей модели включает в себя подачу данных и настройку её параметров, так чтобы она могла делать точные прогнозы. Режим обучения в Ultralytics YOLOv8 предназначен для эффективного и результативного обучения моделей обнаружения объектов с полным использованием возможностей современной аппаратуры. Это руководство нацелено на описание всех деталей, необходимых для начала обучения ваших моделей с использованием богатого набора функций YOLOv8. + +

+
+ +
+ Смотреть: Как обучить модель YOLOv8 на вашем настраиваемом наборе данных в Google Colab. +

+ +## Почему стоит выбрать Ultralytics YOLO для обучения? + +Вот несколько убедительных причин использовать режим Train YOLOv8: + +- **Эффективность:** Используйте максимум возможностей вашего оборудования, будь то настройка с одним GPU или распределение нагрузки на несколько GPU. +- **Универсальность:** Обучайте на настраиваемых наборах данных, помимо уже доступных, таких как COCO, VOC и ImageNet. +- **Дружелюбный интерфейс:** Простой, но мощный интерфейс командной строки (CLI) и Python для прямолинейного опыта обучения. +- **Гибкость гиперпараметров:** Широкий спектр настраиваемых гиперпараметров для тонкой настройки производительности модели. + +### Ключевые особенности режима Train + +Вот некоторые заметные особенности режима Train YOLOv8: + +- **Автоматическая загрузка набора данных:** Стандартные наборы данных, такие как COCO, VOC и ImageNet, загружаются автоматически при первом использовании. +- **Поддержка многих GPU:** Масштабируйте усилия по обучению без проблем на нескольких GPU, чтобы ускорить процесс. +- **Настройка гиперпараметров:** Возможность изменения гиперпараметров через файлы конфигурации YAML или аргументы CLI. +- **Визуализация и мониторинг:** Отслеживание метрик обучения в реальном времени и визуализация процесса обучения для лучшего понимания. + +!!! tip "Совет" + + * Наборы данных YOLOv8, такие как COCO, VOC, ImageNet и многие другие, автоматически загружаются при первом использовании, например, `yolo train data=coco.yaml` + +## Примеры использования + +Обучение YOLOv8n на наборе данных COCO128 в течение 100 эпох с размером изображения 640. Устройство для обучения может быть указано с помощью аргумента `device`. Если аргумент не передан, будет использоваться GPU `device=0`, если доступен, в противном случае будет использоваться `device=cpu`. Смотрите раздел Аргументы ниже для полного списка аргументов обучения. + +!!! example "Пример обучения на одном GPU и CPU" + + Устройство определяется автоматически. Если доступен GPU, то он будет использован, иначе обучение начнется на CPU. + + === "Python" + + ```python + from ultralytics import YOLO + + # Загрузить модель + model = YOLO('yolov8n.yaml') # создать новую модель из YAML + model = YOLO('yolov8n.pt') # загрузить предобученную модель (рекомендуется для обучения) + model = YOLO('yolov8n.yaml').load('yolov8n.pt') # создать из YAML и перенести веса + + # Обучить модель + results = model.train(data='coco128.yaml', epochs=100, imgsz=640) + ``` + + === "CLI" + + ```bash + # Создать новую модель из YAML и начать обучение с нуля + yolo detect train data=coco128.yaml model=yolov8n.yaml epochs=100 imgsz=640 + + # Начать обучение с предобученной модели *.pt + yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 + + # Создать новую модель из YAML, перенести предобученные веса и начать обучение + yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640 + ``` + +### Обучение на нескольких GPU + +Обучение на нескольких GPU позволяет более эффективно использовать доступные аппаратные ресурсы, распределяя нагрузку по обучению на несколько GPU. Эта функция доступна как через Python API, так и через командный интерфейс. Чтобы включить обучение на нескольких GPU, укажите идентификаторы устройств GPU, которые вы хотите использовать. + +!!! example "Пример обучения на нескольких GPU" + + Чтобы обучить с использованием 2 GPU, устройств CUDA 0 и 1 используйте следующие команды. Расширьте до дополнительных GPU по мере необходимости. + + === "Python" + + ```python + from ultralytics import YOLO + + # Загрузить модель + model = YOLO('yolov8n.pt') # загрузить предобученную модель (рекомендуется для обучения) + + # Обучить модель с использованием 2 GPU + results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device=[0, 1]) + ``` + + === "CLI" + + ```bash + # Начать обучение с предобученной модели *.pt используя GPU 0 и 1 + yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=0,1 + ``` + +### Обучение на Apple M1 и M2 с использованием MPS + +С интеграцией поддержки чипов Apple M1 и M2 в модели Ultralytics YOLO теперь можно обучать ваши модели на устройствах, использующих мощную платформу Metal Performance Shaders (MPS). MPS предлагает производительный способ выполнения вычислений и задач обработки изображений на пользовательских кремниевых чипах Apple. + +Чтобы запустить обучение на чипах Apple M1 и M2, вы должны указать 'mps' в качестве вашего устройства при запуске процесса обучения. Ниже приведены примеры использования Python и командной строки: + +!!! example "Пример обучения с MPS" + + === "Python" + + ```python + from ultralytics import YOLO + + # Загрузить модель + model = YOLO('yolov8n.pt') # загрузить предобученную модель (рекомендуется для обучения) + + # Обучить модель с использованием MPS + results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device='mps') + ``` + + === "CLI" + + ```bash + # Начать обучение с предобученной модели *.pt используя MPS + yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=mps + ``` + +Используя вычислительные возможности чипов M1/M2, это позволяет более эффективно обрабатывать задачи обучения. Для более подробного руководства и расширенных параметров конфигурации, пожалуйста, обратитесь к [документации PyTorch MPS](https://pytorch.org/docs/stable/notes/mps.html). + +## Логирование + +В процессе обучения модели YOLOv8 вы можете найти ценным отслеживание производительности модели со временем. Здесь на помощь приходит логирование. YOLO от Ultralytics поддерживает три типа логгеров - Comet, ClearML и TensorBoard. + +Чтобы использовать логгер, выберите его из выпадающего меню в приведенном выше примере кода и запустите его. Выбранный логгер будет установлен и инициализирован. + +### Comet + +[Comet](https://www.comet.ml/site/) - это платформа, которая позволяет ученым и разработчикам отслеживать, сравнивать, объяснять и оптимизировать эксперименты и модели. Она предоставляет такие функции, как метрики в реальном времени, сравнение кода и отслеживание гиперпараметров. + +Чтобы использовать Comet: + +!!! example "" + + === "Python" + ```python + # pip install comet_ml + import comet_ml + + comet_ml.init() + ``` + +Не забудьте войти в свою учетную запись Comet на их сайте и получить свой API-ключ. Вам нужно будет добавить его в переменные среды или в свой скрипт, чтобы вести журнал своих экспериментов. + +### ClearML + +[ClearML](https://www.clear.ml/) - это открытая платформа, которая автоматизирует отслеживание экспериментов и помогает в эффективном обмене ресурсами. Она предназначена для помощи командам в управлении, выполнении и воспроизведении их работы в области ML более эффективно. + +Чтобы использовать ClearML: + +!!! example "" + + === "Python" + ```python + # pip install clearml + import clearml + + clearml.browser_login() + ``` + +После запуска этого скрипта вам нужно будет войти в вашу учетную запись ClearML в браузере и аутентифицировать вашу сессию. + +### TensorBoard + +[TensorBoard](https://www.tensorflow.org/tensorboard) - это инструмент визуализации для TensorFlow. Он позволяет вам визуализировать граф TensorFlow, выводить количественные метрики о выполнении вашего графа и показывать дополнительные данные, такие как изображения, проходящие через него. + +Чтобы использовать TensorBoard в [Google Colab](https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb): + +!!! example "" + + === "CLI" + ```bash + load_ext tensorboard + tensorboard --logdir ultralytics/runs # заменить на директорию 'runs' + ``` + +Чтобы использовать TensorBoard локально, запустите приведенную ниже команду и просмотрите результаты по адресу http://localhost:6006/. + +!!! example "" + + === "CLI" + ```bash + tensorboard --logdir ultralytics/runs # заменить на директорию 'runs' + ``` + +Это загрузит TensorBoard и направит его к каталогу, где сохраняются ваши журналы обучения. + +После настройки вашего логгера вы можете продолжать обучение модели. Все метрики обучения будут автоматически записаны на выбранной вами платформе, и вы сможете получить доступ к этим журналам, чтобы отслеживать производительность вашей модели со временем, сравнивать различные модели и определять области для улучшения. diff --git a/docs/ru/modes/val.md b/docs/ru/modes/val.md new file mode 100644 index 00000000..77757a57 --- /dev/null +++ b/docs/ru/modes/val.md @@ -0,0 +1,86 @@ +--- +comments: true +description: Руководство по проверке моделей YOLOv8. Узнайте, как оценить производительность ваших моделей YOLO, используя параметры проверки и метрики с примерами на Python и CLI. +keywords: Ultralytics, YOLO Документация, YOLOv8, проверка, оценка модели, гиперпараметры, точность, метрики, Python, CLI +--- + +# Валидация моделей с Ultralytics YOLO + +Ultralytics YOLO экосистема и интеграции + +## Введение + +Валидация является критически важным этапом в процессе машинного обучения, позволяющим оценить качество ваших обученных моделей. Режим Val в Ultralytics YOLOv8 обеспечивает набор инструментов и метрик для оценки производительности ваших моделей по обнаружению объектов. Это руководство служит полным ресурсом для понимания того, как эффективно использовать режим Val, чтобы обеспечить точность и надежность ваших моделей. + +## Зачем проверять с Ultralytics YOLO? + +Вот почему использование режима Val YOLOv8 выгодно: + +- **Точность:** Получите точные метрики, такие как mAP50, mAP75 и mAP50-95, для всесторонней оценки вашей модели. +- **Удобство:** Используйте встроенные функции, которые запоминают настройки обучения, упрощая процесс валидации. +- **Гибкость:** Проверяйте вашу модель с использованием тех же или разных наборов данных и размеров изображений. +- **Настройка гиперпараметров:** Используйте метрики проверки для дополнительной настройки вашей модели для лучшей производительности. + +### Основные функции режима Val + +Вот некоторые заметные функции, предлагаемые режимом Val YOLOv8: + +- **Автоматизированные настройки:** Модели запоминают свои конфигурации обучения для простой валидации. +- **Поддержка множества метрик:** Оцените вашу модель, основываясь на ряде метрик точности. +- **CLI и Python API:** Выберите интерфейс командной строки или Python API в зависимости от вашего предпочтения для проверки. +- **Совместимость данных:** Бесперебойно работает с наборами данных, используемыми во время фазы обучения, а также с пользовательскими наборами данных. + +!!! tip "Совет" + + * Модели YOLOv8 автоматически запоминают свои настройки обучения, так что вы можете легко проверить модель с тем же размером изображения и на оригинальном наборе данных, просто используя `yolo val model=yolov8n.pt` или `model('yolov8n.pt').val()` + +## Примеры использования + +Проверьте точность обученной модели YOLOv8n на наборе данных COCO128. Аргументы передавать не требуется, так как `модель` сохраняет `данные` и аргументы в качестве атрибутов модели. См. раздел Аргументы ниже для полного списка аргументов экспорта. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Загрузка модели + model = YOLO('yolov8n.pt') # загрузить официальную модель + model = YOLO('path/to/best.pt') # загрузить пользовательскую модель + + # Проверка модели + metrics = model.val() # аргументы не нужны, набор данных и настройки запомнены + metrics.box.map # map50-95 + metrics.box.map50 # map50 + metrics.box.map75 # map75 + metrics.box.maps # список содержит map50-95 каждой категории + ``` + === "CLI" + + ```bash + yolo detect val model=yolov8n.pt # проверить официальную модель + yolo detect val model=path/to/best.pt # проверить пользовательскую модель + ``` + +## Аргументы + +Настройки проверки для моделей YOLO относятся к различным гиперпараметрам и конфигурациям, используемым для оценки производительности модели на наборе данных для проверки. Эти настройки могут влиять на производительность, скорость и точность модели. Некоторые общие параметры проверки YOLO включают размер пакета, частоту проведения проверки во время обучения и метрики, используемые для оценки производительности модели. Другие факторы, которые могут влиять на процесс проверки, включают размер и состав набора данных для проверки и конкретную задачу, для которой используется модель. Важно тщательно настроить и провести эксперименты с этими параметрами, чтобы убедиться, что модель хорошо работает на наборе данных для проверки и для обнаружения и предотвращения переобучения. + +| Ключ | Значение | Описание | +|---------------|----------|-----------------------------------------------------------------------------------------| +| `data` | `None` | путь к файлу данных, например, coco128.yaml | +| `imgsz` | `640` | размер входных изображений как целое число | +| `batch` | `16` | количество изображений в пакете (-1 для AutoBatch) | +| `save_json` | `False` | сохранить результаты в файл JSON | +| `save_hybrid` | `False` | сохранить гибридную версию меток (метки + дополнительные предсказания) | +| `conf` | `0.001` | порог уверенности объекта для обнаружения | +| `iou` | `0.6` | порог пересечения по объединению (IoU) для NMS (нечеткое сравнение) | +| `max_det` | `300` | максимальное количество обнаружений на изображение | +| `half` | `True` | использовать полупрецизионность (FP16) | +| `device` | `None` | устройство для выполнения, например, cuda device=0/1/2/3 или device=cpu | +| `dnn` | `False` | использовать OpenCV DNN для ONNX инференции | +| `plots` | `False` | показывать графики во время обучения | +| `rect` | `False` | прямоугольная валидация с коллекцией каждого пакета для минимальной паддинга | +| `split` | `val` | раздел набора данных для использования в валидации, например, 'val', 'test' или 'train' | +| diff --git a/docs/ru/quickstart.md b/docs/ru/quickstart.md new file mode 100644 index 00000000..5c9d502d --- /dev/null +++ b/docs/ru/quickstart.md @@ -0,0 +1,187 @@ +--- +comments: true +description: Изучение различных методов установки Ultralytics с использованием pip, conda, git и Docker. Освоение работы с Ultralytics через интерфейс командной строки или в рамках ваших проектов на Python. +keywords: установка Ultralytics, установка pip Ultralytics, установка Docker Ultralytics, интерфейс командной строки Ultralytics, Python интерфейс Ultralytics +--- + +## Установка Ultralytics + +Ultralytics предлагает различные методы установки, включая pip, conda и Docker. Установите YOLOv8 через пакет `ultralytics` pip для последнего стабильного выпуска или путем клонирования [репозитория Ultralytics на GitHub](https://github.com/ultralytics/ultralytics) для получения самой актуальной версии. Docker можно использовать для выполнения пакета в изолированном контейнере, избегая локальной установки. + +!!! example "Установка" + + === "Установка через Pip (рекомендуется)" + Установите пакет `ultralytics` с помощью pip или обновите существующую установку, запустив `pip install -U ultralytics`. Посетите индекс пакетов Python (PyPI) для получения дополнительной информации о пакете `ultralytics`: [https://pypi.org/project/ultralytics/](https://pypi.org/project/ultralytics/). + + [![Версия PyPI](https://badge.fury.io/py/ultralytics.svg)](https://badge.fury.io/py/ultralytics) [![Загрузки](https://static.pepy.tech/badge/ultralytics)](https://pepy.tech/project/ultralytics) + + ```bash + # Установка пакета ultralytics из PyPI + pip install ultralytics + ``` + + Вы также можете установить пакет `ultralytics` напрямую из [репозитория на GitHub](https://github.com/ultralytics/ultralytics). Это может быть полезно, если вы хотите получить последнюю версию для разработки. Убедитесь, что в вашей системе установлен инструмент командной строки Git. Команда `@main` устанавливает ветку `main`, которую можно изменить на другую, к примеру, `@my-branch`, или удалить полностью, чтобы по умолчанию использовалась ветка `main`. + + ```bash + # Установка пакета ultralytics из GitHub + pip install git+https://github.com/ultralytics/ultralytics.git@main + ``` + + === "Установка через Conda" + Conda - это альтернативный менеджер пакетов для pip, который также может быть использован для установки. Посетите Anaconda для получения дополнительной информации: [https://anaconda.org/conda-forge/ultralytics](https://anaconda.org/conda-forge/ultralytics). Репозиторий для обновления conda пакета Ultralytics находится здесь: [https://github.com/conda-forge/ultralytics-feedstock/](https://github.com/conda-forge/ultralytics-feedstock/). + + [![Conda Recipe](https://img.shields.io/badge/recipe-ultralytics-green.svg)](https://anaconda.org/conda-forge/ultralytics) [![Conda Загрузки](https://img.shields.io/conda/dn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics) [![Conda Версия](https://img.shields.io/conda/vn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics) [![Conda Платформы](https://img.shields.io/conda/pn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics) + + ```bash + # Установка пакета ultralytics с помощью conda + conda install -c conda-forge ultralytics + ``` + + !!! note + + Если вы устанавливаете пакет в среде CUDA, лучшей практикой будет установка `ultralytics`, `pytorch` и `pytorch-cuda` одной командой, чтобы менеджер пакетов conda мог разрешить любые конфликты или установить `pytorch-cuda` последним, чтобы при необходимости он мог заменить пакет `pytorch`, предназначенный для ЦП. + + ```bash + # Установка всех пакетов вместе с помощью conda + conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics + ``` + + ### Образ Conda для Docker + + Образы Conda Ultralytics также доступны на [DockerHub](https://hub.docker.com/r/ultralytics/ultralytics). Эти образы основаны на [Miniconda3](https://docs.conda.io/projects/miniconda/en/latest/) и являются простым способом начать использовать `ultralytics` в среде Conda. + + ```bash + # Установка имени образа в переменную + t=ultralytics/ultralytics:latest-conda + + # Скачивание последнего образа ultralytics с Docker Hub + sudo docker pull $t + + # Запуск образа ultralytics в контейнере с поддержкой GPU + sudo docker run -it --ipc=host --gpus all $t # все GPU + sudo docker run -it --ipc=host --gpus '"device=2,3"' $t # выбор GPU + ``` + + === "Клонирование Git" + Клонируйте репозиторий `ultralytics`, если вы заинтересованы в участии в разработке или хотите экспериментировать с последним исходным кодом. После клонирования перейдите в каталог и установите пакет в режиме редактирования `-e` с помощью pip. + + ```bash + # Клонирование репозитория ultralytics + git clone https://github.com/ultralytics/ultralytics + + # Переход в клонированный каталог + cd ultralytics + + # Установка пакета в режиме редактирования для разработки + pip install -e . + ``` + +Смотрите файл [requirements.txt](https://github.com/ultralytics/ultralytics/blob/main/requirements.txt) `ultralytics` для списка зависимостей. Обратите внимание, что все приведенные выше примеры устанавливают все необходимые зависимости. + +!!! tip "Совет" + + Требования PyTorch зависят от операционной системы и требований CUDA, поэтому рекомендуется сначала установить PyTorch, следуя инструкциям на [https://pytorch.org/get-started/locally](https://pytorch.org/get-started/locally). + + + Инструкции по установке PyTorch + + +## Использование Ultralytics с CLI + +Интерфейс командной строки (CLI) Ultralytics позволяет выполнять простые команды одной строкой без необходимости настройки Python среды. CLI не требует настройки или кода на Python. Все задачи можно легко выполнить из терминала с помощью команды `yolo`. Прочтите [Руководство по CLI](../usage/cli.md), чтобы узнать больше о использовании YOLOv8 из командной строки. + +!!! example + + === "Cинтаксис" + + Команды Ultralytics `yolo` используют следующий синтаксис: + ```bash + yolo ЗАДАЧА РЕЖИМ АРГУМЕНТЫ + + Где ЗАДАЧА (необязательно) одна из [detect, segment, classify] + РЕЖИМ (обязательно) один из [train, val, predict, export, track] + АРГУМЕНТЫ (необязательно) любое количество пар 'arg=value', которые переопределяют настройки по умолчанию. + ``` + Смотрите все АРГУМЕНТЫ в полном [Руководстве по конфигурации](../usage/cfg.md) или с помощью `yolo cfg` + + === "Train" + + Обучение модели для детекции на 10 эпохах с начальной скоростью обучения 0.01 + ```bash + yolo train data=coco128.yaml model=yolov8n.pt epochs=10 lr0=0.01 + ``` + + === "Predict" + + Прогнозирование видео с YouTube с использованием предварительно обученной модели сегментации при размере изображения 320: + ```bash + yolo predict model=yolov8n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320 + ``` + + === "Val" + + Валидация предварительно обученной модели детекции с размером партии 1 и размером изображения 640: + ```bash + yolo val model=yolov8n.pt data=coco128.yaml batch=1 imgsz=640 + ``` + + === "Export" + + Экспорт модели классификации YOLOv8n в формат ONNX с размером изображения 224 на 128 (TASK не требуется) + ```bash + yolo export model=yolov8n-cls.pt format=onnx imgsz=224,128 + ``` + + === "Special" + + Выполнение специальных команд для просмотра версии, настроек, запуска проверок и другого: + ```bash + yolo help + yolo checks + yolo version + yolo settings + yolo copy-cfg + yolo cfg + ``` + +!!! warning "Предупреждение" + + Аргументы должны передаваться в виде пар `arg=val`, разделенных знаком равенства `=`, и разделены пробелами ` ` между парами. Не используйте префиксы аргументов `--` или запятые `,` между аргументами. + + - `yolo predict model=yolov8n.pt imgsz=640 conf=0.25`   ✅ + - `yolo predict model yolov8n.pt imgsz 640 conf 0.25`   ❌ + - `yolo predict --model yolov8n.pt --imgsz 640 --conf 0.25`   ❌ + +[Руководство по CLI](../usage/cli.md){ .md-button .md-button--primary} + +## Использование Ultralytics с Python + +Python интерфейс YOLOv8 позволяет легко интегрировать его в ваши Python проекты, упрощая загрузку, выполнение и обработку результатов работы модели. Интерфейс Python разработан с акцентом на простоту и удобство использования, позволяя пользователям быстро внедрять функции обнаружения объектов, сегментации и классификации в их проектах. Это делает интерфейс Python YOLOv8 незаменимым инструментом для тех, кто хочет включить эти функции в свои Python проекты. + +Например, пользователи могут загрузить модель, обучить ее, оценить ее производительность на валидационном наборе, и даже экспортировать ее в формат ONNX всего за несколько строк кода. Подробнее о том, как использовать YOLOv8 в ваших Python проектах, читайте в [Руководстве по Python](../usage/python.md). + +!!! example + + ```python + from ultralytics import YOLO + + # Создание новой YOLO модели с нуля + model = YOLO('yolov8n.yaml') + + # Загрузка предварительно обученной YOLO модели (рекомендуется для обучения) + model = YOLO('yolov8n.pt') + + # Обучение модели с использованием набора данных 'coco128.yaml' на 3 эпохи + results = model.train(data='coco128.yaml', epochs=3) + + # Оценка производительности модели на валидационном наборе + results = model.val() + + # Выполнение обнаружения объектов на изображении с помощью модели + results = model('https://ultralytics.com/images/bus.jpg') + + # Экспорт модели в формат ONNX + success = model.export(format='onnx') + ``` + +[Руководство по Python](../usage/python.md){.md-button .md-button--primary} diff --git a/docs/ru/tasks/classify.md b/docs/ru/tasks/classify.md new file mode 100644 index 00000000..0156c557 --- /dev/null +++ b/docs/ru/tasks/classify.md @@ -0,0 +1,172 @@ +--- +comments: true +description: Узнайте о моделях классификации изображений YOLOv8 Classify. Получите подробную информацию о списке предварительно обученных моделей и как провести Обучение, Валидацию, Предсказание и Экспорт моделей. +keywords: Ultralytics, YOLOv8, классификация изображений, предварительно обученные модели, YOLOv8n-cls, обучение, валидация, предсказание, экспорт модели +--- + +# Классификация изображений + +Примеры классификации изображений + +Классификация изображений - это самая простая из трех задач и заключается в классификации всего изображения по одному из предварительно определенных классов. + +Выход классификатора изображений - это один классовый ярлык и уровень доверия. Классификация изображений полезна, когда вам нужно знать только к какому классу относится изображение, и не нужно знать, где находятся объекты данного класса или какова их точная форма. + +!!! tip "Совет" + + Модели YOLOv8 Classify используют суффикс `-cls`, например `yolov8n-cls.pt`, и предварительно обучены на [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml). + +## [Модели](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8) + +Здесь показаны предварительно обученные модели классификации YOLOv8. Модели для обнаружения, сегментации и позы обучаются на наборе данных [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), в то время как модели классификации обучаются на наборе данных [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml). + +[Модели](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) автоматически загружаются из последнего релиза Ultralytics [release](https://github.com/ultralytics/assets/releases) при первом использовании. + +| Модель | Размер
(пиксели) | Точность
top1 | Точность
top5 | Скорость
CPU ONNX
(мс) | Скорость
A100 TensorRT
(мс) | Параметры
(М) | FLOPs
(Б) на 640 | +|----------------------------------------------------------------------------------------------|--------------------------|-----------------------|-----------------------|-----------------------------------|----------------------------------------|-----------------------|--------------------------| +| [YOLOv8n-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-cls.pt) | 224 | 66.6 | 87.0 | 12.9 | 0.31 | 2.7 | 4.3 | +| [YOLOv8s-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-cls.pt) | 224 | 72.3 | 91.1 | 23.4 | 0.35 | 6.4 | 13.5 | +| [YOLOv8m-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-cls.pt) | 224 | 76.4 | 93.2 | 85.4 | 0.62 | 17.0 | 42.7 | +| [YOLOv8l-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-cls.pt) | 224 | 78.0 | 94.1 | 163.0 | 0.87 | 37.5 | 99.7 | +| [YOLOv8x-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-cls.pt) | 224 | 78.4 | 94.3 | 232.0 | 1.01 | 57.4 | 154.8 | + +- Значения **точность** указывают на точность модели на валидационном наборе данных [ImageNet](https://www.image-net.org/). +
Повторить результаты можно с помощью `yolo val classify data=path/to/ImageNet device=0`. +- **Скорость** усреднена по изображениям для валидации ImageNet, используя инстанс [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/). +
Повторить результаты можно с помощью `yolo val classify data=path/to/ImageNet batch=1 device=0|cpu`. + +## Обучение + +Обучите модель YOLOv8n-cls на наборе данных MNIST160 на протяжении 100 эпох с размером изображения 64. Полный список доступных аргументов приведен на странице [Конфигурация](../../usage/cfg.md). + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Загрузите модель + model = YOLO('yolov8n-cls.yaml') # создайте новую модель из YAML + model = YOLO('yolov8n-cls.pt') # загрузите предварительно обученную модель (рекомендуется для обучения) + model = YOLO('yolov8n-cls.yaml').load('yolov8n-cls.pt') # создайте из YAML и перенесите веса + + # Обучите модель + результаты = model.train(data='mnist160', epochs=100, imgsz=64) + ``` + + === "CLI" + + ```bash + # Создайте новую модель из YAML и начните обучение с нуля + yolo classify train data=mnist160 model=yolov8n-cls.yaml epochs=100 imgsz=64 + + # Начните обучение с предварительно обученной *.pt модели + yolo classify train data=mnist160 model=yolov8n-cls.pt epochs=100 imgsz=64 + + # Создайте новую модель из YAML, перенесите предварительно обученные веса и начните обучение + yolo classify train data=mnist160 model=yolov8n-cls.yaml pretrained=yolov8n-cls.pt epochs=100 imgsz=64 + ``` + +### Формат набора данных + +Формат набора данных для классификации YOLO можно подробно изучить в [Руководстве по наборам данных](../../datasets/classify/index.md). + +## Валидация + +Проверьте точность обученной модели YOLOv8n-cls на наборе данных MNIST160. Не нужно передавать какие-либо аргументы, так как `model` сохраняет свои `data` и аргументы в качестве атрибутов модели. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Загрузите модель + model = YOLO('yolov8n-cls.pt') # загрузите официальную модель + model = YOLO('path/to/best.pt') # загрузите собственную модель + + # Проведите валидацию модели + метрики = model.val() # аргументы не нужны, набор данных и настройки запомнены + метрики.top1 # точность top1 + метрики.top5 # точность top5 + ``` + === "CLI" + + ```bash + yolo classify val model=yolov8n-cls.pt # валидация официальной модели + yolo classify val model=path/to/best.pt # валидация собственной модели + ``` + +## Предсказание + +Используйте обученную модель YOLOv8n-cls для выполнения предсказаний на изображениях. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Загрузите модель + model = YOLO('yolov8n-cls.pt') # загрузите официальную модель + model = YOLO('path/to/best.pt') # загрузите собственную модель + + # Сделайте предсказание с помощью модели + результаты = model('https://ultralytics.com/images/bus.jpg') # сделайте предсказание на изображении + ``` + === "CLI" + + ```bash + yolo classify predict model=yolov8n-cls.pt source='https://ultralytics.com/images/bus.jpg' # предсказание с официальной моделью + yolo classify predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # предсказание с собственной моделью + ``` + +Подробная информация о режиме `predict` приведена на странице [Предсказание](https://docs.ultralytics.com/modes/predict/). + +## Экспорт + +Экспортируйте модель YOLOv8n-cls в другой формат, например, ONNX, CoreML и т. д. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Загрузите модель + model = YOLO('yolov8n-cls.pt') # загрузите официальную модель + model = YOLO('path/to/best.pt') # загрузите собственную обученную модель + + # Экспортируйте модель + model.export(format='onnx') + ``` + === "CLI" + + ```bash + yolo export model=yolov8n-cls.pt format=onnx # экспорт официальной модели + yolo export model=path/to/best.pt format=onnx # экспорт собственной обученной модели + ``` + +Доступные форматы экспорта YOLOv8-cls представлены в таблице ниже. Вы можете выполнять предсказания или валидацию прямо на экспортированных моделях, например, `yolo predict model=yolov8n-cls.onnx`. Примеры использования показаны для вашей модели после завершения экспорта. + +| Формат | Аргумент `format` | Модель | Метаданные | Аргументы | +|--------------------------------------------------------------------|-------------------|-------------------------------|------------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n-cls.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-cls.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-cls.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-cls_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-cls.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-cls.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-cls_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-cls.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-cls.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-cls_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-cls_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-cls_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-cls_ncnn_model/` | ✅ | `imgsz`, `half` | + +Подробная информация об экспорте приведена на странице [Экспорт](https://docs.ultralytics.com/modes/export/). diff --git a/docs/ru/tasks/detect.md b/docs/ru/tasks/detect.md new file mode 100644 index 00000000..a2372aeb --- /dev/null +++ b/docs/ru/tasks/detect.md @@ -0,0 +1,184 @@ +--- +comments: true +description: Официальная документация YOLOv8 от Ultralytics. Узнайте, как проводить обучение, проверку, предсказание и экспорт моделей в различных форматах. Включая подробные статистические данные о производительности. +keywords: YOLOv8, Ultralytics, обнаружение объектов, предобученные модели, обучение, валидация, предсказание, экспорт моделей, COCO, ImageNet, PyTorch, ONNX, CoreML +--- + +# Обнаружение объектов + +Примеры обнаружения объектов + +Обнаружение объектов – это задача, которая включает идентификацию местоположения и класса объектов на изображении или видео. + +Результат работы детектора объектов – это набор ограничивающих рамок, которые заключают в себе объекты на изображении, вместе с метками классов и уровнями достоверности для каждой рамки. Обнаружение объектов является хорошим выбором, когда необходимо определить объекты интереса в сцене, но не нужно точно знать, где находится объект или его точную форму. + +

+
+ +
+ Смотрите: Обнаружение объектов с предобученной моделью Ultralytics YOLOv8. +

+ +!!! tip "Совет" + + YOLOv8 Detect модели являются стандартными моделями YOLOv8, то есть `yolov8n.pt`, и предобучены на [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml). + +## [Модели](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8) + +Здесь показаны предобученные модели YOLOv8 Detect. Модели Detect, Segment и Pose предобучены на датасете [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), в то время как модели Classify предобучены на датасете [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml). + +[Модели](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) автоматически загружаются с последнего релиза Ultralytics [release](https://github.com/ultralytics/assets/releases) при первом использовании. + +| Модель | размер
(пиксели) | mAPval
50-95 | Скорость
CPU ONNX
(мс) | Скорость
A100 TensorRT
(мс) | параметры
(М) | FLOPs
(Б) | +|--------------------------------------------------------------------------------------|--------------------------|----------------------|-----------------------------------|----------------------------------------|-----------------------|-------------------| +| [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n.pt) | 640 | 37.3 | 80.4 | 0.99 | 3.2 | 8.7 | +| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s.pt) | 640 | 44.9 | 128.4 | 1.20 | 11.2 | 28.6 | +| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m.pt) | 640 | 50.2 | 234.7 | 1.83 | 25.9 | 78.9 | +| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l.pt) | 640 | 52.9 | 375.2 | 2.39 | 43.7 | 165.2 | +| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x.pt) | 640 | 53.9 | 479.1 | 3.53 | 68.2 | 257.8 | + +- **mAPval** значения для одиночной модели одиночного масштаба на датасете [COCO val2017](http://cocodataset.org). +
Для воспроизведения используйте `yolo val detect data=coco.yaml device=0` +- **Скорость** усреднена по изображениям COCO val на экземпляре [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/). +
Для воспроизведения используйте `yolo val detect data=coco128.yaml batch=1 device=0|cpu` + +## Обучение + +Обучите модель YOLOv8n на датасете COCO128 в течение 100 эпох с размером изображения 640. Полный список доступных аргументов см. на странице [Конфигурация](../../usage/cfg.md). + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Загрузите модель + model = YOLO('yolov8n.yaml') # создать новую модель из YAML + model = YOLO('yolov8n.pt') # загрузить предобученную модель (рекомендуется для обучения) + model = YOLO('yolov8n.yaml').load('yolov8n.pt') # создать из YAML и перенести веса + + # Обучите модель + results = model.train(data='coco128.yaml', epochs=100, imgsz=640) + ``` + === "CLI" + + ```bash + # Создать новую модель из YAML и начать обучение с нуля + yolo detect train data=coco128.yaml model=yolov8n.yaml epochs=100 imgsz=640 + + # Начать обучение с предобученной модели *.pt + yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 + + # Создать новую модель из YAML, перенести в нее предобученные веса и начать обучение + yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640 + ``` + +### Формат датасета + +Формат датасета для обнаружения YOLO можно найти более подробно в [Руководстве по датасетам](../../datasets/detect/index.md). Чтобы конвертировать ваш существующий датасет из других форматов (например, COCO и т.д.) в формат YOLO, пожалуйста, используйте инструмент [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) от Ultralytics. + +## Валидация + +Проверьте точность обученной модели YOLOv8n на датасете COCO128. Необходимо передать аргументы, поскольку `model` сохраняет свои `data` и аргументы обучения как атрибуты модели. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Загрузите модель + model = YOLO('yolov8n.pt') # загрузить официальную модель + model = YOLO('path/to/best.pt') # загрузить собственную модель + + # Проверьте модель + metrics = model.val() # аргументы не нужны, набор данных и настройки запоминаются + metrics.box.map # map50-95 + metrics.box.map50 # map50 + metrics.box.map75 # map75 + metrics.box.maps # список содержит map50-95 для каждой категории + ``` + === "CLI" + + ```bash + yolo detect val model=yolov8n.pt # val официальная модель + yolo detect val model=path/to/best.pt # val собственная модель + ``` + +## Предсказание + +Используйте обученную модель YOLOv8n для выполнения предсказаний на изображениях. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Загрузите модель + model = YOLO('yolov8n.pt') # загрузить официальную модель + model = YOLO('path/to/best.pt') # загрузить собственную модель + + # Сделайте предсказание с помощью модели + results = model('https://ultralytics.com/images/bus.jpg') # сделать предсказание на изображении + ``` + === "CLI" + + ```bash + yolo detect predict model=yolov8n.pt source='https://ultralytics.com/images/bus.jpg' # предсказание с официальной моделью + yolo detect predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # предсказание с собственной моделью + ``` + +Полные детали режима `predict` смотрите на странице [Предсказание](https://docs.ultralytics.com/modes/predict/). + +## Экспорт + +Экспортируйте модель YOLOv8n в другой формат, такой как ONNX, CoreML и др. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Загрузите модель + model = YOLO('yolov8n.pt') # загрузить официальную модель + model = YOLO('path/to/best.pt') # загрузить собственную модель после обучения + + # Экспортируйте модель + model.export(format='onnx') + ``` + === "CLI" + + ```bash + yolo export model=yolov8n.pt format=onnx # экспорт официальной модели + yolo export model=path/to/best.pt format=onnx # экспорт собственной модели после обучения + ``` + +Доступные форматы экспорта YOLOv8 приведены в таблице ниже. Вы можете выполнять предсказания или проверку непосредственно на экспортированных моделях, например `yolo predict model=yolov8n.onnx`. Примеры использования для вашей модели показаны после завершения экспорта. + +| Формат | Аргумент `format` | Модель | Метаданные | Аргументы | +|--------------------------------------------------------------------|-------------------|---------------------------|------------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | ✅ | `imgsz`, `half` | + +Полные детали режима `export` смотрите на странице [Экспорт](https://docs.ultralytics.com/modes/export/). diff --git a/docs/ru/tasks/index.md b/docs/ru/tasks/index.md new file mode 100644 index 00000000..ffced03a --- /dev/null +++ b/docs/ru/tasks/index.md @@ -0,0 +1,55 @@ +--- +comments: true +description: Узнайте о ключевых задачах компьютерного зрения, которые может выполнять YOLOv8, включая обнаружение, сегментацию, классификацию и оценку позы. Поймите, как они могут быть использованы в ваших AI проектах. +keywords: Ultralytics, YOLOv8, Обнаружение, Сегментация, Классификация, Оценка Позы, AI Фреймворк, Задачи Компьютерного Зрения +--- + +# Задачи Ultralytics YOLOv8 + +
+Поддерживаемые задачи Ultralytics YOLO + +YOLOv8 — это AI фреймворк, поддерживающий множество задач компьютерного зрения **задачи**. Фреймворк может быть использован для выполнения [обнаружения](detect.md), [сегментации](segment.md), [классификации](classify.md) и оценки [позы](pose.md). Каждая из этих задач имеет различные цели и области применения. + +!!! note + + 🚧 Наша многоязычная документация в настоящее время находится в стадии разработки, и мы усердно работаем над ее улучшением. Спасибо за ваше терпение! 🙏 + +

+
+ +
+ Смотрите: Изучите задачи Ultralytics YOLO: Обнаружение объектов, Сегментация, Отслеживание и Оценка позы. +

+ +## [Обнаружение](detect.md) + +Обнаружение — это основная задача, поддерживаемая YOLOv8. Она заключается в обнаружении объектов на изображении или кадре видео и рисовании вокруг них ограничивающих рамок. Обнаруженные объекты классифицируются на разные категории на основе их характеристик. YOLOv8 может обнаруживать несколько объектов на одном изображении или видеокадре с высокой точностью и скоростью. + +[Примеры Обнаружения](detect.md){ .md-button .md-button--primary} + +## [Сегментация](segment.md) + +Сегментация — это задача, которая включает разбиение изображения на разные регионы на основе содержимого изображения. Каждому региону присваивается метка на основе его содержимого. Эта задача полезна в таких приложениях, как сегментация изображений и медицинская визуализация. YOLOv8 использует вариацию архитектуры U-Net для выполнения сегментации. + +[Примеры Сегментации](segment.md){ .md-button .md-button--primary} + +## [Классификация](classify.md) + +Классификация — это задача, включающая классификацию изображения на разные категории. YOLOv8 может быть использован для классификации изображений на основе их содержимого. Для выполнения классификации используется вариация архитектуры EfficientNet. + +[Примеры Классификации](classify.md){ .md-button .md-button--primary} + +## [Поза](pose.md) + +Обнаружение точек позы или ключевых точек — это задача, которая включает обнаружение конкретных точек на изображении или видеокадре. Эти точки называются ключевыми и используются для отслеживания движения или оценки позы. YOLOv8 может обнаруживать ключевые точки на изображении или видеокадре с высокой точностью и скоростью. + +[Примеры Поз](pose.md){ .md-button .md-button--primary} + +## Заключение + +YOLOv8 поддерживает множество задач, включая обнаружение, сегментацию, классификацию и обнаружение ключевых точек. Каждая из этих задач имеет разные цели и области применения. Понимая различия между этими задачами, вы можете выбрать подходящую задачу для вашего приложения компьютерного зрения. diff --git a/docs/ru/tasks/pose.md b/docs/ru/tasks/pose.md new file mode 100644 index 00000000..27d708f8 --- /dev/null +++ b/docs/ru/tasks/pose.md @@ -0,0 +1,176 @@ +--- +comments: true +description: Узнайте, как использовать Ultralytics YOLOv8 для задач оценки позы. Найдите предварительно обученные модели, узнайте, как обучать, проверять, предсказывать и экспортировать свои собственные. +--- + +# Оценка позы + +![Примеры оценки позы](https://user-images.githubusercontent.com/26833433/243418616-9811ac0b-a4a7-452a-8aba-484ba32bb4a8.png) + +Оценка позы — это задача, заключающаяся в определении местоположения определённых точек на изображении, обычно называемых контрольными точками. Контрольные точки могут представлять различные части объекта, такие как суставы, ориентиры или другие характерные особенности. Расположение контрольных точек обычно представлено в виде набора 2D `[x, y]` или 3D `[x, y, visible]` координат. + +Результат работы модели оценки позы — это набор точек, представляющих контрольные точки на объекте в изображении, обычно вместе с оценками уверенности для каждой точки. Оценка позы является хорошим выбором, когда вам нужно идентифицировать конкретные части объекта в сцене и их расположение относительно друг друга. + +[Смотрите: Оценка позы с Ultralytics YOLOv8.](https://www.youtube.com/embed/Y28xXQmju64?si=pCY4ZwejZFu6Z4kZ) + +!!! tip "Совет" + + Модели _pose_ YOLOv8 используют суффикс `-pose`, т.е. `yolov8n-pose.pt`. Эти модели обучены на наборе данных [COCO keypoints](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco-pose.yaml) и подходят для различных задач оценки позы. + +## [Модели](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8) + +Здесь представлены предварительно обученные модели YOLOv8 Pose. Модели Detect, Segment и Pose предварительно обучены на наборе данных [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), а модели Classify — на наборе данных [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml). + +[Модели](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) скачиваются автоматически из последнего [релиза](https://github.com/ultralytics/assets/releases) Ultralytics при первом использовании. + +| Модель | размер
(пиксели) | mAPpose
50-95 | mAPpose
50 | Скорость
CPU ONNX
(мс) | Скорость
A100 TensorRT
(мс) | параметры
(М) | FLOPs
(Б) | +|------------------------------------------------------------------------------------------------------|--------------------------|-----------------------|--------------------|-----------------------------------|----------------------------------------|-----------------------|-------------------| +| [YOLOv8n-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-pose.pt) | 640 | 50.4 | 80.1 | 131.8 | 1.18 | 3.3 | 9.2 | +| [YOLOv8s-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-pose.pt) | 640 | 60.0 | 86.2 | 233.2 | 1.42 | 11.6 | 30.2 | +| [YOLOv8m-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-pose.pt) | 640 | 65.0 | 88.8 | 456.3 | 2.00 | 26.4 | 81.0 | +| [YOLOv8l-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-pose.pt) | 640 | 67.6 | 90.0 | 784.5 | 2.59 | 44.4 | 168.6 | +| [YOLOv8x-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose.pt) | 640 | 69.2 | 90.2 | 1607.1 | 3.73 | 69.4 | 263.2 | +| [YOLOv8x-pose-p6](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose-p6.pt) | 1280 | 71.6 | 91.2 | 4088.7 | 10.04 | 99.1 | 1066.4 | + +- **mAPval** значения для одной модели одиночного масштаба на наборе данных [COCO Keypoints val2017](http://cocodataset.org). +
Воспроизводится с помощью: `yolo val pose data=coco-pose.yaml device=0` +- **Скорость** усреднена по изображениям COCO val на [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) инстансе. +
Воспроизводится с помощью: `yolo val pose data=coco8-pose.yaml batch=1 device=0|cpu` + +## Обучение + +Обучите модель YOLOv8-pose на наборе данных COCO128-pose. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Загрузить модель + model = YOLO('yolov8n-pose.yaml') # создать новую модель из YAML + model = YOLO('yolov8n-pose.pt') # загрузить предварительно обученную модель (рекомендуется для обучения) + model = YOLO('yolov8n-pose.yaml').load('yolov8n-pose.pt') # создать из YAML и перенести веса + + # Обучить модель + results = model.train(data='coco8-pose.yaml', epochs=100, imgsz=640) + ``` + === "CLI" + + ```bash + # Создать новую модель из YAML и начать обучение с нуля + yolo pose train data=coco8-pose.yaml model=yolov8n-pose.yaml epochs=100 imgsz=640 + + # Начать обучение с предварительно обученной модели *.pt + yolo pose train data=coco8-pose.yaml model=yolov8n-pose.pt epochs=100 imgsz=640 + + # Создать новую модель из YAML, перенести предварительно обученные веса и начать обучение + yolo pose train data=coco8-pose.yaml model=yolov8n-pose.yaml pretrained=yolov8n-pose.pt epochs=100 imgsz=640 + ``` + +### Формат набора данных + +Формат набора данных YOLO pose можно найти в подробностях в [Руководстве по наборам данных](../../datasets/pose/index.md). Для преобразования существующего набора данных из других форматов (например, COCO и т.д.) в формат YOLO, пожалуйста, используйте инструмент [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) от Ultralytics. + +## Проверка + +Проверьте точность обученной модели YOLOv8n-pose на наборе данных COCO128-pose. Аргументы не нужны, так как `model` +запоминает свои `data` и аргументы как атрибуты модели. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Загрузить модель + model = YOLO('yolov8n-pose.pt') # загрузить официальную модель + model = YOLO('path/to/best.pt') # загрузить свою модель + + # Проверить модель + metrics = model.val() # аргументы не нужны, набор данных и настройки запомнены + metrics.box.map # map50-95 + metrics.box.map50 # map50 + metrics.box.map75 # map75 + metrics.box.maps # список содержит map50-95 для каждой категории + ``` + === "CLI" + + ```bash + yolo pose val model=yolov8n-pose.pt # проверить официальную модель + yolo pose val model=path/to/best.pt # проверить свою модель + ``` + +## Предсказание + +Используйте обученную модель YOLOv8n-pose для выполнения предсказаний на изображениях. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Загрузить модель + model = YOLO('yolov8n-pose.pt') # загрузить официальную модель + model = YOLO('path/to/best.pt') # загрузить свою модель + + # Сделать предсказание моделью + results = model('https://ultralytics.com/images/bus.jpg') # предсказать по изображению + ``` + === "CLI" + + ```bash + yolo pose predict model=yolov8n-pose.pt source='https://ultralytics.com/images/bus.jpg' # предсказать официальной моделью + yolo pose predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # предсказать своей моделью + ``` + +Полные детали работы в режиме `predict` смотрите на странице [Predict](https://docs.ultralytics.com/modes/predict/). + +## Экспорт + +Экспортируйте модель YOLOv8n Pose в другой формат, такой как ONNX, CoreML и т.д. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Загрузить модель + model = YOLO('yolov8n-pose.pt') # загрузить официальную модель + model = YOLO('path/to/best.pt') # загрузить свою обученную модель + + # Экспортировать модель + model.export(format='onnx') + ``` + === "CLI" + + ```bash + yolo export model=yolov8n-pose.pt format=onnx # экспортировать официальную модель + yolo export model=path/to/best.pt format=onnx # экспортировать свою обученную модель + ``` + +Доступные форматы экспорта модели YOLOv8-pose приведены в таблице ниже. Вы можете делать предсказания или проверки непосредственно с экспортированных моделей, например, `yolo predict model=yolov8n-pose.onnx`. Примеры использования показаны для вашей модели после завершения экспорта. + +| Формат | Аргумент `format` | Модель | Метаданные | Аргументы | +|--------------------------------------------------------------------|-------------------|--------------------------------|------------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n-pose.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-pose.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-pose.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-pose_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-pose.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-pose.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-pose_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-pose.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-pose.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-pose_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-pose_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-pose_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-pose_ncnn_model/` | ✅ | `imgsz`, `half` | + +Полные детали экспорта смотрите на странице [Export](https://docs.ultralytics.com/modes/export/). diff --git a/docs/ru/tasks/segment.md b/docs/ru/tasks/segment.md new file mode 100644 index 00000000..a951b819 --- /dev/null +++ b/docs/ru/tasks/segment.md @@ -0,0 +1,189 @@ +--- +comments: true +description: Научитесь использовать модели сегментации объектов с помощью Ultralytics YOLO. Инструкции по обучению, валидации, предсказанию изображений и экспорту моделей. +keywords: yolov8, сегментация объектов, Ultralytics, набор данных COCO, сегментация изображений, обнаружение объектов, обучение моделей, валидация моделей, предсказания изображений, экспорт моделей +--- + +# Сегментация экземпляров + +Примеры сегментации экземпляров + +Сегментация экземпляров идёт на шаг дальше по сравнению с обнаружением объектов и включает идентификацию отдельных объектов на изображении и их сегментацию от остальной части изображения. + +Результатом модели сегментации экземпляров является набор масок или контуров, очерчивающих каждый объект на изображении, вместе с классовыми метками и коэффициентами уверенности для каждого объекта. Сегментация экземпляров полезна, когда вам нужно знать не только, где находятся объекты на изображении, но и их точную форму. + +

+
+ +
+ Смотрите: Запуск сегментации с предварительно обученной моделью Ultralytics YOLOv8 на Python. +

+ +!!! tip "Совет" + + Модели YOLOv8 Segment используют суффикс `-seg`, например `yolov8n-seg.pt` и предварительно обучены на [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml). + +## [Модели](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8) + +Здесь показаны предварительно обученные модели Segment YOLOv8. Модели Detect, Segment и Pose предварительно обучены на наборе данных [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), в то время как модели Classify предварительно обучены на наборе данных [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml). + +[Модели](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) автоматически загружаются из последнего [релиза](https://github.com/ultralytics/assets/releases) Ultralytics при первом использовании. + +| Модель | размер
(пиксели) | mAPbox
50-95 | mAPmask
50-95 | Скорость
CPU ONNX
(мс) | Скорость
A100 TensorRT
(мс) | параметры
(М) | FLOPs
(B) | +|----------------------------------------------------------------------------------------------|--------------------------|----------------------|-----------------------|-----------------------------------|----------------------------------------|-----------------------|-------------------| +| [YOLOv8n-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-seg.pt) | 640 | 36.7 | 30.5 | 96.1 | 1.21 | 3.4 | 12.6 | +| [YOLOv8s-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-seg.pt) | 640 | 44.6 | 36.8 | 155.7 | 1.47 | 11.8 | 42.6 | +| [YOLOv8m-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-seg.pt) | 640 | 49.9 | 40.8 | 317.0 | 2.18 | 27.3 | 110.2 | +| [YOLOv8l-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-seg.pt) | 640 | 52.3 | 42.6 | 572.4 | 2.79 | 46.0 | 220.5 | +| [YOLOv8x-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-seg.pt) | 640 | 53.4 | 43.4 | 712.1 | 4.02 | 71.8 | 344.1 | + +- Значения **mAPval** для одиночной модели одиночного масштаба на наборе данных [COCO val2017](http://cocodataset.org). +
Воспроизведите с помощью `yolo val segment data=coco.yaml device=0` +- **Скорость** усреднена для изображений COCO val на [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) + инстансе. +
Воспроизведите с помощью `yolo val segment data=coco128-seg.yaml batch=1 device=0|cpu` + +## Обучение + +Обучите модель YOLOv8n-seg на наборе данных COCO128-seg в течение 100 эпох при размере изображения 640. Полный список доступных аргументов см. на странице [Конфигурация](../../usage/cfg.md). + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Загрузить модель + model = YOLO('yolov8n-seg.yaml') # создать новую модель из YAML + model = YOLO('yolov8n-seg.pt') # загрузить предварительно обученную модель (рекомендуется для обучения) + model = YOLO('yolov8n-seg.yaml').load('yolov8n.pt') # создать из YAML и перенести веса + + # Обучить модель + results = model.train(data='coco128-seg.yaml', epochs=100, imgsz=640) + ``` + === "CLI" + + ```bash + # Создать новую модель из YAML и начать обучение с нуля + yolo segment train data=coco128-seg.yaml model=yolov8n-seg.yaml epochs=100 imgsz=640 + + # Начать обучение с предварительно обученной модели *.pt + yolo segment train data=coco128-seg.yaml model=yolov8n-seg.pt epochs=100 imgsz=640 + + # Создать новую модель из YAML, перенести предварительно обученные веса и начать обучение + yolo segment train data=coco128-seg.yaml model=yolov8n-seg.yaml pretrained=yolov8n-seg.pt epochs=100 imgsz=640 + ``` + +### Формат набора данных + +Формат набора данных для сегментации YOLO можно найти детально в [Руководстве по наборам данных](../../datasets/segment/index.md). Чтобы конвертировать свой существующий набор данных из других форматов (например, COCO и т.д.) в формат YOLO, пожалуйста, используйте инструмент [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) от Ultralytics. + +## Валидация + +Проверьте точность обученной модели YOLOv8n-seg на наборе данных COCO128-seg. Аргументы передавать не нужно, так как `model` сохраняет `data` и аргументы обучения в качестве атрибутов модели. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Загрузить модель + model = YOLO('yolov8n-seg.pt') # загрузить официальную модель + model = YOLO('path/to/best.pt') # загрузить пользовательскую модель + + # Провалидировать модель + metrics = model.val() # аргументы не нужны, набор данных и настройки запомнены + metrics.box.map # map50-95(B) + metrics.box.map50 # map50(B) + metrics.box.map75 # map75(B) + metrics.box.maps # список содержит map50-95(B) каждой категории + metrics.seg.map # map50-95(M) + metrics.seg.map50 # map50(M) + metrics.seg.map75 # map75(M) + metrics.seg.maps # список содержит map50-95(M) каждой категории + ``` + === "CLI" + + ```bash + yolo segment val model=yolov8n-seg.pt # валидация официальной модели + yolo segment val model=path/to/best.pt # валидация пользовательской модели + ``` + +## Предсказание + +Используйте обученную модель YOLOv8n-seg для выполнения предсказаний на изображениях. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Загрузить модель + model = YOLO('yolov8n-seg.pt') # загрузить официальную модель + model = YOLO('path/to/best.pt') # загрузить пользовательскую модель + + # Сделать предсказание с помощью модели + results = model('https://ultralytics.com/images/bus.jpg') # предсказать по изображению + ``` + === "CLI" + + ```bash + yolo segment predict model=yolov8n-seg.pt source='https://ultralytics.com/images/bus.jpg' # предсказать с официальной моделью + yolo segment predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # предсказать с пользовательской моделью + ``` + +Полная информация о режиме `predict` на странице [Predict](https://docs.ultralytics.com/modes/predict/). + +## Экспорт + +Экспортируйте модель YOLOv8n-seg в другой формат, например ONNX, CoreML и т.д. + +!!! example "" + + === "Python" + + ```python + from ultralytics import YOLO + + # Загрузить модель + model = YOLO('yolov8n-seg.pt') # загрузить официальную модель + model = YOLO('path/to/best.pt') # загрузить пользовательскую обученную модель + + # Экспортировать модель + model.export(format='onnx') + ``` + === "CLI" + + ```bash + yolo export model=yolov8n-seg.pt format=onnx # экспортировать официальную модель + yolo export model=path/to/best.pt format=onnx # экспортировать пользовательскую обученную модель + ``` + +Доступные форматы экспорта YOLOv8-seg приведены в таблице ниже. После завершения экспорта для вашей модели показаны примеры использования, включая прямое предсказание или валидацию на экспортированных моделях, например `yolo predict model=yolov8n-seg.onnx`. + +| Формат | Аргумент `format` | Модель | Метаданные | Аргументы | +|--------------------------------------------------------------------|-------------------|-------------------------------|------------|-----------------------------------------------------| +| [PyTorch](https://pytorch.org/) | - | `yolov8n-seg.pt` | ✅ | - | +| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-seg.torchscript` | ✅ | `imgsz`, `optimize` | +| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-seg.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` | +| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-seg_openvino_model/` | ✅ | `imgsz`, `half` | +| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-seg.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` | +| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-seg.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` | +| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-seg_saved_model/` | ✅ | `imgsz`, `keras` | +| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-seg.pb` | ❌ | `imgsz` | +| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-seg.tflite` | ✅ | `imgsz`, `half`, `int8` | +| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-seg_edgetpu.tflite` | ✅ | `imgsz` | +| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-seg_web_model/` | ✅ | `imgsz` | +| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-seg_paddle_model/` | ✅ | `imgsz` | +| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-seg_ncnn_model/` | ✅ | `imgsz`, `half` | + +Подробности о режиме `export` смотрите на странице [Export](https://docs.ultralytics.com/modes/export/). diff --git a/docs/update_translations.py b/docs/update_translations.py new file mode 100644 index 00000000..64b5c11a --- /dev/null +++ b/docs/update_translations.py @@ -0,0 +1,111 @@ +# Ultralytics YOLO 🚀, AGPL-3.0 license +""" +Script to fix broken Markdown links and front matter in language-specific directories. + +This script processes markdown files in language-specific directories (like /zh/). It finds Markdown links and checks +their existence. If a link is broken and does not exist in the language-specific directory but exists in the /en/ +directory, the script updates the link to point to the corresponding file in the /en/ directory. + +It also ensures that front matter keywords like 'comments:', 'description:', and 'keywords:' are not translated and +remain in English. +""" + +import re +from pathlib import Path + + +class MarkdownLinkFixer: + """Class to fix Markdown links and front matter in language-specific directories.""" + + def __init__(self, base_dir, update_links=True, update_frontmatter=True, update_iframes=True): + """Initialize the MarkdownLinkFixer with the base directory.""" + self.base_dir = Path(base_dir) + self.update_links = update_links + self.update_frontmatter = update_frontmatter + self.update_iframes = update_iframes + self.md_link_regex = re.compile(r'\[([^\]]+)\]\(([^:\)]+)\.md\)') + self.front_matter_regex = re.compile(r'^(comments|description|keywords):.*$', re.MULTILINE) + self.translations = { + 'zh': ['评论', '描述', '关键词'], # Mandarin Chinese (Simplified) + 'es': ['comentarios', 'descripción', 'palabras clave'], # Spanish + 'ru': ['комментарии', 'описание', 'ключевые слова'], # Russian + 'pt': ['comentários', 'descrição', 'palavras-chave'], # Portuguese + 'fr': ['commentaires', 'description', 'mots-clés'], # French + 'de': ['Kommentare', 'Beschreibung', 'Schlüsselwörter'], # German + 'ja': ['コメント', '説明', 'キーワード'], # Japanese + 'ko': ['댓글', '설명', '키워드'] # Korean + } # front matter translations for comments, description, keyword + + def replace_front_matter(self, content): + """Ensure front matter keywords remain in English.""" + english_keys = ['comments', 'description', 'keywords'] + + for lang, terms in self.translations.items(): + for term, eng_key in zip(terms, english_keys): + if eng_key == 'comments': + # Replace comments key and set its value to 'true' + content = re.sub(rf'{term} *:.*', f'{eng_key}: true', content) + else: + content = re.sub(rf'{term} *:', f'{eng_key}:', content) + + return content + + def update_iframe(self, content): + """Update the 'allow' attribute of iframe if it does not contain the specific English permissions.""" + english_permissions = 'accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share' + pattern = re.compile(f'allow="(?!{re.escape(english_permissions)}).+?"') + return pattern.sub(f'allow="{english_permissions}"', content) + + def link_replacer(self, match, parent_dir, lang_dir): + """Replace broken links with corresponding links in the /en/ directory.""" + text, path = match.groups() + linked_path = (parent_dir / path).resolve().with_suffix('.md') + + if not linked_path.exists(): + en_linked_path = Path(str(linked_path).replace(str(lang_dir), str(lang_dir.parent / 'en'))) + if en_linked_path.exists(): + steps_up = len(parent_dir.relative_to(self.base_dir).parts) + relative_path = Path('../' * steps_up) / en_linked_path.relative_to(self.base_dir) + relative_path = str(relative_path).replace('/en/', '/') + print(f"Redirecting link '[{text}]({path})' from {parent_dir} to {relative_path}") + return f'[{text}]({relative_path})' + else: + print(f"Warning: Broken link '[{text}]({path})' found in {parent_dir} does not exist in /docs/en/.") + return match.group(0) + + def process_markdown_file(self, md_file_path, lang_dir): + """Process each markdown file in the language directory.""" + print(f'Processing file: {md_file_path}') + with open(md_file_path, encoding='utf-8') as file: + content = file.read() + + if self.update_links: + content = self.md_link_regex.sub(lambda m: self.link_replacer(m, md_file_path.parent, lang_dir), content) + + if self.update_frontmatter: + content = self.replace_front_matter(content) + + if self.update_iframes: + content = self.update_iframe(content) + + with open(md_file_path, 'w', encoding='utf-8') as file: + file.write(content) + + def process_language_directory(self, lang_dir): + """Process each language-specific directory.""" + print(f'Processing language directory: {lang_dir}') + for md_file in lang_dir.rglob('*.md'): + self.process_markdown_file(md_file, lang_dir) + + def run(self): + """Run the link fixing and front matter updating process for each language-specific directory.""" + for subdir in self.base_dir.iterdir(): + if subdir.is_dir() and re.match(r'^\w\w$', subdir.name) and subdir.name != 'en': + self.process_language_directory(subdir) + + +if __name__ == '__main__': + # Set the path to your MkDocs 'docs' directory here + docs_dir = str(Path(__file__).parent.resolve()) + fixer = MarkdownLinkFixer(docs_dir, update_links=False, update_frontmatter=True, update_iframes=True) + fixer.run() diff --git a/docs/zh/datasets/index.md b/docs/zh/datasets/index.md new file mode 100644 index 00000000..d063e880 --- /dev/null +++ b/docs/zh/datasets/index.md @@ -0,0 +1,127 @@ +--- +comments: true +description: 探索 Ultralytics 支持的多种计算机视觉数据集，适用于对象检测、分割、姿态估计、图像分类和多对象跟踪。 +keywords: 计算机视觉, 数据集, Ultralytics, YOLO, 对象检测, 实例分割, 姿态估计, 图像分类, 多对象跟踪 +--- + +# 数据集概览 + +Ultralytics 支持多种数据集，方便开展计算机视觉任务，诸如检测、实例分割、姿态估计、分类和多对象跟踪。以下是主要 Ultralytics 数据集的列表，以及每个计算机视觉任务及其相应数据集的概述。 + +!!! note + + Ultralytics 团队正在努力将文档翻译成多种语言。目前，本页面上的链接可能会直接指向英文文档页面，因为我们正在扩展多语言文档支持。感谢您的耐心等待 🙏！ + +## [检测数据集](/../datasets/detect/index.md) + +边界框对象检测是一种计算机视觉技术，涉及通过在图像中的每个对象周围绘制边界框来检测和定位对象。 + +- [Argoverse](/../datasets/detect/argoverse.md)：包含城市环境中的 3D 追踪和运动预测数据，并提供丰富的注释。 +- [COCO](/../datasets/detect/coco.md)：一个大型数据集，专为对象检测、分割和描述设计，包含 20 多万带有标签的图像。 +- [COCO8](/../datasets/detect/coco8.md)：包含 COCO 训练集和 COCO 验证集的前 4 张图像，适合快速测试。 +- [Global Wheat 2020](/../datasets/detect/globalwheat2020.md)：一个小麦头部图像的数据集，收集自世界各地，用于对象检测和定位任务。 +- [Objects365](/../datasets/detect/objects365.md)：一个高质量的大规模对象检测数据集，含 365 个对象类别和逾 60 万个注释图像。 +- [OpenImagesV7](/../datasets/detect/open-images-v7.md)：谷歌提供的综合数据集，包含 170 万训练图像和 4.2 万验证图像。 +- [SKU-110K](/../datasets/detect/sku-110k.md)：一个特点是在零售环境中进行密集对象检测的数据集，包含 1.1 万图像和 170 万个边界框。 +- [VisDrone](/../datasets/detect/visdrone.md)：包含无人机拍摄图像中的对象检测和多对象跟踪数据的数据集，包含超过 1 万张图像和视频序列。 +- [VOC](/../datasets/detect/voc.md)：Pascal Visual Object Classes (VOC) 对象检测和分割数据集，包含 20 个对象类别和逾 1.1 万图像。 +- [xView](/../datasets/detect/xview.md)：用于航拍图像对象检测的数据集，包含 60 个对象类别和逾 100 万个注释对象。 + +## [实例分割数据集](/../datasets/segment/index.md) + +实例分割是一种计算机视觉技术，涉及在像素级别识别和定位图像中的对象。 + +- [COCO](/../datasets/segment/coco.md)：一个大型数据集，专为对象检测、分割和描述任务设计，包含 20 多万带有标签的图像。 +- [COCO8-seg](/../datasets/segment/coco8-seg.md)：一个用于实例分割任务的较小数据集，包含 8 张带有分割注释的 COCO 图像。 + +## [姿态估计](/../datasets/pose/index.md) + +姿态估计是一种用于确定对象相对于相机或世界坐标系统的姿势的技术。 + +- [COCO](/../datasets/pose/coco.md)：一个包含人体姿态注释的大型数据集，专为姿态估计任务设计。 +- [COCO8-pose](/../datasets/pose/coco8-pose.md)：一个用于姿态估计任务的较小数据集，包含 8 张带有人体姿态注释的 COCO 图像。 +- [Tiger-pose](/../datasets/pose/tiger-pose.md)：一个紧凑型数据集，包含 263 张专注于老虎的图像，每只老虎注释有 12 个关键点，用于姿态估计任务。 + +## [分类](/../datasets/classify/index.md) + +图像分类是一个计算机视觉任务，涉及基于其视觉内容将图像分类到一个或多个预定义类别中。 + +- [Caltech 101](/../datasets/classify/caltech101.md)：包含 101 个对象类别图像的数据集，用于图像分类任务。 +- [Caltech 256](/../datasets/classify/caltech256.md)：Caltech 101 的扩展版本，具有 256 个对象类别和更具挑战性的图像。 +- [CIFAR-10](/../datasets/classify/cifar10.md)：包含 60K 32x32 彩色图像的数据集，分为 10 个类别，每个类别有 6K 图像。 +- [CIFAR-100](/../datasets/classify/cifar100.md)：CIFAR-10 的扩展版本，具有 100 个对象类别和每类 600 个图像。 +- [Fashion-MNIST](/../datasets/classify/fashion-mnist.md)：包含 70,000 张灰度图像的数据集，图像来自 10 个时尚类别，用于图像分类任务。 +- [ImageNet](/../datasets/classify/imagenet.md)：一个大型的用于对象检测和图像分类的数据集，包含超过 1400 万图像和 2 万个类别。 +- [ImageNet-10](/../datasets/classify/imagenet10.md)：ImageNet 的一个较小子集，包含 10 个类别，用于更快速的实验和测试。 +- [Imagenette](/../datasets/classify/imagenette.md)：ImageNet 的一个较小子集，其中包含 10 个容易区分的类别，用于更快速的训练和测试。 +- [Imagewoof](/../datasets/classify/imagewoof.md)：ImageNet 的一个更具挑战性的子集，包含 10 个狗品种类别用于图像分类任务。 +- [MNIST](/../datasets/classify/mnist.md)：包含 70,000 张手写数字灰度图像的数据集，用于图像分类任务。 + +## [定向边界框 (OBB)](/../datasets/obb/index.md) + +定向边界框 (OBB) 是一种计算机视觉方法，用于使用旋转的边界框检测图像中的倾斜对象，常应用于航空和卫星图像。 + +- [DOTAv2](/../datasets/obb/dota-v2.md)：一个流行的 OBB 航拍图像数据集，拥有 170 万个实例和 11,268 张图像。 + +## [多对象跟踪](/../datasets/track/index.md) + +多对象跟踪是一种计算机视觉技术，涉及在视频序列中检测和跟踪多个对象的运动。 + +- [Argoverse](/../datasets/detect/argoverse.md)：包含城市环境中的 3D 追踪和运动预测数据，并提供丰富的注释，适用于多对象跟踪任务。 +- [VisDrone](/../datasets/detect/visdrone.md)：包含无人机拍摄图像中的对象检测和多对象跟踪数据的数据集，包含超过 1 万张图像和视频序列。 + +## 贡献新数据集 + +贡献一个新数据集需要几个步骤，来确保它与现有基础设施良好对齐。以下是必要的步骤： + +### 贡献新数据集的步骤 + +1. **收集图像**：收集属于数据集的图像。这些可能来自公共数据库或您自己的收藏。 + +2. **注释图像**：根据任务对这些图像进行边界框、分段或关键点的标记。 + +3. **导出注释**：将这些注释转换为 Ultralytics 支持的 YOLO *.txt 文件格式。 + +4. **组织数据集**：按正确的文件夹结构排列您的数据集。您应该有 `train/ ` 和 `val/` 顶级目录，在每个目录内，有 `images/` 和 `labels/` 子目录。 + + ``` + dataset/ + ├── train/ + │ ├── images/ + │ └── labels/ + └── val/ + ├── images/ + └── labels/ + ``` + +5. **创建一个 `data.yaml` 文件**：在数据集的根目录中，创建一个描述数据集的 `data.yaml` 文件，包括类别信息等必要内容。 + +6. **优化图像（可选）**：如果您想为了更高效的处理而减小数据集的大小，可以使用以下代码来优化图像。这不是必需的，但推荐用于减小数据集大小和加快下载速度。 + +7. **压缩数据集**：将整个数据集文件夹压缩成一个 zip 文件。 + +8. **文档和 PR**：创建描述您的数据集和它如何融入现有框架的文档页面。之后，提交一个 Pull Request (PR)。更多关于如何提交 PR 的详细信息，请参照 [Ultralytics 贡献指南](https://docs.ultralytics.com/help/contributing)。 + +### 优化和压缩数据集的示例代码 + +!!! example "优化和压缩数据集" + + === "Python" + + ```python + from pathlib import Path + from ultralytics.data.utils import compress_one_image + from ultralytics.utils.downloads import zip_directory + + # 定义数据集目录 + path = Path('path/to/dataset') + + # 优化数据集中的图像（可选） + for f in path.rglob('*.jpg'): + compress_one_image(f) + + # 将数据集压缩成 'path/to/dataset.zip' + zip_directory(path) + ``` + +通过遵循这些步骤，您可以贡献一个与 Ultralytics 现有结构良好融合的新数据集。 diff --git a/docs/zh/models/index.md b/docs/zh/models/index.md new file mode 100644 index 00000000..1735e416 --- /dev/null +++ b/docs/zh/models/index.md @@ -0,0 +1,94 @@ +--- +comments: true +description: 探索 Ultralytics 支持的 YOLO 系列、SAM、MobileSAM、FastSAM、YOLO-NAS 和 RT-DETR 模型多样化的范围。提供 CLI 和 Python 使用的示例以供入门。 +keywords: Ultralytics, 文档, YOLO, SAM, MobileSAM, FastSAM, YOLO-NAS, RT-DETR, 模型, 架构, Python, CLI +--- + +# Ultralytics 支持的模型 + +欢迎来到 Ultralytics 的模型文档！我们支持多种模型，每种模型都针对特定任务进行了优化，如[对象检测](/../tasks/detect.md)、[实例分割](/../tasks/segment.md)、[图像分类](/../tasks/classify.md)、[姿态估计](/../tasks/pose.md)和[多对象追踪](/../modes/track.md)。如果您有兴趣将您的模型架构贡献给 Ultralytics，请查看我们的[贡献指南](/../help/contributing.md)。 + +!!! note + + Ultralytics 团队正忙于将文档翻译成多种语言。本页面上的链接目前可能会导向英文文档页面，因为我们正在努力扩展多语言文档支持。感谢您的耐心等待 🙏！ + +## 特色模型 + +以下是一些关键支持的模型： + +1. **[YOLOv3](/../models/yolov3.md)**：YOLO 模型系列的第三个版本，最初由 Joseph Redmon 提出，以其高效的实时对象检测能力而闻名。 +2. **[YOLOv4](/../models/yolov4.md)**：YOLOv3 的 darknet 本地更新，由 Alexey Bochkovskiy 在 2020 年发布。 +3. **[YOLOv5](/../models/yolov5.md)**：Ultralytics 改进的 YOLO 架构版本，与之前的版本相比提供了更好的性能和速度折中选择。 +4. **[YOLOv6](/../models/yolov6.md)**：由 [美团](https://about.meituan.com/) 在 2022 年发布，并在公司众多自主配送机器人中使用。 +5. **[YOLOv7](/../models/yolov7.md)**：YOLOv4 作者在 2022 年发布的更新版 YOLO 模型。 +6. **[YOLOv8](/../models/yolov8.md)**：YOLO 系列的最新版本，具备增强的功能，如实例分割、姿态/关键点估计和分类。 +7. **[Segment Anything Model (SAM)](/../models/sam.md)**：Meta's Segment Anything Model (SAM)。 +8. **[Mobile Segment Anything Model (MobileSAM)](/../models/mobile-sam.md)**：由庆熙大学为移动应用程序打造的 MobileSAM。 +9. **[Fast Segment Anything Model (FastSAM)](/../models/fast-sam.md)**：中国科学院自动化研究所图像与视频分析组的 FastSAM。 +10. **[YOLO-NAS](/../models/yolo-nas.md)**：YOLO 神经架构搜索 (NAS) 模型。 +11. **[Realtime Detection Transformers (RT-DETR)](/../models/rtdetr.md)**：百度 PaddlePaddle 实时检测变换器 (RT-DETR) 模型。 + +

+
+ +
+ 观看：仅使用几行代码运行 Ultralytics YOLO 模型。 +

+ +## 入门：使用示例 + +!!! example "" + + === "Python" + + PyTorch 预训练的 `*.pt` 模型以及配置 `*.yaml` 文件都可以传递给 `YOLO()`、`SAM()`、`NAS()` 和 `RTDETR()` 类来在 Python 中创建模型实例： + + ```python + from ultralytics import YOLO + + # 加载 COCO 预训练的 YOLOv8n 模型 + model = YOLO('yolov8n.pt') + + # 显示模型信息（可选） + model.info() + + # 在 COCO8 示例数据集上训练模型 100 个周期 + results = model.train(data='coco8.yaml', epochs=100, imgsz=640) + + # 使用 YOLOv8n 模型对 'bus.jpg' 图像进行推理 + results = model('path/to/bus.jpg') + ``` + + === "CLI" + + CLI 命令可直接运行模型： + + ```bash + # 加载 COCO 预训练的 YOLOv8n 模型，并在 COCO8 示例数据集上训练它 100 个周期 + yolo train model=yolov8n.pt data=coco8.yaml epochs=100 imgsz=640 + + # 加载 COCO 预训练的 YOLOv8n 模型，并对 'bus.jpg' 图像进行推理 + yolo predict model=yolov8n.pt source=path/to/bus.jpg + ``` + +## 贡献新模型 + +有兴趣将您的模型贡献给 Ultralytics 吗？太好了！我们始终欢迎扩展我们的模型组合。 + +1. **Fork 仓库**：首先 Fork [Ultralytics GitHub 仓库](https://github.com/ultralytics/ultralytics)。 + +2. **克隆您的 Fork**：将您的 Fork 克隆到本地机器上，并创建一个新分支进行工作。 + +3. **实现您的模型**：按照我们在[贡献指南](/../help/contributing.md)中提供的编码标准和指南添加您的模型。 + +4. **彻底测试**：确保彻底测试您的模型，无论是独立还是作为整个管道的一部分。 + +5. **创建 Pull Request**：一旦您对您的模型感到满意，请创建一个到主仓库的 Pull Request 以便审查。 + +6. **代码审查与合并**：经审查，如果您的模型符合我们的标准，它将被合并到主仓库中。 + +有关详细步骤，请参阅我们的[贡献指南](/../help/contributing.md)。 diff --git a/docs/zh/modes/track.md b/docs/zh/modes/track.md index 047756dc..9409079d 100644 --- a/docs/zh/modes/track.md +++ b/docs/zh/modes/track.md @@ -1,7 +1,7 @@ --- -评论: 真 -描述: 学习如何使用Ultralytics YOLO进行视频流中的物体追踪。指南包括使用不同的追踪器和自定义追踪器配置。 -关键词: Ultralytics, YOLO, 物体追踪, 视频流, BoT-SORT, ByteTrack, Python 指南, CLI 指南 +comments: true +description: 学习如何使用Ultralytics YOLO进行视频流中的物体追踪。指南包括使用不同的追踪器和自定义追踪器配置。 +keywords: Ultralytics, YOLO, 物体追踪, 视频流, BoT-SORT, ByteTrack, Python 指南, CLI 指南 --- # 使用Ultralytics YOLO进行多物体追踪 diff --git a/docs/zh/modes/train.md b/docs/zh/modes/train.md index e4fe76cd..ffe06ea0 100644 --- a/docs/zh/modes/train.md +++ b/docs/zh/modes/train.md @@ -1,7 +1,7 @@ --- -评论: 真 -描述: 使用Ultralytics YOLO训练YOLOv8模型的逐步指南，包括单GPU和多GPU训练示例 -关键词: Ultralytics, YOLOv8, YOLO, 目标检测, 训练模式, 自定义数据集, GPU训练, 多GPU, 超参数, CLI示例, Python示例 +comments: true +description: 使用Ultralytics YOLO训练YOLOv8模型的逐步指南，包括单GPU和多GPU训练示例 +keywords: Ultralytics, YOLOv8, YOLO, 目标检测, 训练模式, 自定义数据集, GPU训练, 多GPU, 超参数, CLI示例, Python示例 --- # 使用Ultralytics YOLO进行模型训练