Add Docs languages zh, es, ru, pt, fr, de, ja, ko (#6316)

Signed-off-by: Glenn Jocher <glenn.jocher@ultralytics.com>
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
This commit is contained in:
Glenn Jocher 2023-11-13 18:18:31 +01:00 committed by GitHub
parent e3a538bbde
commit 48e70f0921
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
144 changed files with 17632 additions and 76 deletions

127
docs/ja/datasets/index.md Normal file
View file

@ -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の既存の構造に適切に統合された新しいデータセットを提供することができます。

82
docs/ja/index.md Normal file
View file

@ -0,0 +1,82 @@
---
comments: true
description: Ultralytics YOLOv8に関する完全ガイド。高速で高精度なオブジェクト検出・画像セグメンテーションモデル。インストール、予測、トレーニングチュートリアルなど。
keywords: Ultralytics, YOLOv8, オブジェクト検出, 画像セグメンテーション, 機械学習, ディープラーニング, コンピュータビジョン, YOLOv8 インストール, YOLOv8 予測, YOLOv8 トレーニング, YOLO 歴史, YOLO ライセンス
---
<div align="center">
<p>
<a href="https://yolovision.ultralytics.com" target="_blank">
<img width="1024" src="https://raw.githubusercontent.com/ultralytics/assets/main/yolov8/banner-yolov8.png" alt="Ultralytics YOLOバナー"></a>
</p>
<a href="https://github.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-github.png" width="3%" alt="Ultralytics GitHub"></a>
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
<a href="https://www.linkedin.com/company/ultralytics/"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-linkedin.png" width="3%" alt="Ultralytics LinkedIn"></a>
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
<a href="https://twitter.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-twitter.png" width="3%" alt="Ultralytics Twitter"></a>
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
<a href="https://youtube.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-youtube.png" width="3%" alt="Ultralytics YouTube"></a>
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
<a href="https://www.tiktok.com/@ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-tiktok.png" width="3%" alt="Ultralytics TikTok"></a>
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
<a href="https://www.instagram.com/ultralytics/"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-instagram.png" width="3%" alt="Ultralytics Instagram"></a>
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
<a href="https://ultralytics.com/discord"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-discord.png" width="3%" alt="Ultralytics Discord"></a>
<br>
<br>
<a href="https://github.com/ultralytics/ultralytics/actions/workflows/ci.yaml"><img src="https://github.com/ultralytics/ultralytics/actions/workflows/ci.yaml/badge.svg" alt="Ultralytics CI"></a>
<a href="https://codecov.io/github/ultralytics/ultralytics"><img src="https://codecov.io/github/ultralytics/ultralytics/branch/main/graph/badge.svg?token=HHW7IIVFVY" alt="Ultralytics コードカバレッジ"></a>
<a href="https://zenodo.org/badge/latestdoi/264818686"><img src="https://zenodo.org/badge/264818686.svg" alt="YOLOv8 引用情報"></a>
<a href="https://hub.docker.com/r/ultralytics/ultralytics"><img src="https://img.shields.io/docker/pulls/ultralytics/ultralytics?logo=docker" alt="Docker プル"></a>
<br>
<a href="https://console.paperspace.com/github/ultralytics/ultralytics"><img src="https://assets.paperspace.io/img/gradient-badge.svg" alt="Gradient上で実行"/></a>
<a href="https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Colabで開く"></a>
<a href="https://www.kaggle.com/ultralytics/yolov8"><img src="https://kaggle.com/static/images/open-in-kaggle.svg" alt="Kaggleで開く"></a>
</div>
全く新しい[Ultralytics](https://ultralytics.com)の[YOLOv8](https://github.com/ultralytics/ultralytics)を紹介します。これは、実時間で動作するオブジェクト検出および画像セグメンテーションモデルの最新バージョンです。YOLOv8は、ディープラーニングとコンピュータビジョンの最先端の進歩に基づいており、速度と精度の面で比類のない性能を提供します。その合理化された設計により、エッジデバイスからクラウドAPIまで、さまざまなアプリケーションやハードウェアプラットフォームへの適応が容易です。
YOLOv8ドキュメントを探索し、その特徴と能力を理解し、活用するための包括的なリソースを提供します。機械学習の経験者であれ、分野の新入りであれ、このハブはあなたのプロジェクトでYOLOv8のポテンシャルを最大限に引き出すことを目指しています。
!!! note
🚧 多言語ドキュメントは現在作成中であり、改善に努めております。お待ちいただき、ありがとうございます! 🙏
## はじめに
- pipで`ultralytics`を**インストール**し、数分で稼働 &nbsp; [:material-clock-fast: はじめに](quickstart.md){ .md-button }
- YOLOv8で新しい画像やビデオに**予測** &nbsp; [:octicons-image-16: 画像で予測](modes/predict.md){ .md-button }
- 独自のカスタムデータセットで新しいYOLOv8モデルを**トレーニング** &nbsp; [:fontawesome-solid-brain: モデルをトレーニング](modes/train.md){ .md-button }
- セグメント、クラス分け、ポーズ、トラッキングなどのYOLOv8タスクを**探求** &nbsp; [:material-magnify-expand: タスクを探求](tasks/index.md){ .md-button }
<p align="center">
<br>
<iframe width="720" height="405" src="https://www.youtube.com/embed/LNwODJXcvt4?si=7n1UvGRLSd9p5wKs"
title="YouTubeビデオプレイヤー" frameborder="0"
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
allowfullscreen>
</iframe>
<br>
<strong>視聴:</strong> <a href="https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb" target="_blank">Google Colab</a>でカスタムデータセットにYOLOv8モデルをトレーニングする方法。
</p>
## 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)を通じてお問い合わせください。
私たちのライセンス戦略は、オープンソースプロジェクトに対するあらゆる改善がコミュニティに還元されることを確実にするために設計されています。私たちはオープンソースの原則を大切にしており、私たちの貢献が全ての人にとって有益な方法で利用可能であり、さらに拡張されることを保証することを使命としています。❤️

94
docs/ja/models/index.md Normal file
View file

@ -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)モデル。
<p align="center">
<br>
<iframe width="720" height="405" src="https://www.youtube.com/embed/MWq1UxqTClU?si=nHAW-lYDzrz68jR0"
title="YouTube video player" frameborder="0"
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
allowfullscreen>
</iframe>
<br>
<strong>視聴:</strong> Ultralytics YOLOモデルを数行のコードで実行。
</p>
## 入門:使用例
!!! 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)を参照してください。

View file

@ -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 でのモデルベンチマーク
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="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`の詳細をご覧ください。

76
docs/ja/modes/export.md Normal file
View file

@ -0,0 +1,76 @@
---
comments: true
description: YOLOv8モデルをONNX, TensorRT, CoreMLなどの様々なフォーマットへエキスポートする手順についてのガイドです。今すぐ展開を探求してください
keywords: YOLO, YOLOv8, Ultralytics, モデルエキスポート, ONNX, TensorRT, CoreML, TensorFlow SavedModel, OpenVINO, PyTorch, モデルをエキスポート
---
# Ultralytics YOLO でのモデルエキスポート
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ultralytics YOLO エコシステムと統合">
## はじめに
モデルのトレーニング終了後の最終目標は、実世界のアプリケーションに導入することです。Ultralytics YOLOv8のエキスポートモードは、トレーニング済みモデルを異なるフォーマットにエキスポートして、様々なプラットフォームやデバイスで展開可能にするための多様なオプションを提供します。この包括的なガイドは、モデルエキスポートのニュアンスをわかりやすく解説し、最大の互換性とパフォーマンスを達成する方法をご紹介します。
<p align="center">
<br>
<iframe width="720" height="405" src="https://www.youtube.com/embed/WbomGeoOT_k?si=aGmuyooWftA0ue9X"
title="YouTube video player" frameborder="0"
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
allowfullscreen>
</iframe>
<br>
<strong>視聴:</strong> カスタムトレーニングしたUltralytics YOLOv8モデルをエキスポートして、ウェブカムでリアルタイム推論を実行する方法。
</p>
## 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...]

53
docs/ja/modes/index.md Normal file
View file

@ -0,0 +1,53 @@
---
comments: true
description: トレーニングからトラッキングまで、UltralyticsのYOLOv8を活用して最大限に活用します。検証、エクスポート、ベンチマーキングなど、各サポートモードの洞察と例を得る。
keywords: Ultralytics, YOLOv8, 機械学習, オブジェクト検出, トレーニング, 検証, 予測, エクスポート, トラッキング, ベンチマーキング
---
# Ultralytics YOLOv8 モード
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ultralytics YOLOエコシステムと統合">
## はじめに
Ultralytics YOLOv8は、単なるオブジェクト検出モデルではありません; これは、データ収集、モデルトレーニングから検証、デプロイメント、実際のトラッキングに至るまでの機械学習モデルのライフサイクル全体をカバーするように設計された多用途フレームワークです。各モードは特定の目的に役立ち、異なるタスクやユースケースに必要な柔軟性と効率を提供するように工夫されています。
<p align="center">
<br>
<iframe width="720" height="405" src="https://www.youtube.com/embed/j8uQc0qB91s?si=dhnGKgqvs7nPgeaM"
title="YouTube video player" frameborder="0"
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
allowfullscreen>
</iframe>
<br>
<strong>視聴する:</strong> Ultralytics モードチュートリアル: トレーニ、検証、予測、エクスポート ベンチマーキング。
</p>
### モードの概要
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モデルを使用して予測を行うために使用されます。このモードでは、モデルがチェックポイントファイルから読み込まれ、ユーザーが推論を行うために画像やビデオを提供できます。モデルは、入力した画像やビデオ内のオブジェクトのクラスと位置を予測します。

211
docs/ja/modes/predict.md Normal file
View file

@ -0,0 +1,211 @@
---
comments: true
description: YOLOv8予測モードの使用方法について学び、画像、動画、データフォーマットなどさまざまな推論ソースについて解説します。
keywords: Ultralytics, YOLOv8, 予測モード, 推論ソース, 予測タスク, ストリーミングモード, 画像処理, 動画処理, 機械学習, AI
---
# Ultralytics YOLOによるモデル予測
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ultralytics YOLO ecosystem and integrations">
## イントロダクション
機械学習やコンピュータビジョンの世界では、視覚データから意味を引き出すプロセスを「推論」または「予測」と呼ばれています。UltralyticsのYOLOv8は、幅広いデータソースに対して高性能でリアルタイムな推論を行うために特化した、「予測モード」と呼ばれる強力な機能を提供しています。
<p align="center">
<br>
<iframe width="720" height="405" src="https://www.youtube.com/embed/QtsI0TnwDZs?si=ljesw75cMO2Eas14"
title="YouTube video player" frameborder="0"
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
allowfullscreen>
</iframe>
<br>
<strong>視聴:</strong> Ultralytics YOLOv8モデルの出力をカスタムプロジェクトに取り込む方法を学ぶ。
</p>
## 実際の応用例
| 製造業 | スポーツ | 安全 |
|:-----------------------------------------------------------------------------------------------------------------------------------:|:-------------------------------------------------------------------------------------------------------------------------------:|:---------------------------------------------------------------------------------------------------------------------------:|
| ![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オブジェクトのリスト
```

200
docs/ja/modes/track.md Normal file
View file

@ -0,0 +1,200 @@
---
comments: true
description: Ultralytics YOLOを使用したビデオストリームでのオブジェクトトラッキングの使用方法を学びます。異なるトラッカーの使用ガイドとトラッカー構成のカスタマイズについて。
keywords: Ultralytics, YOLO, オブジェクトトラッキング, ビデオストリーム, BoT-SORT, ByteTrack, Pythonガイド, CLIガイド
---
# Ultralytics YOLOによる複数オブジェクトのトラッキング
<img width="1024" src="https://user-images.githubusercontent.com/26833433/243418637-1d6250fd-1515-4c10-a844-a32818ae6d46.png" alt="複数オブジェクトのトラッキング例">
ビデオ分析の領域でのオブジェクトトラッキングは、フレーム内のオブジェクトの位置とクラスを特定するだけでなく、ビデオが進行するにつれてそれぞれの検出されたオブジェクトにユニークなIDを維持する重要なタスクです。その応用範囲は無限で、監視やセキュリティからリアルタイムスポーツ分析まで及びます。
## オブジェクトトラッキングにUltralytics YOLOを選ぶ理由は
Ultralyticsのトラッカーからの出力は標準のオブジェクト検出と一致しており、さらにオブジェクトIDの付加価値があります。これにより、ビデオストリーム内のオブジェクトを追跡し、後続の分析を行うことが容易になります。Ultralytics YOLOをオブジェクトトラッキングのニーズに利用を検討する理由は以下の通りです
- **効率性:** 精度を損なうことなくリアルタイムでビデオストリームを処理します。
- **柔軟性:** 複数のトラッキングアルゴリズムと構成をサポートしています。
- **使いやすさ:** 簡単なPython APIとCLIオプションで迅速な統合と展開が可能です。
- **カスタマイズ性:** カスタムトレーニング済みのYOLOモデルとの容易な使用により、ドメイン特有のアプリケーションへの統合が可能です。
<p align="center">
<br>
<iframe width="720" height="405" src="https://www.youtube.com/embed/hHyHmOtmEgs?si=VNZtXmm45Nb9s-N-"
title="YouTube video player" frameborder="0"
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
allowfullscreen>
</iframe>
<br>
<strong>視聴:</strong> Ultralytics YOLOv8によるオブジェクト検出とトラッキング。
</p>
## 実世界での応用例
| 交通 | 小売 | 水産業 |
|:---------------------------------------------------------------------------------------------------------------:|:---------------------------------------------------------------------------------------------------------------:|:--------------------------------------------------------------------------------------------------------------:|
| ![車両のトラッキング](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エコシステムのトラッキング機能を高めましょう 🙏!

206
docs/ja/modes/train.md Normal file
View file

@ -0,0 +1,206 @@
---
comments: true
description: YOLOv8モデルをUltralytics YOLOを使用してトレーニングする手順についてのガイドで、シングルGPUとマルチGPUトレーニングの例を含む
keywords: Ultralytics, YOLOv8, YOLO, 物体検出, トレーニングモード, カスタムデータセット, GPUトレーニング, マルチGPU, ハイパーパラメータ, CLI例, Python例
---
# Ultralytics YOLOを使ったモデルトレーニング
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ultralytics YOLOエコシステムと統合">
## はじめに
ディープラーニングモデルのトレーニングは、データを与えてパラメーターを調整し、正確な予測を行えるようにするプロセスを含みます。UltralyticsのYOLOv8のトレーニングモードは、現代のハードウェアの能力をフルに活用して物体検出モデルを効果的かつ効率的にトレーニングするために設計されています。このガイドは、YOLOv8 の豊富な機能セットを使用して自身のモデルをトレーニングするために必要なすべての詳細をカバーすることを目的としています。
<p align="center">
<br>
<iframe width="720" height="405" src="https://www.youtube.com/embed/LNwODJXcvt4?si=7n1UvGRLSd9p5wKs"
title="YouTube動画プレーヤー" frameborder="0"
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
allowfullscreen>
</iframe>
<br>
<strong>視聴:</strong> Google Colab でカスタムデータセットにYOLOv8モデルをトレーニングする方法。
</p>
## トレーニングに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 ShadersMPSフレームワークを使用してデバイスでモデルをトレーニングすることが可能になりました。 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がロードされ、トレーニングログが保存されているディレクトリを指定します。
ログを設定した後、モデルのトレーニングを進めてください。すべてのトレーニングメトリクスが選択したプラットフォームに自動的に記録され、これらのログをアクセスして、時間とともにモデルのパフォーマンスを監視したり、さまざまなモデルを比較したり、改善の余地を特定したりすることができます。

86
docs/ja/modes/val.md Normal file
View file

@ -0,0 +1,86 @@
---
comments: true
description: YOLOv8モデルのバリデーションガイド。バリデーション設定とメトリクスを使用してYOLOモデルのパフォーマンスを評価する方法をPythonとCLIの例で学びましょう。
keywords: Ultralytics, YOLO ドキュメント, YOLOv8, バリデーション, モデル評価, ハイパーパラメータ, 正確性, メトリクス, Python, CLI
---
# Ultralytics YOLOによるモデルバリデーション
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="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' |
| | | |

187
docs/ja/quickstart.md Normal file
View file

@ -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 IndexPyPIを参照してください: [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をインストールすることをお勧めします。
<a href="https://pytorch.org/get-started/locally/">
<img width="800" alt="PyTorch Installation Instructions" src="https://user-images.githubusercontent.com/26833433/228650108-ab0ec98a-b328-4f40-a40d-95355e8a84e3.png">
</a>
## 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` &nbsp;
- `yolo predict model yolov8n.pt imgsz 640 conf 0.25` &nbsp;
- `yolo predict --model yolov8n.pt --imgsz 640 --conf 0.25` &nbsp;
[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}

172
docs/ja/tasks/classify.md Normal file
View file

@ -0,0 +1,172 @@
---
comments: true
description: YOLOv8 分類モデルについての画像分類。事前トレーニングされたモデルのリストとモデルのトレーニング、検証、予測、エクスポート方法の詳細情報を学びます。
keywords: Ultralytics, YOLOv8, 画像分類, 事前トレーニングされたモデル, YOLOv8n-cls, トレーニング, 検証, 予測, モデルエクスポート
---
# 画像分類
<img width="1024" src="https://user-images.githubusercontent.com/26833433/243418606-adf35c62-2e11-405d-84c6-b84e7d013804.png" alt="画像分類の例">
画像分類は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) から自動的にダウンロードされます。
| モデル | サイズ<br><sup>(ピクセル) | 正確性<br><sup>トップ1 | 正確性<br><sup>トップ5 | スピード<br><sup>CPU ONNX<br>(ms) | スピード<br><sup>A100 TensorRT<br>(ms) | パラメータ<br><sup>(M) | FLOPs<br><sup>(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/) データセットの検証セットでのモデルの正確性です。
<br>再現するには `yolo val classify data=path/to/ImageNet device=0`
- **スピード** は [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) インスタンスを使用して ImageNet 検証画像を平均化したものです。
<br>再現するには `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/) ページを参照してください。

184
docs/ja/tasks/detect.md Normal file
View file

@ -0,0 +1,184 @@
---
comments: true
description: Ultralyticsの公式ドキュメント YOLOv8。モデルのトレーニング、検証、予測、そして様々なフォーマットでのモデルエクスポート方法を学ぶ。詳細なパフォーマンス統計も含む。
keywords: YOLOv8, Ultralytics, 物体検出, 事前訓練済みモデル, トレーニング, 検証, 予測, モデルエクスポート, COCO, ImageNet, PyTorch, ONNX, CoreML
---
# 物体検出
<img width="1024" src="https://user-images.githubusercontent.com/26833433/243418624-5785cb93-74c9-4541-9179-d5c6782d491a.png" alt="物体検出の例">
物体検出とは、画像やビデオストリーム内の物体の位置とクラスを特定するタスクです。
物体検出器の出力は、画像内の物体を囲む一連のバウンディングボックスであり、各ボックスにはクラスラベルと信頼度スコアが付けられます。シーン内の関心対象を識別する必要があるが、その物体の正確な位置や形状までは必要ない場合に、物体検出が適しています。
<p align="center">
<br>
<iframe width="720" height="405" src="https://www.youtube.com/embed/5ku7npMrW40?si=6HQO1dDXunV8gekh"
title="YouTube video player" frameborder="0"
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
allowfullscreen>
</iframe>
<br>
<strong>視聴する:</strong> Ultralyticsの事前訓練済みYOLOv8モデルによる物体検出。
</p>
!!! 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)から自動的にダウンロードされます。
| モデル | サイズ<br><sup>(ピクセル) | mAP<sup>val<br>50-95 | 速度<br><sup>CPU ONNX<br>(ms) | 速度<br><sup>A100 TensorRT<br>(ms) | パラメータ数<br><sup>(M) | FLOPs<br><sup>(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 |
- **mAP<sup>val</sup>** の値は[COCO val2017](http://cocodataset.org)データセットにおいて、単一モデル単一スケールでのものです。
<br>再現方法: `yolo val detect data=coco.yaml device=0`
- **速度** は[Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/)インスタンスを使用してCOCO val画像に対して平均化されたものです。
<br>再現方法: `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/)ページで全て見ることができます。

55
docs/ja/tasks/index.md Normal file
View file

@ -0,0 +1,55 @@
---
comments: true
description: YOLOv8が実行できる基本的なコンピュータービジョンタスクについて学び、検出、セグメンテーション、分類、ポーズ認識がAIプロジェクトでどのように使用されるかを理解します。
keywords: Ultralytics, YOLOv8, 検出, セグメンテーション, 分類, ポーズ推定, AIフレームワーク, コンピュータービジョンタスク
---
# Ultralytics YOLOv8タスク
<br>
<img width="1024" src="https://raw.githubusercontent.com/ultralytics/assets/main/im/banner-tasks.png" alt="Ultralytics YOLOがサポートするタスク">
YOLOv8は、複数のコンピュータービジョン**タスク**をサポートするAIフレームワークです。このフレームワークは、[検出](detect.md)、[セグメンテーション](segment.md)、[分類](classify.md)、及び[ポーズ](pose.md)推定を実行するために使用できます。これらのタスクはそれぞれ異なる目的と用途を持っています。
!!! note
🚧 当社の多言語ドキュメントは現在建設中であり、改善のために一生懸命作業を行っています。ご理解いただきありがとうございます!🙏
<p align="center">
<br>
<iframe width="720" height="405" src="https://www.youtube.com/embed/NAs-cfq9BDw"
title="YouTube video player" frameborder="0"
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
allowfullscreen>
</iframe>
<br>
<strong>視聴する:</strong> Ultralytics YOLOタスクの探索オブジェクト検出、セグメンテーション、トラッキング、ポーズ推定。
</p>
## [検出](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は、検出、セグメンテーション、分類、キーポイント検出を含む複数のタスクをサポートしています。これらのタスクはそれぞれ異なる目的と用途を持っています。これらのタスクの違いを理解することにより、コンピュータービジョンアプリケーションに適切なタスクを選択することができます。

185
docs/ja/tasks/pose.md Normal file
View file

@ -0,0 +1,185 @@
---
comments: true
description: Ultralytics YOLOv8を使用してポーズ推定タスクを行う方法を学びます。事前トレーニング済みのモデルを見つけ、トレーニング、検証、予測、独自のエクスポートを行います。
keywords: Ultralytics, YOLO, YOLOv8, ポーズ推定, キーポイント検出, 物体検出, 事前トレーニング済みモデル, 機械学習, 人工知能
---
# ポーズ推定
<img width="1024" src="https://user-images.githubusercontent.com/26833433/243418616-9811ac0b-a4a7-452a-8aba-484ba32bb4a8.png" alt="ポーズ推定例">
ポーズ推定は、通常キーポイントとして参照される画像内の特定の点の位置を識別するタスクです。キーポイントは、関節、ランドマーク、またはその他の特徴的な特徴など、対象物のさまざまな部分を表すことができます。キーポイントの位置は、通常2Dの `[x, y]` または3D `[x, y, visible]` 座標のセットとして表されます。
ポーズ推定モデルの出力は、画像内のオブジェクト上のキーポイントを表す一連の点であり、通常は各点の信頼スコアを伴います。ポーズ推定は、シーン内のオブジェクトの特定の部分と、それらが互いに対して位置する場所を特定する必要がある場合に適しています。
<p align="center">
<br>
<iframe width="720" height="405" src="https://www.youtube.com/embed/Y28xXQmju64?si=pCY4ZwejZFu6Z4kZ"
title="YouTube video player" frameborder="0"
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
allowfullscreen>
</iframe>
<br>
<strong>視聴:</strong> Ultralytics YOLOv8によるポーズ推定。
</p>
!!! 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)から最初の使用時に自動的にダウンロードされます。
| モデル | サイズ<br><sup>(ピクセル) | mAP<sup>ポーズ<br>50-95 | mAP<sup>ポーズ<br>50 | 速度<br><sup>CPU ONNX<br>(ミリ秒) | 速度<br><sup>A100 TensorRT<br>(ミリ秒) | パラメータ<br><sup>(M) | FLOPs<br><sup>(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 |
- **mAP<sup>val</sup>** の値は、[COCO Keypoints val2017](http://cocodataset.org)データセットでの単一モデル単一スケールに対するものです。
<br>再現方法 `yolo val pose data=coco-pose.yaml device=0`
- **速度** は [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/)インスタンスを使用したCOCO val画像の平均です。
<br>再現方法 `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/)ページでご覧いただけます。

186
docs/ja/tasks/segment.md Normal file
View file

@ -0,0 +1,186 @@
---
comments: true
description: Ultralytics YOLOを使用してインスタンスセグメンテーションモデルを使いこなす方法を学びましょう。トレーニング、バリデーション、画像予測、モデルエクスポートに関する指示が含まれています。
keywords: yolov8, インスタンスセグメンテーション, Ultralytics, COCOデータセット, 画像セグメンテーション, オブジェクト検出, モデルトレーニング, モデルバリデーション, 画像予測, モデルエクスポート
---
# インスタンスセグメンテーション
<img width="1024" src="https://user-images.githubusercontent.com/26833433/243418644-7df320b8-098d-47f1-85c5-26604d761286.png" alt="インスタンスセグメンテーションの例">
インスタンスセグメンテーションはオブジェクト検出を一歩進めており、画像内の個々のオブジェクトを識別し、それらを画像の残りの部分からセグメント化します。
インスタンスセグメンテーションモデルの出力は、画像内の各オブジェクトを概説するマスクまたは輪郭のセットであり、各オブジェクトにはクラスラベルと信頼スコアが含まれています。オブジェクトの位置だけでなく、その正確な形状を知る必要がある場合に、インスタンスセグメンテーションが役立ちます。
<p align="center">
<br>
<iframe width="720" height="405" src="https://www.youtube.com/embed/o4Zd-IeMlSY?si=37nusCzDTd74Obsp"
title="YouTubeのビデオプレーヤー" frameborder="0"
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
allowfullscreen>
</iframe>
<br>
<strong>視聴:</strong> Pythonで事前トレーニング済みのUltralytics YOLOv8モデルでセグメンテーションを実行する。
</p>
!!! 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)から自動的にダウンロードされます。
| モデル | サイズ<br><sup>(ピクセル) | mAP<sup>box<br>50-95 | mAP<sup>mask<br>50-95 | スピード<br><sup>CPU ONNX<br>(ms) | スピード<br><sup>A100 TensorRT<br>(ms) | パラメータ<br><sup>(M) | FLOPs<br><sup>(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 |
- **mAP<sup>val</sup>**の値は[COCO val2017](http://cocodataset.org)データセットでの単一モデル単一スケールの値です。
<br>再現するには `yolo val segment data=coco.yaml device=0`
- **スピード**は[Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/)インスタンスを使用してCOCO val画像で平均化されます。
<br>再現するには `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` |