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-22 20:45:46 +01:00 committed by GitHub
parent 0c4e97443b
commit 16a13a1ce0
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
178 changed files with 14224 additions and 561 deletions

193
docs/ja/models/fast-sam.md Normal file
View file

@ -0,0 +1,193 @@
---
comments: true
description: FastSAMは、画像内のオブジェクトをリアルタイムでセグメンテーションするためのCNNベースのソリューションです。利用者の対話、計算効率の向上、様々なビジョンタスクに対応可能です。
keywords: FastSAM, 機械学習, CNNベースのソリューション, オブジェクトセグメンテーション, リアルタイムソリューション, Ultralytics, ビジョンタスク, 画像処理, 工業用途, ユーザー対話
---
# Fast Segment Anything Model (FastSAM)
Fast Segment Anything ModelFastSAMは、セグメントエニシングタスクのための新しいリアルタイムのCNNベースのソリューションです。このタスクは、さまざまなユーザー対話のプロンプトに基づいて画像内の任意のオブジェクトをセグメント化することを目的としています。FastSAMは、優れた性能を維持しながら、計算要件を大幅に削減し、様々なビジョンタスクに実用的な選択肢となります。
![Fast Segment Anything Model (FastSAM) architecture overview](https://user-images.githubusercontent.com/26833433/248551984-d98f0f6d-7535-45d0-b380-2e1440b52ad7.jpg)
## 概要
FastSAMは、[Segment Anything Model (SAM)](sam.md)の制約事項に対処するために設計されました。SAMは、大規模な計算リソースを要する重いTransformerモデルです。FastSAMは、セグメントエニシングタスクを2つの連続するステージに分割し、すべてのインスタンスセグメンテーションとプロンプトガイドの選択を行います。最初のステージでは、[YOLOv8-seg](../tasks/segment.md)を使用して、画像内のすべてのインスタンスのセグメンテーションマスクを生成します。2番目のステージでは、プロンプトに対応する領域を出力します。
## 主な特徴
1. **リアルタイムソリューション:** CNNの計算効率を活用することで、FastSAMはセグメントエニシングタスクのためのリアルタイムソリューションを提供し、迅速な結果を必要とする工業用途に価値をもたらします。
2. **効率と性能:** FastSAMは、計算およびリソースの要求を大幅に削減しながら、パフォーマンスの品質を損なうことなく、SAMと同等のパフォーマンスを達成します。これにより、リアルタイムアプリケーションが可能となります。
3. **プロンプトガイドのセグメンテーション:** FastSAMは、さまざまなユーザー対話のプロンプトに基づいて画像内の任意のオブジェクトをセグメント化することができます。これにより、様々なシナリオでの柔軟性と適応性が提供されます。
4. **YOLOv8-segに基づく** FastSAMは、インスタンスセグメンテーションブランチを備えたオブジェクト検出器である[YOLOv8-seg](../tasks/segment.md)に基づいています。これにより、画像内のすべてのインスタンスのセグメンテーションマスクを効果的に生成することができます。
5. **ベンチマークでの競合力のある結果:** MS COCOのオブジェクトプロポーザルタスクにおいて、FastSAMは単一のNVIDIA RTX 3090上でのSAMよりもはるかに高速に高得点を獲得し、その効率性と能力を示しています。
6. **実用的な応用:** 提案されたアプローチは、現在の方法よりも数十倍または数百倍も高速な速度で、非常に高速なvisionタスクの新しい実用的なソリューションを提供します。
7. **モデルの圧縮の可能性:** FastSAMは、構造への人工的な事前条件を導入することにより、計算負荷を大幅に削減する可能な経路を示し、一般的なビジョンタスクの大規模モデルアーキテクチャの新たな可能性を開くことを示しています。
## 利用可能なモデル、サポートされるタスク、および動作モード
この表は、利用可能なモデルとそれぞれの特定の事前学習済みウェイト、サポートされるタスク、およびInference、Validation、Training、Exportなどの異なる操作モードとの互換性を示しています。サポートされているモードは✅、サポートされていないモードは❌の絵文字で示されます。
| モデルの種類 | 事前学習済みウェイト | サポートされるタスク | Inference | Validation | Training | Export |
|-----------|----------------|----------------------------------------|-----------|------------|----------|--------|
| FastSAM-s | `FastSAM-s.pt` | [インスタンスセグメンテーション](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ |
| FastSAM-x | `FastSAM-x.pt` | [インスタンスセグメンテーション](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ |
## 使用例
FastSAMモデルは、Pythonアプリケーションに簡単に統合できます。Ultralyticsは、開発を効率化するためのユーザーフレンドリーなPython APIおよびCLIコマンドを提供しています。
### 予測の使用方法
画像のオブジェクト検出を実行するには、以下のように`predict`メソッドを使用します:
!!! Example "例"
=== "Python"
```python
from ultralytics import FastSAM
from ultralytics.models.fastsam import FastSAMPrompt
# 推論元のソースを定義する
source = 'path/to/bus.jpg'
# FastSAMモデルを作成する
model = FastSAM('FastSAM-s.pt') # または FastSAM-x.pt
# 画像への推論を実行する
everything_results = model(source, device='cpu', retina_masks=True, imgsz=1024, conf=0.4, iou=0.9)
# Prompt Processオブジェクトを準備する
prompt_process = FastSAMPrompt(source, everything_results, device='cpu')
# Everything prompt
ann = prompt_process.everything_prompt()
# バウンディングボックスのデフォルトの形状は [0,0,0,0] -> [x1,y1,x2,y2]
ann = prompt_process.box_prompt(bbox=[200, 200, 300, 300])
# テキストプロンプト
ann = prompt_process.text_prompt(text='a photo of a dog')
# ポイントプロンプト
# pointsのデフォルトは [[0,0]] [[x1,y1],[x2,y2]]
# point_labelのデフォルトは [0] [1,0] 0:background, 1:foreground
ann = prompt_process.point_prompt(points=[[200, 200]], pointlabel=[1])
prompt_process.plot(annotations=ann, output='./')
```
=== "CLI"
```bash
# FastSAMモデルをロードし、それによってeverythingをセグメント化する
yolo segment predict model=FastSAM-s.pt source=path/to/bus.jpg imgsz=640
```
このスニペットは、事前学習済みモデルをロードし、イメージに対する予測を実行するシンプルさを示しています。
### 検証の使用方法
データセット上でモデルの検証を行うには、以下のようにします:
!!! Example "例"
=== "Python"
```python
from ultralytics import FastSAM
# FastSAMモデルを作成する
model = FastSAM('FastSAM-s.pt') # または FastSAM-x.pt
# モデルを検証する
results = model.val(data='coco8-seg.yaml')
```
=== "CLI"
```bash
# FastSAMモデルをロードし、COCO8の例のデータセットで検証するイメージサイズ640
yolo segment val model=FastSAM-s.pt data=coco8.yaml imgsz=640
```
FastSAMは、オブジェクトの検出とセグメンテーションを1つのクラスのオブジェクトに対してのみサポートしています。これは、すべてのオブジェクトを同じクラスとして認識し、セグメント化することを意味します。そのため、データセットを準備する際には、すべてのオブジェクトのカテゴリIDを0に変換する必要があります。
## FastSAM公式の使用方法
FastSAMは、[https://github.com/CASIA-IVA-Lab/FastSAM](https://github.com/CASIA-IVA-Lab/FastSAM)リポジトリから直接利用することもできます。以下は、FastSAMを使用するための一般的な手順の概要です。
### インストール
1. FastSAMリポジトリをクローンする
```shell
git clone https://github.com/CASIA-IVA-Lab/FastSAM.git
```
2. Python 3.9を使用したConda環境を作成してアクティベートする
```shell
conda create -n FastSAM python=3.9
conda activate FastSAM
```
3. クローンされたリポジトリに移動し、必要なパッケージをインストールする:
```shell
cd FastSAM
pip install -r requirements.txt
```
4. CLIPモデルをインストールする
```shell
pip install git+https://github.com/openai/CLIP.git
```
### 使用例
1. [モデルのチェックポイント](https://drive.google.com/file/d/1m1sjY4ihXBU1fZXdQ-Xdj-mDltW-2Rqv/view?usp=sharing)をダウンロードします。
2. FastSAMを推論に使用します。以下は実行例です
- 画像内のすべてをセグメント化する:
```shell
python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg
```
- テキストプロンプトを使用して特定のオブジェクトをセグメント化する:
```shell
python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --text_prompt "the yellow dog"
```
- バウンディングボックス内のオブジェクトをセグメント化するxywh形式でボックス座標を指定します
```shell
python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --box_prompt "[570,200,230,400]"
```
- 特定のポイントの近くにあるオブジェクトをセグメント化する:
```shell
python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --point_prompt "[[520,360],[620,300]]" --point_label "[1,0]"
```
さらに、FastSAMを[Colabデモ](https://colab.research.google.com/drive/1oX14f6IneGGw612WgVlAiy91UHwFAvr9?usp=sharing)や[HuggingFaceウェブデモ](https://huggingface.co/spaces/An-619/FastSAM)で試すこともできます。
## 引用と謝辞
FastSAMの著者には、リアルタイムインスタンスセグメンテーションの分野での重要な貢献を称えたいと思います。
!!! Quote ""
=== "BibTeX"
```bibtex
@misc{zhao2023fast,
title={Fast Segment Anything},
author={Xu Zhao and Wenchao Ding and Yongqi An and Yinglong Du and Tao Yu and Min Li and Ming Tang and Jinqiao Wang},
year={2023},
eprint={2306.12156},
archivePrefix={arXiv},
primaryClass={cs.CV}
}
```
FastSAMのオリジナルの論文は、[arXiv](https://arxiv.org/abs/2306.12156)で入手できます。著者は彼らの作品を広く公開し、コードベースは[GitHub](https://github.com/CASIA-IVA-Lab/FastSAM)でアクセスできるようにしています。私たちは、彼らがフィールドを進歩させ、その成果を広いコミュニティにアクセス可能にしてくれた彼らの努力に感謝しています。

View file

@ -1,94 +1,98 @@
---
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
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がサポートするモデル
Ultralyticsのモデルドキュメンテーションへようこそ![オブジェクト検出](../tasks/detect.md)、[インスタンスセグメンテーション](../tasks/segment.md)、[画像分類](../tasks/classify.md)、[ポーズ推定](../tasks/pose.md)、[マルチオブジェクトトラッキング](../modes/track.md)など、特定のタスクに適した幅広いモデルをサポートしています。Ultralyticsにあなたのモデルアーキテクチャを寄稿したい場合は、[コントリビューティングガイド](../../help/contributing.md)を確認してください。
Ultralyticsのモデルドキュメントへようこそ!我々は、[オブジェクト検出](../tasks/detect.md)、[インスタンスセグメンテーション](../tasks/segment.md)、[画像分類](../tasks/classify.md)、[ポーズ推定](../tasks/pose.md)、[多対象トラッキング](../modes/track.md)などの特定のタスクに特化した幅広いモデルのサポートを提供しています。Ultralyticsにあなたのモデルアーキテクチャを貢献したい場合は、[貢献ガイド](../../help/contributing.md)を確認してください。
!!! Note "ノート"
!!! 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)モデル。
1. **[YOLOv3](yolov3.md)**Joseph RedmonによるYOLOモデルファミリーの第三世代で、効率的なリアルタイムオブジェクト検出能力で知られています。
2. **[YOLOv4](yolov4.md)**2020年にAlexey BochkovskiyによってリリースされたYOLOv3のdarknetネイティブアップデートです
3. **[YOLOv5](yolov5.md)**UltralyticsによるYOLOアーキテクチャの改良版で、以前のバージョンと比較してパフォーマンスと速度のトレードオフが向上しています。
4. **[YOLOv6](yolov6.md)**2022年に[美団](https://about.meituan.com/)によってリリースされ、同社の多数の自動配送ロボットで使用されています。
5. **[YOLOv7](yolov7.md)**YOLOv4の著者によって2022年にリリースされたYOLOモデルのアップデートです
6. **[YOLOv8](yolov8.md) 新機能 🚀**YOLOファミリーの最新バージョンで、例えばインスタンスセグメンテーション、ポーズ/キーポイント推定、分類などの機能が強化されています。
7. **[Segment Anything Model (SAM)](sam.md)**MetaのSegment Anything Model (SAM)です。
8. **[Mobile Segment Anything Model (MobileSAM)](mobile-sam.md)**慶應義塾大学によるモバイルアプリケーションのためのMobileSAMです
9. **[Fast Segment Anything Model (FastSAM)](fast-sam.md)**中国科学院自動化研究所、画像及びビデオ解析グループのFastSAMです
10. **[YOLO-NAS](yolo-nas.md)**YOLO Neural Architecture Search (NAS)モデルです
11. **[Realtime Detection Transformers (RT-DETR)](rtdetr.md)**:百度の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"
title="YouTube動画プレイヤー" frameborder="0"
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
allowfullscreen>
</iframe>
<br>
<strong>視聴</strong> Ultralytics YOLOモデルを数行のコードで実行。
<strong>視聴:</strong> Ultralytics YOLOモデルをわずか数行のコードで実行します
</p>
## 入門:使用例
## Getting Started: 使用例
この例は、YOLOのトレーニングと推論の簡単な例を提供します。これらおよびその他の[モード](../modes/index.md)についての完全なドキュメントについては、[Predict](../modes/predict.md)、[Train](../modes/train.md)、[Val](../modes/val.md)、[Export](../modes/export.md)のドキュメントページを参照してください。
以下の例は、オブジェクト検出のためのYOLOv8 [Detect](../tasks/detect.md) モデルについてです。追加のサポートされるタスクについては、[Segment](../tasks/segment.md)、[Classify](../tasks/classify.md)、[Pose](../tasks/pose.md)のドキュメントを参照してください。
!!! Example "例"
=== "Python"
PyTorchの事前訓練済み`*.pt`モデルや設定`*.yaml`ファイルを`YOLO()`, `SAM()`, `NAS()`, `RTDETR()`クラスに渡して、Pythonでモデルインスタンスを生成できます:
PyTorchの事前訓練済み`*.pt`モデルや構成`*.yaml`ファイルは、`YOLO()``SAM()``NAS()``RTDETR()`クラスに渡して、Pythonでモデルインスタンスを作成することができます:
```python
from ultralytics import YOLO
# COCO事前訓練済みのYOLOv8nモデルをロード
# COCOで事前訓練されたYOLOv8nモデルをロードする
model = YOLO('yolov8n.pt')
# モデル情報の表示(オプション
# モデル情報を表示する(任意
model.info()
# COCO8の例示データセットでモデルを100エポック訓練
# モデルをCOCO8の例示データセットで100エポックトレーニングする
results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
# 'bus.jpg'画像上でYOLOv8nモデルによる推論実行
# 'bus.jpg'画像でYOLOv8nモデルを用いた推論を実行する
results = model('path/to/bus.jpg')
```
=== "CLI"
モデルを直接実行するためのCLIコマンドがあります:
モデルを直接実行するためのCLIコマンドが利用可能です:
```bash
# COCO事前訓練済みのYOLOv8nモデルをロードし、COCO8の例示データセットで100エポック訓練
# COCOで事前訓練されたYOLOv8nモデルをロードし、COCO8の例示データセットで100エポックトレーニングする
yolo train model=yolov8n.pt data=coco8.yaml epochs=100 imgsz=640
# COCO事前訓練済みのYOLOv8nモデルをロードし、'bus.jpg'画像で推論実行
# COCOで事前訓練されたYOLOv8nモデルをロードし、'bus.jpg'画像で推論実行する
yolo predict model=yolov8n.pt source=path/to/bus.jpg
```
## 新しいモデルの提供
## 新しいモデルの貢献
Ultralyticsにモデルを提供してみたいですか?素晴らしいことです!私たちは常にモデルのポートフォリオを拡大することに興味があります。
Ultralyticsにあなたのモデルを貢献することに興味がありますか?素晴らしいです!我々は常にモデルのポートフォリオを拡張することに興味があります。
1. **リポジトリをフォークする**[Ultralytics GitHubリポジトリ](https://github.com/ultralytics/ultralytics)をフォークして始めます。
1. **リポジトリをフォークする**[Ultralytics GitHubリポジトリ](https://github.com/ultralytics/ultralytics)をフォークすることから始めます。
2. **フォークをクローンする**:フォークをローカルマシンにクローンし、作業用の新しいブランチを作成します。
2. **あなたのフォークをクローンする**あなたのフォークをローカルマシンにクローンし、作業を行う新しいブランチを作成します。
3. **モデルを実装する**:提供されているコーディング規格とガイドラインに従ってモデルを追加します。
3. **あなたのモデルを実装する**[貢献ガイド](../../help/contributing.md)に示されているコーディング規格および指針に従ってモデルを追加します。
4. **徹底的にテストする**孤立してもパイプラインの一部としても、モデルを徹底的にテストしてください。
4. **徹底的にテストする**パイプラインの一部としてだけでなく、単独でモデルを厳密にテストすることを確認してください。
5. **プルリクエストを作成する**:モデルに満足したら、レビューのためにメインリポジトリへのプルリクエストを作成します。
5. **プルリクエストを作成する**:モデルに満足したら、レビューのために本リポジトリにプルリクエストを作成します。
6. **コードレビューとマージ**:レビュー後、モデルが私たちの基準を満たしている場合、メインリポジトリにマージされます。
6. **コードレビュー&マージ**:レビュー後、モデルが我々の基準を満たしている場合、本リポジトリにマージされます。
詳細な手順については、[コントリビューティングガイド](../../help/contributing.md)を参照してください。
詳細な手順については、[貢献ガイド](../../help/contributing.md)を参照してください。

View file

@ -0,0 +1,116 @@
---
comments: true
description: Ultralyticsフレームワーク内でMobileSAMをダウンロードしてテストする方法、MobileSAMの実装、オリジナルのSAMとの比較について詳しく知ることができます。今日からモバイルアプリケーションを改善しましょう。
keywords: MobileSAM, Ultralytics, SAM, モバイルアプリケーション, Arxiv, GPU, API, 画像エンコーダ, マスクデコーダ, モデルのダウンロード, テスト方法
---
![MobileSAM ロゴ](https://github.com/ChaoningZhang/MobileSAM/blob/master/assets/logo2.png?raw=true)
# Mobile Segment AnythingMobileSAM
MobileSAM論文が[arXiv](https://arxiv.org/pdf/2306.14289.pdf)で利用可能になりました。
CPU上で動作するMobileSAMのデモは、[こちらのデモリンク](https://huggingface.co/spaces/dhkim2810/MobileSAM)からアクセスできます。Mac i5 CPU上では、約3秒かかります。Hugging Faceのデモでは、インターフェースと低性能なCPUが遅い応答に寄与していますが、効果的に動作し続けます。
MobileSAMは、[Grounding-SAM](https://github.com/IDEA-Research/Grounded-Segment-Anything)、[AnyLabeling](https://github.com/vietanhdev/anylabeling)、および[Segment Anything in 3D](https://github.com/Jumpat/SegmentAnythingin3D)など、さまざまなプロジェクトで実装されています。
MobileSAMは、100kのデータセット元の画像の1%を単一のGPUで学習し、1日未満で訓練が完了します。このトレーニングのコードは将来公開される予定です。
## 利用可能なモデル、サポートされているタスク、および動作モード
この表は、利用可能なモデルとそれぞれの固有の事前学習重み、サポートされているタスク、および[予測](../modes/predict.md)、[検証](../modes/val.md)、[訓練](../modes/train.md)、および[エクスポート](../modes/export.md)のようなさまざまな動作モードに対する互換性を示しています。`✅`は対応しているモード、`❌`は対応していないモードを示しています。
| モデルタイプ | 事前学習重み | サポートされているタスク | 予測 | 検証 | 訓練 | エクスポート |
|-----------|-----------------|----------------------------------------|----|----|----|--------|
| MobileSAM | `mobile_sam.pt` | [インスタンスセグメンテーション](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ |
## SAMからMobileSAMへの移行
MobileSAMは、オリジナルのSAMと同じパイプラインを維持しているため、オリジナルの前処理、後処理、およびその他のインタフェースを組み込んでいます。そのため、現在オリジナルのSAMを使用している場合でも、MobileSAMへの移行は最小限の労力で行うことができます。
MobileSAMは、オリジナルのSAMと同等のパフォーマンスを発揮し、イメージエンコーダを変更することで同じパイプラインを保持しています。具体的には、元の重いViT-Hエンコーダ632Mをより小さいTiny-ViT5Mに置き換えています。単一のGPU上でMobileSAMは、おおよそ画像あたり12msで動作しますイメージエンコーダで8ms、マスクデコーダで4msです。
次の表は、ViTベースのイメージエンコーダの比較です
| イメージエンコーダ | オリジナルのSAM | MobileSAM |
|-----------|-----------|-----------|
| パラメーター | 611M | 5M |
| 速度 | 452ms | 8ms |
オリジナルのSAMとMobileSAMは、同じプロンプト誘導型マスクデコーダを使用しています
| マスクデコーダ | オリジナルのSAM | MobileSAM |
|---------|-----------|-----------|
| パラメーター | 3.876M | 3.876M |
| 速度 | 4ms | 4ms |
以下は、全体のパイプラインの比較です:
| パイプライン全体(エンコーダ+デコーダ) | オリジナルのSAM | MobileSAM |
|----------------------|-----------|-----------|
| パラメーター | 615M | 9.66M |
| 速度 | 456ms | 12ms |
MobileSAMとオリジナルのSAMのパフォーマンスは、ポイントとボックスをプロンプトとして使用した場合に示されます。
![ポイントをプロンプトにした画像](https://raw.githubusercontent.com/ChaoningZhang/MobileSAM/master/assets/mask_box.jpg?raw=true)
![ボックスをプロンプトにした画像](https://raw.githubusercontent.com/ChaoningZhang/MobileSAM/master/assets/mask_box.jpg?raw=true)
MobileSAMは、現在のFastSAMよりも約5倍小さく、約7倍高速です。詳細は[MobileSAMプロジェクトページ](https://github.com/ChaoningZhang/MobileSAM)でご覧いただけます。
## UltralyticsでのMobileSAMのテスト
オリジナルのSAMと同様に、ポイントとボックスのプロンプトの両方に対応したUltralyticsでの簡単なテスト方法を提供しています。
### モデルのダウンロード
モデルは[こちらからダウンロード](https://github.com/ChaoningZhang/MobileSAM/blob/master/weights/mobile_sam.pt)できます。
### ポイントプロンプト
!!! Example "例"
=== "Python"
```python
from ultralytics import SAM
# モデルをロード
model = SAM('mobile_sam.pt')
# ポイントプロンプトに基づいてセグメントを予測
model.predict('ultralytics/assets/zidane.jpg', points=[900, 370], labels=[1])
```
### ボックスプロンプト
!!! Example "例"
=== "Python"
```python
from ultralytics import SAM
# モデルをロード
model = SAM('mobile_sam.pt')
# ボックスプロンプトに基づいてセグメントを予測
model.predict('ultralytics/assets/zidane.jpg', bboxes=[439, 437, 524, 709])
```
`MobileSAM``SAM`は、同じAPIを使用して実装されています。詳細な使用方法については、[SAMページ](sam.md)をご覧ください。
## 引用と謝辞
MobileSAMが研究や開発のお役に立つ場合は、次の論文を引用していただけると幸いです
!!! Quote文 ""
=== "BibTeX"
```bibtex
@article{mobile_sam,
title={Faster Segment Anything: Towards Lightweight SAM for Mobile Applications},
author={Zhang, Chaoning and Han, Dongshen and Qiao, Yu and Kim, Jung Uk and Bae, Sung Ho and Lee, Seungkyu and Hong, Choong Seon},
journal={arXiv preprint arXiv:2306.14289},
year={2023}
}

93
docs/ja/models/rtdetr.md Normal file
View file

@ -0,0 +1,93 @@
---
comments: true
description: RT-DETRは、Baiduによって開発された、高速かつ高精度なリアルタイムオブジェクト検出器です。Vision TransformersViTの力を借りて、マルチスケールの特徴を効率的に処理します。RT-DETRは非常に適応性があり、再学習せずに異なるデコーダーレイヤーを使用して推論速度を柔軟に調整できます。このモデルは、TensorRTを使用したCUDAなどの高速エンドバックエンドで優れた性能を発揮し、多くの他のリアルタイムオブジェクト検出器を凌駕します。
keywords: RT-DETR, Baidu, Vision Transformers, object detection, real-time performance, CUDA, TensorRT, IoU-aware query selection, Ultralytics, Python API, PaddlePaddle
---
# BaiduのRT-DETR: Vision Transformerベースのリアルタイムオブジェクト検出器
## 概要
Baiduが開発したリアルタイム検出TransformerRT-DETRは、高い精度を維持しながらリアルタイム性能を提供する最先端のエンドツーエンドのオブジェクト検出器です。Vision TransformersViTの力を借りて、マルチスケールの特徴を効率的に処理することにより、RT-DETRは高い適応性を持ちます。再学習せずに異なるデコーダーレイヤーを使用して推論速度を柔軟に調整できるため、このモデルはTensorRTを使用したCUDAなどの高速バックエンドで多くの他のリアルタイムオブジェクト検出器を凌駕します。
![モデルの例](https://user-images.githubusercontent.com/26833433/238963168-90e8483f-90aa-4eb6-a5e1-0d408b23dd33.png)
**BaiduのRT-DETRの概要。** RT-DETRのモデルアーキテクチャダイアグラムでは、バックボーンの最後の3つのステージ{S3、S4、S5}がエンコーダーへの入力として表示されます。効率的なハイブリッドエンコーダーは、マルチスケールの特徴をイントラスケール特徴の相互作用AIFIとクロススケール特徴融合モジュールCCFMを介して画像特徴のシーケンスに変換します。IoU-awareクエリ選択は、デコーダーの初期オブジェクトクエリとして固定数の画像特徴を選択するために使用されます。最後に、デコーダーは補助予測ヘッドとともに、オブジェクトクエリを反復最適化してボックスと信頼スコアを生成します[出典](https://arxiv.org/pdf/2304.08069.pdf))。
### 主な特徴
- **効率的なハイブリッドエンコーダー:** BaiduのRT-DETRは、マルチスケールの特徴をイントラスケールの相互作用とクロススケールの融合を分離することで処理する効率的なハイブリッドエンコーダーを使用しています。このユニークなVision Transformersベースの設計により、計算コストを削減し、リアルタイムオブジェクト検出を実現しています。
- **IoU-awareクエリ選択** BaiduのRT-DETRは、IoU-awareクエリ選択を活用してオブジェクトクエリの初期化を改善します。これにより、モデルはシーン内の関連性の高いオブジェクトに焦点を当てて検出の精度を向上させることができます。
- **適応可能な推論速度:** BaiduのRT-DETRは、再学習せずに異なるデコーダーレイヤーを使用して推論速度を柔軟に調整することができます。この適応性により、さまざまなリアルタイムオブジェクト検出シナリオでの実用的な応用が容易になります。
## 事前学習済みモデル
Ultralytics Python APIは、異なるスケールの事前学習済みPaddlePaddle RT-DETRモデルを提供しています。
- RT-DETR-LCOCO val2017で53.0%のAP、T4 GPUで114 FPS
- RT-DETR-XCOCO val2017で54.8%のAP、T4 GPUで74 FPS
## 使用例
この例では、RT-DETRの訓練と推論の簡単な例を提供します。これらと他の[モード](../modes/index.md)の詳しいドキュメントについては、[Predict](../modes/predict.md)、[Train](../modes/train.md)、[Val](../modes/val.md)、および[Export](../modes/export.md)ドキュメントページを参照してください。
!!! Example "例"
=== "Python"
```python
from ultralytics import RTDETR
# COCOで事前学習済みのRT-DETR-lモデルをロードします
model = RTDETR('rtdetr-l.pt')
# モデル情報を表示します(オプション)
model.info()
# COCO8の例のデータセットでモデルを100エポックトレーニングします
results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
# 'bus.jpg'画像でRT-DETR-lモデルで推論を実行します
results = model('path/to/bus.jpg')
```
=== "CLI"
```bash
# COCOで事前学習済みのRT-DETR-lモデルをロードし、COCO8の例のデータセットで100エポックトレーニングします
yolo train model=rtdetr-l.pt data=coco8.yaml epochs=100 imgsz=640
# COCOで事前学習済みのRT-DETR-lモデルをロードし、'bus.jpg'画像で推論を実行します
yolo predict model=rtdetr-l.pt source=path/to/bus.jpg
```
## サポートされているタスクとモード
この表には、各モデルがサポートするタスク、特定の事前学習済み重み、およびサポートされるさまざまなモード([Train](../modes/train.md)、[Val](../modes/val.md)、[Predict](../modes/predict.md)、[Export](../modes/export.md))が✅絵文字で示されている情報が示されています。
| モデルの種類 | 事前学習済み重み | サポートされるタスク | 推論 | 検証 | 訓練 | エクスポート |
|---------------------|---------------|--------------------------------|----|----|----|--------|
| RT-DETR Large | `rtdetr-l.pt` | [オブジェクト検出](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
| RT-DETR Extra-Large | `rtdetr-x.pt` | [オブジェクト検出](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
## 引用と謝辞
研究や開発の中でBaiduのRT-DETRを使用する場合は、[元の論文](https://arxiv.org/abs/2304.08069)を引用してください。
!!! Quote ""
=== "BibTeX"
```bibtex
@misc{lv2023detrs,
title={DETRs Beat YOLOs on Real-time Object Detection},
author={Wenyu Lv and Shangliang Xu and Yian Zhao and Guanzhong Wang and Jinman Wei and Cheng Cui and Yuning Du and Qingqing Dang and Yi Liu},
year={2023},
eprint={2304.08069},
archivePrefix={arXiv},
primaryClass={cs.CV}
}
```
私たちは、Baiduと[PaddlePaddle](https://github.com/PaddlePaddle/PaddleDetection)チームに、コンピュータビジョンコミュニティ向けのこの貴重なリソースを作成しメンテナンスしていただいたことに感謝いたします。Vision Transformersベースのリアルタイムオブジェクト検出器であるRT-DETRの開発による、彼らのフィールドへの貢献は非常に評価されています。
*Keywords: RT-DETR, Transformer, ViT, Vision Transformers, Baidu RT-DETR, PaddlePaddle, Paddle Paddle RT-DETR, real-time object detection, Vision Transformers-based object detection, pre-trained PaddlePaddle RT-DETR models, Baidu's RT-DETR usage, Ultralytics Python API*

226
docs/ja/models/sam.md Normal file
View file

@ -0,0 +1,226 @@
---
comments: true
description: リアルタイムの画像セグメンテーションを可能にするウルトラリティクスの最先端Segment Anything Model (SAM)を紹介します。SAMのプロンプト可能なセグメンテーション、ゼロショットパフォーマンス、使用方法について学びましょう。
keywords: Ultralytics, 画像セグメンテーション, Segment Anything Model, SAM, SA-1B データセット, リアルタイムパフォーマンス, ゼロショット転送, 物体検出, 画像解析, 機械学習
---
# Segment Anything Model (SAM)
ウルトラリティクスのSegment Anything ModelSAMへようこそ。この革新的なモデルは、プロンプト可能な画像セグメンテーションを実現し、リアルタイムのパフォーマンスで画期的な成果を上げ、この分野で新たな基準を設定しました。
## SAMの紹介: Segment Anything Model
Segment Anything ModelSAMは、画像解析タスクにおける柔軟なセグメンテーションを可能にする最先端の画像セグメンテーションモデルです。SAMは、セグメンテーションという新しいモデル、タスク、データセットを導入した画期的なプロジェクト「Segment Anything」の中核をなしています。
SAMの高度な設計により、新しい画像分布やタスクに事前の知識なしで適応するゼロショット転送の機能を持っています。豊富な[SA-1B データセット](https://ai.facebook.com/datasets/segment-anything/)でトレーニングされたSAMは、1億以上のマスクを含む1,100万枚以上の厳選された画像に広がる自動的にアテーションされたセグメンテーションマスクを備えており、多くの場合、前向きに監督された結果を上回る卓越したゼロショットパフォーマンスを発揮しています。
![データセットサンプルイメージ](https://user-images.githubusercontent.com/26833433/238056229-0e8ffbeb-f81a-477e-a490-aff3d82fd8ce.jpg)
新たに導入されたSA-1Bデータセットからガイドマスクを重畳した例の画像です。SA-1Bには、多様な高解像度のライセンス画像と11億件以上の高品質のセグメンテーションマスクが含まれています。これらのマスクは、SAMによって完全自動的に注釈付けされ、人間の評価と数多くの実験で高品質と多様性が確認されています。画像は可視化のために画像あたりのマスクの数でグループ化されています平均でおおよそ100個のマスクがあります
## Segment Anything Model (SAM)の主な特徴
- **プロンプト可能なセグメンテーションタスク:** SAMは、プロンプトオブジェクトを特定する空間的なまたはテキスト的な手がかりから有効なセグメンテーションマスクを生成するように設計されています。
- **高度なアーキテクチャ:** Segment Anything Modelは、強力な画像エンコーダ、プロンプトエンコーダ、軽量のマスクデコーダを採用しています。このユニークなアーキテクチャにより、柔軟なプロンプティング、リアルタイムのマスク計算、セグメンテーションタスクの曖昧さの認識が可能です。
- **SA-1Bデータセット:** Segment Anythingプロジェクトによって導入されたSA-1Bデータセットは、1,100万枚以上の画像に1,000,000,000件以上のマスクを提供します。これまでで最も大規模なセグメンテーションデータセットであり、SAMに多様で大規模なトレーニングデータソースを提供します。
- **ゼロショットパフォーマンス:** SAMは、さまざまなセグメンテーションタスクで優れたゼロショットパフォーマンスを発揮し、プロンプトエンジニアリングの最小限の必要性で多様なアプリケーションに即座に使用できるツールとなります。
Segment Anything ModelおよびSA-1Bデータセットの詳細については、[Segment Anything website](https://segment-anything.com)をご覧いただくか、研究論文[Segment Anything](https://arxiv.org/abs/2304.02643)をご覧ください。
## 使用可能なモデル、サポートされるタスク、および動作モード
このテーブルでは、使用可能なモデルとその特定の事前トレーニング済み重み、サポートされているタスク、およびInference、Validation、Training、Exportなどのさまざまな操作モードに対する互換性を示しています。サポートされるモードは✅の絵文字で表示され、サポートされていないモードは❌の絵文字で表示されます。
| モデルの種類 | 事前トレーニング済みの重み | サポートされているタスク | Inference | Validation | Training | Export |
|-----------|---------------|---------------------------------------------------------------|-----------|------------|----------|--------|
| SAM base | `sam_b.pt` | [Instance Segmentationインスタンスセグメンテーション](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ |
| SAM large | `sam_l.pt` | [Instance Segmentationインスタンスセグメンテーション](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ |
## SAMの使用方法: 画像セグメンテーションにおける柔軟性とパワー
Segment Anything Modelは、トレーニングデータを超えた多くのダウンストリームタスクに使用することができます。これにはエッジ検出、オブジェクトの提案生成、インスタンスセグメンテーション、および予備的なテキストからマスクへの予測などが含まれます。プロンプトエンジニアリングを使用することで、SAMはゼロショットの方法で新しいタスクとデータ分布にすばやく適応することができ、あらゆる画像セグメンテーションに関する柔軟で強力なツールとなります。
### SAMの予測の例
!!! Example "プロンプトでセグメントする"
与えられたプロンプトで画像をセグメンテーションします。
=== "Python"
```python
from ultralytics import SAM
# モデルをロード
model = SAM('sam_b.pt')
# モデル情報を表示(オプション)
model.info()
# バウンディングボックスのプロンプトで予測を実行
model('ultralytics/assets/zidane.jpg', bboxes=[439, 437, 524, 709])
# ポイントのプロンプトで予測を実行
model('ultralytics/assets/zidane.jpg', points=[900, 370], labels=[1])
```
!!! Example "すべてをセグメントする"
画像全体をセグメンテーションします。
=== "Python"
```python
from ultralytics import SAM
# モデルをロード
model = SAM('sam_b.pt')
# モデル情報を表示(オプション)
model.info()
# 予測を実行
model('path/to/image.jpg')
```
=== "CLI"
```bash
# SAMモデルで予測を実行
yolo predict model=sam_b.pt source=path/to/image.jpg
```
- ここでは、プロンプト(バウンディングボックス/ポイント/マスク)を指定しない場合は、画像全体がセグメンテーションされるロジックです。
!!! Example "SAMPredictorの例"
画像を一度設定し、イメージエンコーダを複数回実行することなく複数回プロンプト推論を実行できます。
=== "プロンプト推論"
```python
from ultralytics.models.sam import Predictor as SAMPredictor
# SAMPredictorを作成
overrides = dict(conf=0.25, task='segment', mode='predict', imgsz=1024, model="mobile_sam.pt")
predictor = SAMPredictor(overrides=overrides)
# イメージを設定する
predictor.set_image("ultralytics/assets/zidane.jpg") # 画像ファイルで設定する
predictor.set_image(cv2.imread("ultralytics/assets/zidane.jpg")) # np.ndarrayで設定する
results = predictor(bboxes=[439, 437, 524, 709])
results = predictor(points=[900, 370], labels=[1])
# イメージをリセットする
predictor.reset_image()
```
追加の引数を指定してすべてのセグメントを設定します。
=== "すべてをセグメントする"
```python
from ultralytics.models.sam import Predictor as SAMPredictor
# SAMPredictorを作成
overrides = dict(conf=0.25, task='segment', mode='predict', imgsz=1024, model="mobile_sam.pt")
predictor = SAMPredictor(overrides=overrides)
# 追加の引数でセグメント
results = predictor(source="ultralytics/assets/zidane.jpg", crop_n_layers=1, points_stride=64)
```
- `すべてをセグメントする` のための追加の引数の詳細は、[`Predictor/generate` リファレンス](../../reference/models/sam/predict.md)を参照してください。
## YOLOv8とのSAM比較
ここでは、Metaの最小のSAMモデルであるSAM-bと、Ultralyticsの最小のセグメンテーションモデルである[YOLOv8n-seg](../tasks/segment.md)とを比較します。
| モデル | サイズ | パラメータ数 | スピードCPU |
|------------------------------------------------|-----------------------|----------------------|-----------------------|
| MetaのSAM-b | 358 MB | 94.7 M | 51096 ms/im |
| [MobileSAM](mobile-sam.md) | 40.7 MB | 10.1 M | 46122 ms/im |
| [FastSAM-s](fast-sam.md) with YOLOv8 backbone | 23.7 MB | 11.8 M | 115 ms/im |
| Ultralytics [YOLOv8n-seg](../tasks/segment.md) | **6.7 MB** (53.4倍小さい) | **3.4 M** (27.9倍少ない) | **59 ms/im** (866倍速い) |
この比較では、モデルのサイズとスピードの桁違いの違いが示されています。SAMは自動セグメンテーションのユニークな機能を提供しますが、より小さい、より速く、より効率的なYOLOv8セグメントモデルとは競合しません。
テストは、2023年製のApple M2 Macbook、16GBのRAMで実行されました。このテストを再現するには:
!!! Example "例"
=== "Python"
```python
from ultralytics import FastSAM, SAM, YOLO
# SAM-bのプロファイリング
model = SAM('sam_b.pt')
model.info()
model('ultralytics/assets')
# MobileSAMのプロファイリング
model = SAM('mobile_sam.pt')
model.info()
model('ultralytics/assets')
# FastSAM-sのプロファイリング
model = FastSAM('FastSAM-s.pt')
model.info()
model('ultralytics/assets')
# YOLOv8n-segのプロファイリング
model = YOLO('yolov8n-seg.pt')
model.info()
model('ultralytics/assets')
```
## オートアノテーション: セグメンテーションデータセットの迅速な作成方法
オートアテーションは、SAMの主要な機能の一つであり、事前トレーニング済みの検出モデルを使用して[セグメンテーションデータセット](https://docs.ultralytics.com/datasets/segment)を生成することができます。この機能により、時間のかかる手作業のラベリング作業を回避し、大量の画像の迅速かつ正確な注釈付けが可能になります。
### ディテクションモデルを使用したセグメンテーションデータセットの生成
Ultralyticsフレームワークを使用してデータセットをオートアテーションするには、以下のように`auto_annotate`関数を使用します:
!!! Example "例"
=== "Python"
```python
from ultralytics.data.annotator import auto_annotate
auto_annotate(data="path/to/images", det_model="yolov8x.pt", sam_model='sam_b.pt')
```
| 引数 | タイプ | 説明 | デフォルト |
|------------|------------------|--------------------------------------------------------------|--------------|
| data | str | 注釈を付ける画像が含まれるフォルダへのパス。 | |
| det_model | str, オプション | 事前トレーニング済みのYOLO検出モデル。デフォルトは'yolov8x.pt'。 | 'yolov8x.pt' |
| sam_model | str, オプション | 事前トレーニング済みのSAMセグメンテーションモデル。デフォルトは'sam_b.pt'。 | 'sam_b.pt' |
| device | str, オプション | モデルを実行するデバイス。デフォルトは空の文字列CPUまたはGPUが利用可能な場合。 | |
| output_dir | str, None, オプション | 注釈付け結果を保存するディレクトリ。デフォルトは、'data'と同じディレクトリ内の 'labels' フォルダーです。 | None |
`auto_annotate`関数は、画像へのパス、任意の事前トレーニング済みの検出およびSAMセグメンテーションモデル、モデルを実行するデバイス、および注釈付け結果を保存する出力ディレクトリを指定するためのオプション引数を取ります。
事前トレーニング済みモデルを使用したオートアノテーションにより、高品質なセグメンテーションデータセットを作成するための時間と労力を大幅に節約することができます。この機能は、大量の画像コレクションに取り組んでいる研究者や開発者にとって特に有益であり、モデルの開発と評価に集中することができます。
## 引用と謝辞
SAMが研究や開発の場で役立つ場合は、引用にご協力いただけると幸いです。
!!! Quote ""
=== "BibTeX"
```bibtex
@misc{kirillov2023segment,
title={Segment Anything},
author={Alexander Kirillov and Eric Mintun and Nikhila Ravi and Hanzi Mao and Chloe Rolland and Laura Gustafson and Tete Xiao and Spencer Whitehead and Alexander C. Berg and Wan-Yen Lo and Piotr Dollár and Ross Girshick},
year={2023},
eprint={2304.02643},
archivePrefix={arXiv},
primaryClass={cs.CV}
}
```
この貴重なコンピュータビジョンコミュニティ向けのリソースを作成および維持してくれたMeta AIに感謝の意を表します。
*keywords: Segment Anything, Segment Anything Model, SAM, Meta SAM, 画像セグメンテーション, プロンプト可能なセグメンテーション, ゼロショットパフォーマンス, SA-1B データセット, 先進のアーキテクチャ, オートアノテーション, Ultralytics, 事前トレーニング済みモデル, SAM base, SAM large, インスタンスセグメンテーション, コンピュータビジョン, AI, 人工知能, 機械学習, データアノテーション, セグメンテーションマスク, ディテクションモデル, YOLOディテクションモデル, bibtex, Meta AI.*

121
docs/ja/models/yolo-nas.md Normal file
View file

@ -0,0 +1,121 @@
---
comments: true
description: YOLO-NASは、優れた物体検出モデルです。その機能、事前学習モデル、Ultralytics Python APIの使用法などについて詳しく説明します。
keywords: YOLO-NAS, Deci AI, 物体検出, 深層学習, ニューラルアーキテクチャ検索, Ultralytics Python API, YOLOモデル, 事前学習モデル, 量子化, 最適化, COCO, Objects365, Roboflow 100
---
# YOLO-NAS
## 概要
Deci AIによって開発されたYOLO-NASは、画期的な物体検出ベースモデルです。従来のYOLOモデルの制約に対処するための高度なニューラルアーキテクチャ検索技術によって生み出されています。量子化のサポートと精度とレイテンシのトレードオフの改善により、YOLO-NASは物体検出において大きな進歩を遂げています。
![モデルの例の画像](https://learnopencv.com/wp-content/uploads/2023/05/yolo-nas_COCO_map_metrics.png)
**YOLO-NASの概要。** YOLO-NASは、量子化対応のブロックと選択的量子化を使用して最適なパフォーマンスを実現します。モデルをINT8で量子化すると、他のモデルよりも精度がほとんど低下せずに最適なパフォーマンスが得られます。これらの進歩により、前例のない物体検出能力と優れたパフォーマンスを備えた優れたアーキテクチャが実現されます。
### 主な特徴
- **量子化フレンドリーな基本ブロック:** YOLO-NASは、従来のYOLOモデルの制約の1つである量子化に対応した新しい基本ブロックを導入しています。
- **洗練されたトレーニングと量子化:** YOLO-NASは、高度なトレーニングスキームとポストトレーニング量子化を活用してパフォーマンスを向上させています。
- **AutoNAC最適化と事前学習:** YOLO-NASはAutoNAC最適化を利用し、COCO、Objects365、Roboflow 100などの注目されるデータセットで事前学習されています。この事前学習により、製品環境での下流物体検出タスクに非常に適しています。
## 事前学習モデル
Ultralyticsが提供する事前学習済みのYOLO-NASモデルを使用して、次世代の物体検出のパワーを体験してください。これらのモデルは、速度と精度の両方の面で優れたパフォーマンスを提供するように設計されています。特定のニーズに合わせてさまざまなオプションから選択できます。
| モデル | mAP | レイテンシ (ms) |
|------------------|-------|------------|
| YOLO-NAS S | 47.5 | 3.21 |
| YOLO-NAS M | 51.55 | 5.85 |
| YOLO-NAS L | 52.22 | 7.87 |
| YOLO-NAS S INT-8 | 47.03 | 2.36 |
| YOLO-NAS M INT-8 | 51.0 | 3.78 |
| YOLO-NAS L INT-8 | 52.1 | 4.78 |
各モデルのバリエーションは、Mean Average PrecisionmAPとレイテンシのバランスを取り、パフォーマンスとスピードの両方に最適化されています。
## 使用例
Ultralyticsの`ultralytics` Pythonパッケージを使用して、YOLO-NASモデルをPythonアプリケーションに簡単に統合できるようにしました。このパッケージは、プロセスをスムーズにするユーザーフレンドリーなPython APIを提供します。
次の例では、推論と検証のために`ultralytics`パッケージを使用してYOLO-NASモデルをどのように使用するかを示しています。
### 推論と検証の例
この例では、COCO8データセットでYOLO-NAS-sを検証します。
!!! Example "例"
この例では、YOLO-NASの推論と検証のためのシンプルなコードを提供しています。推論結果の処理については、[Predict](../modes/predict.md)モードを参照してください。他のモードでYOLO-NASを使用する方法については、[Val](../modes/val.md)および[Export](../modes/export.md)を参照してください。`ultralytics`パッケージのYOLO-NASはトレーニングをサポートしていません。
=== "Python"
Pythonで、PyTorchの事前学習済みの`*.pt`モデルファイルを`NAS()`クラスに渡すことで、モデルのインスタンスを作成できます:
```python
from ultralytics import NAS
# COCO事前学習済みのYOLO-NAS-sモデルをロード
model = NAS('yolo_nas_s.pt')
# モデル情報の表示(オプション)
model.info()
# COCO8の例データセットでモデルを検証
results = model.val(data='coco8.yaml')
# 'bus.jpg'画像上でYOLO-NAS-sモデルを使用した推論
results = model('path/to/bus.jpg')
```
=== "CLI"
モデルを直接実行するためのCLIコマンドもあります:
```bash
# COCO事前学習済みのYOLO-NAS-sモデルをロードし、COCO8の例データセットでパフォーマンスを検証
yolo val model=yolo_nas_s.pt data=coco8.yaml
# COCO事前学習済みのYOLO-NAS-sモデルをロードし、'bus.jpg'画像上で推論を実行
yolo predict model=yolo_nas_s.pt source=path/to/bus.jpg
```
## サポートされているタスクとモード
YOLO-NASモデルは、Smalls、Mediumm、Largelの3つのバリエーションを提供しています。各バリエーションは、異なる計算リソースとパフォーマンスのニーズに対応するように設計されています:
- **YOLO-NAS-s:** 計算リソースが限られている環境で効率が重要な場合に最適化されています。
- **YOLO-NAS-m:** 幅広い一般的な物体検出のニーズに適したバランスの取れたアプローチです。
- **YOLO-NAS-l:** 計算リソースの制約が少ない最高の精度が求められるシナリオに対応しています。
以下は、各モデルの詳細な概要であり、それらの事前学習済み重みへのリンク、サポートされるタスク、さまざまな動作モードとの互換性が示されています。
| モデルの種類 | 事前学習済みの重み | サポートされるタスク | 推論 | 検証 | トレーニング | エクスポート |
|------------|-----------------------------------------------------------------------------------------------|----------------------------|----|----|--------|--------|
| YOLO-NAS-s | [yolo_nas_s.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolo_nas_s.pt) | [物体検出](../tasks/detect.md) | ✅ | ✅ | ❌ | ✅ |
| YOLO-NAS-m | [yolo_nas_m.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolo_nas_m.pt) | [物体検出](../tasks/detect.md) | ✅ | ✅ | ❌ | ✅ |
| YOLO-NAS-l | [yolo_nas_l.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolo_nas_l.pt) | [物体検出](../tasks/detect.md) | ✅ | ✅ | ❌ | ✅ |
## 引用と謝辞
研究や開発の中でYOLO-NASを使用する場合は、SuperGradientsを引用してください:
!!! Quote ""
=== "BibTeX"
```bibtex
@misc{supergradients,
doi = {10.5281/ZENODO.7789328},
url = {https://zenodo.org/record/7789328},
author = {Aharon, Shay and {Louis-Dupont} and {Ofri Masad} and Yurkova, Kate and {Lotem Fridman} and {Lkdci} and Khvedchenya, Eugene and Rubin, Ran and Bagrov, Natan and Tymchenko, Borys and Keren, Tomer and Zhilko, Alexander and {Eran-Deci}},
title = {Super-Gradients},
publisher = {GitHub},
journal = {GitHub repository},
year = {2021},
}
```
このコンピュータビジョンコミュニティ向けの貴重なリソースを作成および維持するために、Deci AIの[SuperGradients](https://github.com/Deci-AI/super-gradients/)チームに感謝の意を表します。革新的なアーキテクチャと優れた物体検出能力を持つYOLO-NASが、開発者や研究者の重要なツールになると信じています。
*keywords: YOLO-NAS, Deci AI, 物体検出, 深層学習, ニューラルアーキテクチャ検索, Ultralytics Python API, YOLOモデル, SuperGradients, 事前学習モデル, 量子化フレンドリーな基本ブロック, 高度なトレーニングスキーム, ポストトレーニング量子化, AutoNAC最適化, COCO, Objects365, Roboflow 100*

98
docs/ja/models/yolov3.md Normal file
View file

@ -0,0 +1,98 @@
---
comments: true
description: YOLOv3、YOLOv3-Ultralytics、およびYOLOv3uの概要を把握してください。オブジェクト検出に対するこれらのモデルの主な特徴、使用方法、およびサポートされるタスクについて学びます。
keywords: YOLOv3, YOLOv3-Ultralytics, YOLOv3u, オブジェクト検出, 推論, トレーニング, Ultralytics
---
# YOLOv3、YOLOv3-Ultralytics、およびYOLOv3u
## 概要
このドキュメントでは、[YOLOv3](https://pjreddie.com/darknet/yolo/)、[YOLOv3-Ultralytics](https://github.com/ultralytics/yolov3)、および[YOLOv3u](https://github.com/ultralytics/ultralytics)という3つの関連するオブジェクト検出モデルについて概説します。
1. **YOLOv3:** これはYou Only Look Once (YOLO) オブジェクト検出アルゴリズムの3番目のバージョンです。Joseph Redmonによって最初に開発されたYOLOv3は、マルチスケール予測や3つの異なるサイズの検出カーネルなど、さまざまな機能を導入し、前バージョンよりも性能を向上させました。
2. **YOLOv3-Ultralytics:** これはUltralyticsによるYOLOv3モデルの実装です。オリジナルのYOLOv3アーキテクチャを再現し、より多くの事前学習済みモデルのサポートや簡単なカスタマイズオプションなど、追加の機能を提供します。
3. **YOLOv3u:** これはYOLOv8モデルで使用されるアンカーフリーでオブジェクトネスフリーなスプリットヘッドを組み込んだYOLOv3-Ultralyticsの更新版です。YOLOv3uは、YOLOv3と同じバックボーンとネックアーキテクチャを保持しながら、YOLOv8の更新された検出ヘッドを備えています。
![Ultralytics YOLOv3](https://raw.githubusercontent.com/ultralytics/assets/main/yolov3/banner-yolov3.png)
## 主な特徴
- **YOLOv3:** 3つの異なる検出スケールを使用し、13x13、26x26、および52x52の3つの異なるサイズの検出カーネルを活用しました。これにより、さまざまなサイズのオブジェクトの検出精度が大幅に向上しました。さらに、YOLOv3では各バウンディングボックスの複数のラベル予測や、より良い特徴抽出ネットワークなどの機能が追加されました。
- **YOLOv3-Ultralytics:** UltralyticsのYOLOv3の実装は、オリジナルのモデルと同じ性能を提供しながら、より多くの事前学習済みモデルのサポート、追加のトレーニング方法、および簡単なカスタマイズオプションを提供します。これにより、実用的なアプリケーションにおいてより柔軟で使いやすくなります。
- **YOLOv3u:** この更新されたモデルは、YOLOv8から使用されているアンカーフリーでオブジェクトネスフリーなスプリットヘッドを組み込んでいます。事前定義されたアンカーボックスとオブジェクトネススコアの必要性を排除することで、この検出ヘッドの設計は、さまざまなサイズや形状のオブジェクトの検出能力を向上させることができます。これにより、YOLOv3uはオブジェクト検出タスクにおいてより堅牢で正確なモデルとなります。
## サポートされるタスクとモード
YOLOv3シリーズ、YOLOv3、YOLOv3-Ultralytics、およびYOLOv3uは、オブジェクト検出タスクに特化して設計されています。これらのモデルは、精度と速度のバランスを取りながらさまざまな実世界のシナリオでの効果が高いことで知られています。各バリアントはユニークな機能と最適化を提供し、さまざまなアプリケーションに適しています。
3つのモデルは[推論](../modes/predict.md)、[検証](../modes/val.md)、[トレーニング](../modes/train.md)、および[エクスポート](../modes/export.md)など、幅広いモードをサポートしており、効果的なオブジェクト検出のための完全なツールキットを提供します。
| モデルの種類 | サポートされるタスク | 推論 | 検証 | トレーニング | エクスポート |
|--------------------|--------------------------------|----|----|--------|--------|
| YOLOv3 | [オブジェクト検出](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
| YOLOv3-Ultralytics | [オブジェクト検出](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
| YOLOv3u | [オブジェクト検出](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
この表は、各YOLOv3バリアントの機能を一目で把握するためのもので、オブジェクト検出ワークフローのさまざまなタスクと操作モードに対する多様性と適用性を強調しています。
## 使用例
この例では、YOLOv3の簡単なトレーニングおよび推論の例を提供します。これらおよびその他の[モード](../modes/index.md)の完全なドキュメンテーションについては、[Predict](../modes/predict.md)、[Train](../modes/train.md)、[Val](../modes/val.md)、および[Export](../modes/export.md)のドキュメントページを参照してください。
!!! Example "例"
=== "Python"
PyTorchの事前学習済み `*.pt` モデルと設定 `*.yaml` ファイルは、`YOLO()` クラスに渡してモデルインスタンスを作成できます。
```python
from ultralytics import YOLO
# COCOで学習済みのYOLOv3nモデルをロード
model = YOLO('yolov3n.pt')
# モデル情報の表示(任意)
model.info()
# COCO8のサンプルデータセットでモデルを100エポックトレーニング
results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
# YOLOv3nモデルで'bus.jpg'画像に対して推論実行
results = model('path/to/bus.jpg')
```
=== "CLI"
CLIコマンドを使用して直接モデルを実行できます。
```bash
# COCOで学習済みのYOLOv3nモデルをロードし、COCO8のサンプルデータセットで100エポックトレーニング
yolo train model=yolov3n.pt data=coco8.yaml epochs=100 imgsz=640
# COCOで学習済みのYOLOv3nモデルをロードし、'bus.jpg'画像に対して推論実行
yolo predict model=yolov3n.pt source=path/to/bus.jpg
```
## 引用と謝辞
研究でYOLOv3を使用する場合は、元のYOLO論文とUltralyticsのYOLOv3リポジトリを引用してください。
!!! Quote ""
=== "BibTeX"
```bibtex
@article{redmon2018yolov3,
title={YOLOv3: An Incremental Improvement},
author={Redmon, Joseph and Farhadi, Ali},
journal={arXiv preprint arXiv:1804.02767},
year={2018}
}
```
Joseph RedmonとAli Farhadiには、オリジナルのYOLOv3を開発していただいたことに感謝します。

71
docs/ja/models/yolov4.md Normal file
View file

@ -0,0 +1,71 @@
---
comments: true
description: YOLOv4は、2020年にAlexey Bochkovskiyによってリリースされた最先端のリアルタイムオブジェクト検出器に関する詳細なガイドをご覧ください。そのアーキテクチャのハイライト、革新的な機能、および応用例を理解してください。
keywords: ultralytics、YOLOv4、オブジェクト検出、ニューラルネットワーク、リアルタイム検出、オブジェクト検出器、機械学習
---
# YOLOv4: 高速で正確なオブジェクト検出
YOLOv4のUltralyticsドキュメンテーションページへようこそ。YOLOv4は、2020年にAlexey Bochkovskiyによってリリースされた最先端のリアルタイムオブジェクト検出器です。速度と精度の最適なバランスを提供するよう設計されており、さまざまなアプリケーションに優れた選択肢です。
![YOLOv4アーキテクチャ図](https://user-images.githubusercontent.com/26833433/246185689-530b7fe8-737b-4bb0-b5dd-de10ef5aface.png)
**YOLOv4アーキテクチャ図**。YOLOv4の複雑なネットワーク設計を示しており、最適なリアルタイムオブジェクト検出のためのバックボーン、ネック、およびヘッドコンポーネント、およびそれらの相互接続されたレイヤーが表示されています。
## 導入
YOLOv4は、You Only Look Once version 4の略で、[YOLOv3](yolov3.md)や他のオブジェクト検出モデルなど、以前のYOLOバージョンの制約に対処するために開発されたリアルタイムオブジェクト検出モデルです。他の畳み込みニューラルネットワークCNNベースのオブジェクト検出器とは異なり、YOLOv4は推薦システムだけでなく、スタンドアロンのプロセス管理や人間の入力削減にも適用可能です。従来のグラフィックスプロセッシングユニットGPU上での動作は、手ごろな価格で大量の使用が可能であり、トレーニングには1つのGPUのみが必要です。
## アーキテクチャ
YOLOv4は、パフォーマンスの最適化に一緒に機能するいくつかの革新的な機能を利用しています。これには、Weighted-Residual-ConnectionsWRC、Cross-Stage-Partial-connectionsCSP、Cross mini-Batch NormalizationCmBN、Self-adversarial-trainingSAT、Mish-activation、Mosaic data augmentation、DropBlock regularization、およびCIoU lossが含まれます。これらの機能は組み合わせて、最先端の結果を達成するために使用されます。
典型的なオブジェクト検出器は、入力、バックボーン、ネック、そしてヘッドの複数の部分で構成されています。YOLOv4のバックボーンはImageNetで事前にトレーニングされ、オブジェクトのクラスと境界ボックスを予測するために使用されます。バックボーンはVGG、ResNet、ResNeXt、またはDenseNetなどの複数のモデルから選択できます。ディテクターのネック部分は、異なるステージからの特徴マップを収集するために使用され、通常、複数のボトムアップパスと複数のトップダウンパスが含まれます。ヘッド部分は、最終的なオブジェクトの検出と分類に使用されます。
## フリービーのバッグ
YOLOv4は、「フリービーのバッグ」として知られる手法も使用しており、これは推論のコストを増やさずにモデルの精度を向上させる技術です。データ拡張は、オブジェクト検出で使用される一般的なフリービーのバッグの技術の一つであり、入力画像の変動性を増加させることでモデルの堅牢性を向上させます。データ拡張の例には、光度の歪み画像の明るさ、コントラスト、色調、彩度、イズの調整や幾何学的歪みランダムなスケーリング、クロッピング、反転、回転の追加があります。これらの技術は、モデルが異なる種類の画像に対してより良い一般化をするのに役立ちます。
## 機能と性能
YOLOv4は、オブジェクト検出の最適な速度と精度を目指して設計されています。YOLOv4のアーキテクチャには、バックボーンとしてCSPDarknet53、ネックとしてPANet、検出ヘッドとしてYOLOv3が含まれています。この設計により、YOLOv4は印象的な速度でオブジェクト検出を実行できるため、リアルタイムアプリケーションに適しています。YOLOv4は精度でも優れており、オブジェクト検出のベンチマークで最先端の結果を達成しています。
## 使用例
現時点では、Ultralyticsは現在、YOLOv4モデルをサポートしていません。そのため、YOLOv4を使用したいユーザーは、インストールおよび使用方法に関する情報は直接YOLOv4のGitHubリポジトリを参照する必要があります。
ここでは、YOLOv4を使用するための一般的な手順の概要を示します。
1. YOLOv4のGitHubリポジトリにアクセスします: [https://github.com/AlexeyAB/darknet](https://github.com/AlexeyAB/darknet).
2. インストールのためにREADMEファイルに記載されている指示に従います。一般的には、リポジトリのクローン、必要な依存関係のインストール、および必要な環境変数のセットアップが含まれます。
3. インストールが完了したら、データセットの準備、モデルパラメータの設定、モデルのトレーニング、トレーニングされたモデルを使用してオブジェクト検出を実行するなど、リポジトリで提供されている使用方法に従ってモデルをトレーニングおよび使用できます。
特定の手順は、特定のユースケースとYOLOv4リポジトリの現在の状態によって変わる場合があります。したがって、YOLOv4 GitHubリポジトリで提供されている指示に直接参照することを強くお勧めします。
YOLOv4のサポートが実装され次第、Ultralyticsの使用例のためにこのドキュメントを更新することをお詫び申し上げます。
## 結論
YOLOv4は、速度と精度のバランスを取った強力で効率的なオブジェクト検出モデルです。トレーニング中にユニークな機能とバッグのフリービーの技術を使用することで、リアルタイムのオブジェクト検出タスクで優れたパフォーマンスを発揮します。通常のGPUを持つ誰でもがトレーニングと使用を行うことができるため、幅広いアプリケーションにアクセス可能かつ実用的です。
## 引用と謝辞
リアルタイムオブジェクト検出の分野での重要な貢献に対して、YOLOv4の著者に謝意を表します:
!!! Quote ""
=== "BibTeX"
```bibtex
@misc{bochkovskiy2020yolov4,
title={YOLOv4: Optimal Speed and Accuracy of Object Detection},
author={Alexey Bochkovskiy and Chien-Yao Wang and Hong-Yuan Mark Liao},
year={2020},
eprint={2004.10934},
archivePrefix={arXiv},
primaryClass={cs.CV}
}
```
オリジナルのYOLOv4の論文は[arXiv](https://arxiv.org/pdf/2004.10934.pdf)で見つけることができます。著者は彼らの仕事を一般に公開しており、コードベースは[GitHub](https://github.com/AlexeyAB/darknet)でアクセスできます。私たちは、彼らの努力に感謝し、彼らの仕事を広いコミュニティにアクセス可能にしてくれたことに感謝しています。

113
docs/ja/models/yolov5.md Normal file
View file

@ -0,0 +1,113 @@
---
comments: true
description: YOLOv5uは、改良された精度と速度のトレードオフと、さまざまな物体検出タスク向けの多数の事前トレーニングモデルを備えたYOLOv5モデルの進化バージョンです。
keywords: YOLOv5u, 物体検出, 事前トレーニングモデル, Ultralytics, Inference, Validation, YOLOv5, YOLOv8, アンカーフリー, オブジェクトフリー, リアルタイムアプリケーション, 機械学習
---
# YOLOv5
## 概要
YOLOv5uは、物体検出方法論の進歩を表しています。Ultralyticsが開発した[YOLOv5](https://github.com/ultralytics/yolov5)モデルの基本アーキテクチャを起源とするYOLOv5uは、アンカーフリーでオブジェクトフリーの分割ヘッドを採用しており、以前の[YOLOv8](yolov8.md)モデルで導入された特徴です。この適応により、モデルのアーキテクチャが洗練され、物体検出タスクにおける改善された精度と速度のトレードオフが実現されます。経験的な結果と派生した特徴から明らかなとおり、YOLOv5uは、研究と実用の両方で堅牢なソリューションを求める人々にとって効率的な選択肢です。
![Ultralytics YOLOv5](https://raw.githubusercontent.com/ultralytics/assets/main/yolov5/v70/splash.png)
## 主な特徴
- **アンカーフリーな分割Ultralyticsヘッド** 伝統的な物体検出モデルは、事前に定義されたアンカーボックスを使用してオブジェクトの位置を予測します。しかし、YOLOv5uはこのアプローチを近代化しています。アンカーフリーな分割Ultralyticsヘッドを採用することで、より柔軟かつ適応性のある検出メカニズムが確保され、さまざまなシナリオでのパフォーマンスが向上します。
- **最適化された精度と速度のトレードオフ:** 速度と精度はしばしば反対の方向に引っ張られます。しかし、YOLOv5uはこのトレードオフに挑戦しています。リアルタイムの検出を確保しながら、精度を損なうことなく、キャリブレーションされたバランスを提供します。この機能は、自動車、ロボット工学、リアルタイムビデオ解析など、迅速な応答を必要とするアプリケーションに特に有用です。
- **さまざまな事前トレーニングモデル:** 異なるタスクには異なるツールセットが必要であることを理解して、YOLOv5uはさまざまな事前トレーニングモデルを提供しています。Inference、Validation、Trainingに焦点を当てていても、ユーザーには待ち受けている特別に調整されたモデルがあります。この多様性により、ワンサイズがすべての解決策ではなく、一意の課題に特化したモデルを使用することができます。
## サポートされるタスクとモード
各種の事前トレーニング済みのYOLOv5uモデルは、[物体検出](../tasks/detect.md)タスクで優れたパフォーマンスを発揮します。[Inference](../modes/predict.md)、[Validation](../modes/val.md)、[Training](../modes/train.md)、および[Export](../modes/export.md)などのさまざまなモードをサポートしているため、開発から展開まで幅広いアプリケーションに適しています。
| モデルの種類 | 事前トレーニング済みの重み | タスク | 推論 | 汎化 | トレーニング | エクスポート |
|---------|-----------------------------------------------------------------------------------------------------------------------------|----------------------------|----|----|--------|--------|
| YOLOv5u | `yolov5nu`, `yolov5su`, `yolov5mu`, `yolov5lu`, `yolov5xu`, `yolov5n6u`, `yolov5s6u`, `yolov5m6u`, `yolov5l6u`, `yolov5x6u` | [物体検出](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
この表では、YOLOv5uモデルのバリアントについて詳細な概要を提供し、物体検出タスクでの適用可能性と、[Inference](../modes/predict.md)、[Validation](../modes/val.md)、[Training](../modes/train.md)、[Export](../modes/export.md)などのさまざまな操作モードのサポートを強調しています。この包括的なサポートにより、ユーザーは広範な物体検出シナリオでYOLOv5uモデルの機能を十分に活用することができます。
## パフォーマンスメトリクス
!!! パフォーマンス
=== "検出"
[COCO](https://docs.ultralytics.com/datasets/detect/coco/)でトレーニングされたこれらのモデルを使用した使用例については、[検出ドキュメント](https://docs.ultralytics.com/tasks/detect/)を参照してください。これらのモデルには80の事前トレーニングクラスが含まれています。
| モデル | YAML | サイズ<br><sup>(pixels) | 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) |
|-------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------|-----------------------|----------------------|----------------------------|-------------------------------------|----------------------|-------------------|
| [yolov5nu.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5nu.pt) | [yolov5n.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 34.3 | 73.6 | 1.06 | 2.6 | 7.7 |
| [yolov5su.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5su.pt) | [yolov5s.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 43.0 | 120.7 | 1.27 | 9.1 | 24.0 |
| [yolov5mu.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5mu.pt) | [yolov5m.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 49.0 | 233.9 | 1.86 | 25.1 | 64.2 |
| [yolov5lu.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5lu.pt) | [yolov5l.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 52.2 | 408.4 | 2.50 | 53.2 | 135.0 |
| [yolov5xu.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5xu.pt) | [yolov5x.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 53.2 | 763.2 | 3.81 | 97.2 | 246.4 |
| | | | | | | | |
| [yolov5n6u.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5n6u.pt) | [yolov5n6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 42.1 | 211.0 | 1.83 | 4.3 | 7.8 |
| [yolov5s6u.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5s6u.pt) | [yolov5s6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 48.6 | 422.6 | 2.34 | 15.3 | 24.6 |
| [yolov5m6u.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5m6u.pt) | [yolov5m6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 53.6 | 810.9 | 4.36 | 41.2 | 65.7 |
| [yolov5l6u.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5l6u.pt) | [yolov5l6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 55.7 | 1470.9 | 5.47 | 86.1 | 137.4 |
| [yolov5x6u.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5x6u.pt) | [yolov5x6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 56.8 | 2436.5 | 8.98 | 155.4 | 250.7 |
## 使用例
この例では、単純なYOLOv5のトレーニングと推論の使用例を提供します。これらと他の[モード](../modes/index.md)の完全なドキュメントについては、[Predict](../modes/predict.md)、[Train](../modes/train.md)、[Val](../modes/val.md)、[Export](../modes/export.md)のドキュメントページを参照してください。
!!! Example "例"
=== "Python"
Pythonでモデルインスタンスを作成するには、PyTorchの事前トレーニング済みの`*.pt`モデルおよび構成`*.yaml`ファイルを`YOLO()`クラスに渡すことができます。
```python
from ultralytics import YOLO
# COCOで事前トレーニング済みのYOLOv5nモデルをロードする
model = YOLO('yolov5n.pt')
# モデル情報を表示する(任意)
model.info()
# COCO8の例のデータセットでモデルを100エポックトレーニングする
results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
# YOLOv5nモデルを使用して'bus.jpg'画像で推論を実行する
results = model('path/to/bus.jpg')
```
=== "CLI"
[CLI](../modes/cli.md)コマンドを使用してモデルを直接実行することもできます。
```bash
# COCOで事前トレーニング済みのYOLOv5nモデルをロードし、COCO8の例のデータセットで100エポックトレーニングする
yolo train model=yolov5n.pt data=coco8.yaml epochs=100 imgsz=640
# COCOで事前トレーニング済みのYOLOv5nモデルをロードし、'bus.jpg'画像で推論を実行する
yolo predict model=yolov5n.pt source=path/to/bus.jpg
```
## 引用および謝辞
研究でYOLOv5またはYOLOv5uを使用する場合は、以下のようにUltralytics YOLOv5リポジトリを引用してください
!!! Quote ""
=== "BibTeX"
```bibtex
@software{yolov5,
title = {Ultralytics YOLOv5},
author = {Glenn Jocher},
year = {2020},
version = {7.0},
license = {AGPL-3.0},
url = {https://github.com/ultralytics/yolov5},
doi = {10.5281/zenodo.3908559},
orcid = {0000-0001-5950-6979}
}
```
なお、YOLOv5モデルは[AGPL-3.0](https://github.com/ultralytics/ultralytics/blob/main/LICENSE)および[Enterprise](https://ultralytics.com/license)ライセンスの下で提供されています。

107
docs/ja/models/yolov6.md Normal file
View file

@ -0,0 +1,107 @@
---
comments: true
description: 最先端の速度と精度のバランスを実現する、Meituan YOLOv6というオブジェクト検出モデルを紹介します。機能、事前学習済みモデル、Pythonの使用方法について深く掘り下げます。
keywords: Meituan YOLOv6、オブジェクト検出、Ultralytics、YOLOv6ドキュメント、Bi-directional Concatenation、Anchor-Aided Training、事前学習済みモデル、リアルタイムアプリケーション
---
# Meituan YOLOv6
## 概要
[Meituan](https://about.meituan.com/) YOLOv6は、速度と精度のバランスに優れた最先端のオブジェクト検出器であり、リアルタイムアプリケーションにおいては人気のある選択肢となっています。このモデルは、Bi-directional ConcatenationBiCモジュール、アンカー支援トレーニングAAT戦略の実装、およびCOCOデータセットにおける最先端の精度を実現するための改良されたバックボーンとネックの設計など、アーキテクチャとトレーニング方法にいくつかの注目すべき技術的改善をもたらしました。
![Meituan YOLOv6](https://user-images.githubusercontent.com/26833433/240750495-4da954ce-8b3b-41c4-8afd-ddb74361d3c2.png)
![モデルの例](https://user-images.githubusercontent.com/26833433/240750557-3e9ec4f0-0598-49a8-83ea-f33c91eb6d68.png)
**YOLOv6の概要。** モデルのアーキテクチャ図は、重要な改善点として再設計されたネットワークコンポーネントとトレーニング戦略を示しており、著しいパフォーマンス向上につながっています。 (a) YOLOv6のネックNおよびSが表示されています。M/Lの場合、RepBlocksはCSPStackRepで置き換えられます。 (b) BiCモジュールの構造。 (c) SimCSPSPPFブロック。 ([出典](https://arxiv.org/pdf/2301.05586.pdf))。
### 主な特徴
- **Bi-directional ConcatenationBiCモジュール** YOLOv6は、検出器のネックにBiCモジュールを導入し、ローカリゼーション信号を強化して性能を向上させ、速度の低下をほとんど無視できる優れた結果を実現します。
- **アンカー支援トレーニングAAT戦略** このモデルでは、AATを提案して、アンカーベースとアンカーフリーのパラダイムの両方の利点を享受することができます。これにより、推論効率を損なうことなく性能を向上させることができます。
- **改良されたバックボーンとネックの設計:** YOLOv6をバックボーンとネックに別のステージを追加することで、このモデルはCOCOデータセットでの最先端の性能を高解像度入力で実現しています。
- **自己蒸留戦略:** YOLOv6の小型モデルの性能を向上させるために、新しい自己蒸留戦略が実装されており、トレーニング中に補助回帰ブランチを強化し、推論時にはそれを除去して顕著な速度低下を回避します。
## パフォーマンスメトリクス
YOLOv6にはさまざまなスケールの事前学習済みモデルが提供されています。
- YOLOv6-N: NVIDIA Tesla T4 GPUで、COCO val2017において37.5%のAPを1187 FPSで達成。
- YOLOv6-S: 484 FPSで45.0%のAP。
- YOLOv6-M: 226 FPSで50.0%のAP。
- YOLOv6-L: 116 FPSで52.8%のAP。
- YOLOv6-L6: リアルタイムでの最先端の精度。
YOLOv6には、異なる精度に最適化されたクォンタイズ済みのモデルや、モバイルプラットフォーム向けに最適化されたモデルも提供されています。
## 使用例
この例では、YOLOv6のトレーニングおよび推論の簡単な使用例を示します。これらおよび他の[モード](../modes/index.md)の完全なドキュメントについては、[Predict](../modes/predict.md)、[Train](../modes/train.md)、[Val](../modes/val.md)、[Export](../modes/export.md)のドキュメントページを参照してください。
!!! Example "例"
=== "Python"
PyTorchで事前学習済みの`*.pt`モデルと`*.yaml`設定ファイルを`YOLO()`クラスに渡すことで、Pythonでモデルインスタンスを作成することができます。
```python
from ultralytics import YOLO
# YOLOv6nモデルをゼロから構築する
model = YOLO('yolov6n.yaml')
# モデルの情報を表示する(オプション)
model.info()
# COCO8の例題データセットでモデルを100エポックトレーニングする
results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
# YOLOv6nモデルで'bus.jpg'画像に対して推論を実行する
results = model('path/to/bus.jpg')
```
=== "CLI"
モデルを直接実行するためのCLIコマンドも利用できます。
```bash
# ゼロからYOLOv6nモデルを構築し、COCO8の例題データセットで100エポックトレーニングする
yolo train model=yolov6n.yaml data=coco8.yaml epochs=100 imgsz=640
# ゼロからYOLOv6nモデルを構築し、'bus.jpg'画像に対して推論を実行する
yolo predict model=yolov6n.yaml source=path/to/bus.jpg
```
## サポートされるタスクとモード
YOLOv6シリーズは、高性能の[オブジェクト検出](../tasks/detect.md)に最適化されたモデルを提供しています。これらのモデルは、さまざまな計算ニーズと精度要件に対応しており、幅広いアプリケーションに適応することができます。
| モデルタイプ | 事前学習済みの重み | サポートされるタスク | 推論 | 検証 | トレーニング | エクスポート |
|-----------|----------------|--------------------------------|----|----|--------|--------|
| YOLOv6-N | `yolov6-n.pt` | [オブジェクト検出](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
| YOLOv6-S | `yolov6-s.pt` | [オブジェクト検出](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
| YOLOv6-M | `yolov6-m.pt` | [オブジェクト検出](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
| YOLOv6-L | `yolov6-l.pt` | [オブジェクト検出](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
| YOLOv6-L6 | `yolov6-l6.pt` | [オブジェクト検出](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
この表は、YOLOv6モデルのバリアントについての詳細な概要を提供し、オブジェクト検出のタスクにおける機能と、[推論](../modes/predict.md)、[検証](../modes/val.md)、[トレーニング](../modes/train.md)、[エクスポート](../modes/export.md)などのさまざまな操作モードとの互換性を強調しています。この包括的なサポートにより、ユーザーはさまざまなオブジェクト検出シナリオでYOLOv6モデルの機能を十分に活用することができます。
## 引用と謝辞
リアルタイムオブジェクト検出の分野における重要な貢献をした著者に謝意を表します。
!!! Quote ""
=== "BibTeX"
```bibtex
@misc{li2023yolov6,
title={YOLOv6 v3.0: A Full-Scale Reloading},
author={Chuyi Li and Lulu Li and Yifei Geng and Hongliang Jiang and Meng Cheng and Bo Zhang and Zaidan Ke and Xiaoming Xu and Xiangxiang Chu},
year={2023},
eprint={2301.05586},
archivePrefix={arXiv},
primaryClass={cs.CV}
}
```
YOLOv6のオリジナル論文は[arXiv](https://arxiv.org/abs/2301.05586)で入手できます。著者は自身の研究を広く共有しており、コードベースは[GitHub](https://github.com/meituan/YOLOv6)でアクセスできます。私たちは彼らがこの分野の進歩に貢献し、その研究を広く公開していることに感謝しています。

65
docs/ja/models/yolov7.md Normal file
View file

@ -0,0 +1,65 @@
---
comments: true
description: YOLOv7は高速性と精度の両方で既知の物体検出器を凌駕する最先端のリアルタイム物体検出器です。この技術では、モデル再パラメータ化、動的ラベル割り当て、拡張スケーリング、複合スケーリングなど、学習可能なBag-of-Freebies最適化に焦点を当てています。
keywords: YOLOv7, リアルタイム物体検出器, 最先端, Ultralytics, MS COCO データセット, モデル再パラメータ化, 動的ラベル割り当て, 拡張スケーリング, 複合スケーリング
---
# YOLOv7: 学習可能なBag-of-Freebies
YOLOv7は、5 FPSから160 FPSの範囲で、既知のすべての物体検出器を速度と精度の両方で凌駕する最先端のリアルタイム物体検出器です。GPU V100上で30 FPS以上の性能を持つリアルタイム物体検出器の中で、最高の精度56.8% APを持っています。さらに、YOLOv7はYOLOR、YOLOX、Scaled-YOLOv4、YOLOv5などの他の物体検出器を速度と精度の面で上回っています。このモデルは、他のデータセットや事前学習重みを使用せずに、MS COCOデータセットでトレーニングされています。YOLOv7のソースコードはGitHubで入手できます。
![SOTA物体検出器との比較](https://github.com/ultralytics/ultralytics/assets/26833433/5e1e0420-8122-4c79-b8d0-2860aa79af92)
**最先端物体検出器との比較。** 表2の結果からわかるように、提案手法は速度と精度のトレードオフにおいて最も優れています。例えば、YOLOv7-tiny-SiLUとYOLOv5-Nr6.1を比較すると、我々の手法は127 fps速く、APにおいて10.7%精度が向上しています。また、YOLOv7はフレームレート161 fpsで51.4%のAPを達成していますが、同じAPを持つPPYOLOE-Lのフレームレートは78 fpsのみです。パラメータ使用量に関しては、YOLOv7はPPYOLOE-Lよりも41%少ないです。さらに、114 fpsの推論速度を持つYOLOv7-Xを99 fpsの推論速度を持つYOLOv5-Lr6.1と比較すると、YOLOv7-XはAPを3.9%向上させることができます。YOLOv7-Xをスケールの近いYOLOv5-Xr6.1と比較すると、YOLOv7-Xの推論速度は31 fps速いです。また、パラメータ量と計算量の観点から、YOLOv7-XはYOLOv5-Xr6.1に比べてパラメータを22%、計算量を8%削減していますが、APは2.2%向上しています([出典](https://arxiv.org/pdf/2207.02696.pdf))。
## 概要
リアルタイム物体検出は、マルチオブジェクトトラッキング、自動運転、ロボティクス、医療画像解析など、多くのコンピュータビジョンシステムの重要なコンポーネントです。近年、リアルタイム物体検出の開発は、さまざまなCPU、GPU、ニューラルプロセッシングユニットNPUの推論速度の効率的なアーキテクチャの設計と向上に焦点を当てています。YOLOv7は、エッジからクラウドまで、モバイルGPUとGPUデバイスの両方をサポートしています。
従来のリアルタイム物体検出器がアーキテクチャの最適化に焦点を当てるのに対し、YOLOv7では学習プロセスの最適化に注力しています。これには、推論コストを増やさずに物体検出の精度を向上させるためのモジュールや最適化手法が含まれます。これは、「学習可能なBag-of-Freebies」というコンセプトです。
## 主な特徴
YOLOv7は、いくつかの主な特徴を導入しています。
1. **モデル再パラメータ化**: YOLOv7は、グラデーション伝播経路の概念を持つ、さまざまなネットワークのレイヤーに適用可能な計画された再パラメータ化モデルを提案しています。
2. **動的ラベル割り当て**: 複数の出力層を持つモデルのトレーニングでは、異なるブランチの出力に動的なターゲットを割り当てる方法が新たな課題となります。この問題を解決するために、YOLOv7はコーストゥーファインリードガイド付きラベル割り当てと呼ばれる新しいラベル割り当て手法を導入しています。
3. **拡張スケーリングと複合スケーリング**: YOLOv7は、「拡張」および「複合スケーリング」の方法を提案し、効果的にパラメータと計算を利用できるリアルタイム物体検出器になります。
4. **効率性**: YOLOv7による方法は、最先端のリアルタイム物体検出器のパラメータ量を約40%、計算量を約50%効率的に削減し、より高速な推論速度と高い検出精度を実現します。
## 使用例
執筆時点では、Ultralyticsは現在、YOLOv7モデルをサポートしていません。そのため、YOLOv7を使用したい場合は、YOLOv7のGitHubリポジトリを直接参照する必要があります。
以下は、YOLOv7を使用するための典型的な手順の概要です。
1. YOLOv7のGitHubリポジトリにアクセスします: [https://github.com/WongKinYiu/yolov7](https://github.com/WongKinYiu/yolov7)。
2. READMEファイルに記載されている手順に従ってインストールします。通常、リポジトリをクローンし、必要な依存関係をインストールし、必要な環境変数を設定する必要があります。
3. インストールが完了したら、データセットの準備、モデルパラメータの設定、モデルのトレーニング、トレーニングされたモデルを使用して物体検出を実行するなど、リポジトリで提供されている使用方法に従って、モデルをトレーニングおよび使用することができます。
具体的な手順は、具体的なユースケースとYOLOv7リポジトリの現在の状態によって異なる場合があります。そのため、YOLOv7のGitHubリポジトリで提供されている手順を直接参照することを強くお勧めします。
YOLOv7のサポートが実装されるまで、このドキュメントを更新して、Ultralyticsの使用例を追加するための努力を続けます。
## 引用と謝辞
リアルタイム物体検出の分野での重要な貢献に対して、YOLOv7の著者に感謝いたします。
!!! Quote ""
=== "BibTeX"
```bibtex
@article{wang2022yolov7,
title={{YOLOv7}: Trainable bag-of-freebies sets new state-of-the-art for real-time object detectors},
author={Wang, Chien-Yao and Bochkovskiy, Alexey and Liao, Hong-Yuan Mark},
journal={arXiv preprint arXiv:2207.02696},
year={2022}
}
```
YOLOv7のオリジナル論文は[arXiv](https://arxiv.org/pdf/2207.02696.pdf)で見つけることができます。著者は自分たちの研究を広く公開しており、コードベースは[GitHub](https://github.com/WongKinYiu/yolov7)でアクセスできます。彼らの研究がこの分野を進め、他の研究者にもアクセス可能にする努力に感謝します。

162
docs/ja/models/yolov8.md Normal file
View file

@ -0,0 +1,162 @@
---
comments: true
description: YOLOv8の魅力的な機能を探索しましょう。これは当社のリアルタイムオブジェクト検出器の最新バージョンです高度なアーキテクチャ、事前学習済みモデル、そして精度と速度の最適なバランスがYOLOv8を完璧なオブジェクト検出タスクの選択肢とします。
keywords: YOLOv8, Ultralytics, リアルタイムオブジェクト検出器, 事前学習済みモデル, ドキュメント, オブジェクト検出, YOLOシリーズ, 高度なアーキテクチャ, 精度, 速度
---
# YOLOv8
## 概要
YOLOv8は、リアルタイムオブジェクト検出器のYOLOシリーズの最新版であり、精度と速度において最先端の性能を提供します。以前のYOLOバージョンの進化を基にして、YOLOv8は新機能と最適化を導入し、様々なオブジェクト検出タスクにおいて広範なアプリケーションに適した選択肢となります。
![Ultralytics YOLOv8](https://raw.githubusercontent.com/ultralytics/assets/main/yolov8/yolo-comparison-plots.png)
## 主な特徴
- **高度なバックボーンおよびネックアーキテクチャ:** YOLOv8は最先端のバックボーンとネックアーキテクチャを採用しており、特徴抽出とオブジェクト検出のパフォーマンスが向上しています。
- **アンカーフリーな分割Ultralyticsヘッド:** YOLOv8はアンカーベースの方法と比べて、アンカーフリーな分割Ultralyticsヘッドを採用し、より高い精度と効率的な検出プロセスに貢献しています。
- **最適な精度と速度のトレードオフの最適化:** 精度と速度の最適なバランスを保ちながら、YOLOv8は多岐にわたるリアルタイムオブジェクト検出タスクに適しています。
- **さまざまな事前学習済みモデル:** YOLOv8はさまざまなタスクやパフォーマンス要件に対応する事前学習済みモデルを提供しており、特定のユースケースに適したモデルを簡単に見つけることができます。
## サポートされるタスクとモード
YOLOv8シリーズは、コンピュータビジョンのさまざまなタスクに特化したさまざまなモデルを提供しています。これらのモデルは、オブジェクト検出からインスタンスセグメンテーション、ポーズ/キーポイントの検出、分類などのより複雑なタスクまで、さまざまな要件に対応するように設計されています。
YOLOv8シリーズの各バリアントは、それぞれのタスクに最適化されており、高いパフォーマンスと精度を提供します。また、これらのモデルは、推論、検証、トレーニング、エクスポートといったさまざまな運用モードと互換性があり、展開と開発のさまざまな段階で使用することができます。
| モデル | ファイル名 | タスク | 推論 | 検証 | トレーニング | エクスポート |
|-------------|----------------------------------------------------------------------------------------------------------------|----------------------------------------|----|----|--------|--------|
| YOLOv8 | `yolov8n.pt` `yolov8s.pt` `yolov8m.pt` `yolov8l.pt` `yolov8x.pt` | [検出](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
| YOLOv8-seg | `yolov8n-seg.pt` `yolov8s-seg.pt` `yolov8m-seg.pt` `yolov8l-seg.pt` `yolov8x-seg.pt` | [インスタンスセグメンテーション](../tasks/segment.md) | ✅ | ✅ | ✅ | ✅ |
| YOLOv8-pose | `yolov8n-pose.pt` `yolov8s-pose.pt` `yolov8m-pose.pt` `yolov8l-pose.pt` `yolov8x-pose.pt` `yolov8x-pose-p6.pt` | [ポーズ/キーポイント](../tasks/pose.md) | ✅ | ✅ | ✅ | ✅ |
| YOLOv8-cls | `yolov8n-cls.pt` `yolov8s-cls.pt` `yolov8m-cls.pt` `yolov8l-cls.pt` `yolov8x-cls.pt` | [分類](../tasks/classify.md) | ✅ | ✅ | ✅ | ✅ |
この表は、YOLOv8モデルのバリアントの概要を提供し、特定のタスクでの適用性と推論、検証、トレーニング、エクスポートなどのさまざまな運用モードとの互換性を示しています。これにより、YOLOv8シリーズの多様性と堅牢性が示されており、コンピュータビジョンのさまざまなアプリケーションに適しています。
## 性能メトリクス
!!! パフォーマンス
=== "検出COCO"
[COCO](https://docs.ultralytics.com/datasets/detect/coco/)でトレーニングされたこれらのモデルを使用した使用例については、[検出ドキュメント](https://docs.ultralytics.com/tasks/detect/)を参照してください。これらのモデルには80の事前学習済みクラスが含まれています。
| モデル | サイズ(ピクセル) | mAP<sup>val<br>50-95 | スピードCPU ONNX<br>(ミリ秒)) | スピードA100 TensorRT<br>(ミリ秒)) | パラメータ数(百万) | FLOPs10億 |
| ------------------------------------------------------------------------------------ | --------------------- | -------------------- | ------------------------------ | ----------------------------------- | ------------------ | ----------------- |
| [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 |
=== "検出Open Images V7"
[Open Image V7](https://docs.ultralytics.com/datasets/detect/open-images-v7/)でトレーニングされたこれらのモデルを使用した使用例については、[検出ドキュメント](https://docs.ultralytics.com/tasks/detect/)を参照してください。これらのモデルには600の事前訓練クラスが含まれています。
| モデル | サイズ(ピクセル) | mAP<sup>val<br>50-95 | スピードCPU ONNX<br>(ミリ秒)) | スピードA100 TensorRT<br>(ミリ秒)) | パラメータ数(百万) | FLOPs10億 |
| ----------------------------------------------------------------------------------------- | --------------------- | -------------------- | ------------------------------ | ----------------------------------- | ------------------ | ----------------- |
| [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-oiv7.pt) | 640 | 18.4 | 142.4 | 1.21 | 3.5 | 10.5 |
| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-oiv7.pt) | 640 | 27.7 | 183.1 | 1.40 | 11.4 | 29.7 |
| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-oiv7.pt) | 640 | 33.6 | 408.5 | 2.26 | 26.2 | 80.6 |
| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-oiv7.pt) | 640 | 34.9 | 596.9 | 2.43 | 44.1 | 167.4 |
| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-oiv7.pt) | 640 | 36.3 | 860.6 | 3.56 | 68.7 | 260.6 |
=== "セグメンテーションCOCO"
[COCO](https://docs.ultralytics.com/datasets/segment/coco/)でトレーニングされたこれらのモデルを使用した使用例については、[セグメンテーションドキュメント](https://docs.ultralytics.com/tasks/segment/)を参照してください。これらのモデルには80の事前学習済みクラスが含まれています。
| モデル | サイズ(ピクセル) | mAP<sup>box<br>50-95 | mAP<sup>mask<br>50-95 | スピードCPU ONNX<br>(ミリ秒)) | スピードA100 TensorRT<br>(ミリ秒)) | パラメータ数(百万) | FLOPs10億 |
| -------------------------------------------------------------------------------------------- | --------------------- | -------------------- | --------------------- | ------------------------------ | ----------------------------------- | ------------------ | ----------------- |
| [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 |
=== "分類ImageNet"
[ImageNet](https://docs.ultralytics.com/datasets/classify/imagenet/)でトレーニングされたこれらのモデルを使用した使用例については、[分類ドキュメント](https://docs.ultralytics.com/tasks/classify/)を参照してください。これらのモデルには1000の事前学習済みクラスが含まれています。
| モデル | サイズ(ピクセル) | top1精度 | top5精度 | スピードCPU ONNX<br>(ミリ秒)) | スピードA100 TensorRT<br>(ミリ秒)) | パラメータ数(百万) | FLOPs640ピクセル時の10億 |
| -------------------------------------------------------------------------------------------- | --------------------- | --------- | --------- | ------------------------------ | ----------------------------------- | ------------------ | ------------------------ |
| [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 |
=== "ポーズCOCO"
['person']クラスの1つの事前学習済みクラスを含む、[COCO](https://docs.ultralytics.com/datasets/pose/coco/)でトレーニングされたこれらのモデルを使用した使用例については、[ポーズ推定ドキュメント](https://docs.ultralytics.com/tasks/pose/)を参照してください。
| モデル | サイズ(ピクセル) | mAP<sup>pose<br>50-95 | mAP<sup>pose<br>50 | スピードCPU ONNX<br>(ミリ秒)) | スピードA100 TensorRT<br>(ミリ秒)) | パラメータ数(百万) | FLOPs10億 |
| ---------------------------------------------------------------------------------------------------- | --------------------- | --------------------- | ------------------ | ------------------------------ | ----------------------------------- | ------------------ | ----------------- |
| [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 |
## 使用例
この例では、YOLOv8のシンプルなトレーニングと推論の使用例を提供しています。これらとその他のモードに関する完全なドキュメントについては、[Predict](../modes/predict.md)、[Train](../modes/train.md)、[Val](../modes/val.md)、および[Export](../modes/export.md)のドキュメントページを参照してください。
以下の例は、オブジェクト検出のためのYOLOv8 [Detect](../tasks/detect.md)モデル用のものです。他のサポートされるタスクについては、[Segment](../tasks/segment.md)、[Classify](../tasks/classify.md)、および[Pose](../tasks/pose.md)のドキュメントを参照してください。
!!! Example "例"
=== "Python"
Pythonでの、`.pt`形式の事前学習済みPyTorchモデルおよび設定ファイル`*.yaml`を使用して、`YOLO()`クラスを介してモデルインスタンスを作成する方法の例です:
```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
```
## 引用および謝辞
このリポジトリからYOLOv8モデルまたは他のソフトウェアを使用する場合は、次の形式で引用してください
!!! Quote ""
=== "BibTeX"
```bibtex
@software{yolov8_ultralytics,
author = {Glenn Jocher and Ayush Chaurasia and Jing Qiu},
title = {Ultralytics YOLOv8},
version = {8.0.0},
year = {2023},
url = {https://github.com/ultralytics/ultralytics},
orcid = {0000-0001-5950-6979, 0000-0002-7603-6750, 0000-0003-3783-7069},
license = {AGPL-3.0}
}
```
DOIは準備中であり、利用可能になり次第、引用に追加されます。YOLOv8モデルは[AGPL-3.0](https://github.com/ultralytics/ultralytics/blob/main/LICENSE)および[Enterprise](https://ultralytics.com/license)ライセンスで提供されています。