画像理解タスク別・実装手法の整理（分類・検出・セグメンテーション・ゼロショット・キーポイント）

本資料について

前提条件

(1) Windowsのパソコンで動作する、(2) ソースコードが公開されている、(3) 学習済みモデルが公開・入手可能である、の3つをすべて満たすものだけを採用する。

ハードウェアの扱い

GPU搭載機かCPUのみかは限定しない。

時点

会議・年の情報は各一次情報（CVPR／ECCV／ICCV／NeurIPS／ICLR 等の公式・arXiv・各GitHub・Hugging Face）に基づく。実装前に、最新のライセンス・配布状況・モデルバリアントを各自で再確認すること。

用語

• バウンディングボックス：対象を囲む矩形。物体検出では物体の位置と範囲を表す。
• top-1精度：分類で、最上位の予測クラスが正解と一致した割合。
• mAP／AP：mean Average Precision。物体検出・インスタンスセグメンテーションの精度指標。値が大きいほど高精度。
• mIoU：mean Intersection over Union。セマンティックセグメンテーションで、予測領域と正解領域の重なりの平均。値が大きいほど高精度。
• PQ：Panoptic Quality。パノプティックセグメンテーションの統合指標。値が大きいほど高精度。
• NMSフリー：重複した検出枠を除去する後処理（Non-Maximum Suppression）を必要としない設計。推論が単純・高速になる。
• OBB：Oriented Bounding Box。回転に対応したバウンディングボックス。航空・衛星画像の傾いた物体に用いる。
• セマンティックセグメンテーション：各ピクセルがどのクラスに属するかを分類する出力形式。個体は区別しない。
• インスタンスセグメンテーション：物体個体ごとに領域マスクを出力する形式。同一クラスの別個体を区別する。
• パノプティックセグメンテーション：物体個体（things）と背景領域（stuff）を単一の出力に統合する形式。
• zero-shot（ゼロショット）：そのデータセットで学習せずに推論すること。例：COCOで学習せずにCOCOを検出する。
• open-vocabulary（オープンボキャブラリ）：固定クラスではなく、任意のテキスト等で指定したクラスを検出・分割すること。
• few-shot（少数ショット）：少数（数枚）の参照例から新クラスを学習・推論すること。
• exemplar：手本となる参照画像。少数ショットや概念指定で用いる。
• PCS：Promptable Concept Segmentation。テキストや参照画像で指定した概念の全インスタンスを分割する枠組み（SAM 3が導入）。
• MIM：Masked Image Modeling。画像の一部を隠して復元させる自己教師あり事前学習。EVA-02等が用いる。
• SAHI：Slicing Aided Hyper Inference。高解像度画像を重複する小パッチに分割して推論し、結果を統合する手法。小物体検出に有効。
• バックボーン：特徴抽出を担うネットワーク本体。ViT・ConvNeXt・Swin Transformerなどを用いる。
• ViT：Vision Transformer。画像をパッチ列として扱うTransformer。
• ONNX：機械学習モデルの共通フォーマット。CPU推論ランタイム（onnxruntime）と組み合わせて用いる。
• 蒸留（distillation）：大きなモデルの知識を小さなモデルに移す学習手法。

本資料の読み方

本資料は13項目のタスクを扱う。処理の性質により分類（タスク1〜2）、検出（タスク3〜4・8〜9・11）、セグメンテーション（タスク5〜7・10・12）、キーポイント（タスク13）の区分に分かれる。各タスクは入力・出力・評価データセットが異なり、用途に応じて使い分ける。全体の対応関係は次のとおりである。

タスクの棲み分けについては、出力形式や技術系統が異なるものを別タスクとして扱う。分類のタスク1とタスク2は、前者がImageNet-22k事前学習→1k fine-tuneで1000クラスを出力するのに対し、後者は22kクラスを直接出力する点で出力が異なる。セグメンテーションのタスク5・6・7は、各ピクセルのクラス分類（5）、個体ごとのマスク（6）、両者の統合（7）という出力形式の違いで分かれる。検出のタスク3・8・11は、固定クラスの高精度検出（3）、テキストによるゼロショット検出（8）、リアルタイム性を重視するオープンボキャブラリ検出（11）という目的・系統の違いで分かれる。

手法の選定では、(i) 2026年5月時点での新しさ、(ii) 学習済みモデルとソースの公開、(iii) Windowsでの導入のしやすさを基準としている。精度と速度のどちらを優先するかは用途により異なるため、各タスクでCPU向け・GPU向けの最大1手法ずつを併記する。該当枠に実用候補がないタスクは「—」と記す。なお、軽量モデル（nano等）を意図的に採用しており、モデルサイズの拡大による精度改善は行わない。新手法への交換は、同等以下の規模で性能・精度がともに上回る場合に限る。

記号の根拠について：◎○△×は、各手法の公開情報（論文・リポジトリの記載）および一般的な傾向に基づく目安であり、実測値ではない。処理速度（FPS）は、CPU／GPUの世代・入力解像度・他タスクとの併用などにより変わるため、導入時には各自の環境で計測すること。

ライセンスについて（重要）：採用手法のライセンスは多様であり、商用利用の可否は手法ごとに異なる。とくに、YOLO26／YOLOE26／YOLO11系はAGPL-3.0（組み込んだソフトの配布・SaaS提供時にソース公開義務が生じうる。商用にはEnterpriseライセンスが別途必要な場合がある）、ConvNeXt-V2のImageNet学習済み重みはCC-BY-NC（非商用。コード自体はMIT）、DEIMv2・LLMDet・MM-Grounding-DINO・RF-DETR・EVA-02・SegFormer・Mask2Former・OneFormer等はApache 2.0系／MIT系が中心である。SAM 3はMetaの独自ライセンス（SAM License）で配布される。各タスクに該当を記載するが、実装前に各配布元のLICENSEを必ず確認すること。

コード例について：各タスクにはコード例を付けている。コード例は要点を示すことを目的とし、エラー処理・例外処理は省略している。

Python 3.12 のインストール

Pythonのインストールを行い、Pythonのプログラムを実行する環境を整える。扱う環境は、Windows搭載パソコンである。金子研究室では、Python 3.12.10を推奨する。

REM Python 3.12 をシステム領域にインストール
winget install --id Python.Python.3.12 -e --scope machine --silent --accept-source-agreements --accept-package-agreements --override "/quiet InstallAllUsers=1 PrependPath=1 Include_test=0 Include_pip=1 Include_launcher=1 InstallLauncherAllUsers=1 TargetDir=\"C:\Program Files\Python312\""

REM Python と Scripts を PATH 先頭に追加
powershell -NoProfile -Command "$p='C:\Program Files\Python312'; $s=\"$p\Scripts\"; $c=[Environment]::GetEnvironmentVariable('Path','Machine'); if((Test-Path $p) -and (';'+$c+';' -notlike \"*;$p;*\") -and (';'+$c+';' -notlike \"*;$s;*\")){[Environment]::SetEnvironmentVariable('Path',\"$p;$s;$c\",'Machine')}"

python --version

Build Tools・CUDA Toolkit・PyTorch のインストール

本章では、C++ ビルドツール、NVIDIA CUDA Toolkit、PyTorch のインストールを行い、GPU を活用した機械学習プログラムを実行する環境を整える。扱う環境は、Windows 搭載パソコンである。

REM VC++ ランタイム
winget install --scope machine --id Microsoft.VCRedist.2015+.x64 -e --silent --disable-interactivity --force --accept-source-agreements --accept-package-agreements --override "/quiet /norestart"

REM ============================================================
REM Visual Studio Build Tools + Desktop development with C++
REM （VCTools、MSBuildTools、CMake連携、Clang、Windows 11 SDK）
REM ============================================================
REM 進行中のインストーラーを停止（ロック競合回避）
taskkill /F /IM vs_setup.exe /T >nul 2>&1
taskkill /F /IM vs_installer.exe /T >nul 2>&1
taskkill /F /IM vs_installerservice.exe /T >nul 2>&1

REM 未インストール時: winget で新規インストール
REM インストール済み時: setup.exe modify でコンポーネント追加（バージョンは変更しない）
winget list --id Microsoft.VisualStudio.BuildTools 2>nul | findstr /i "BuildTools" >nul 2>&1
if %ERRORLEVEL% EQU 0 (
    for /f "usebackq delims=" %P in (`"C:\Program Files (x86)\Microsoft Visual Studio\Installer\vswhere.exe" -products Microsoft.VisualStudio.Product.BuildTools -property installationPath`) do start /wait "" "C:\Program Files (x86)\Microsoft Visual Studio\Installer\setup.exe" modify --installPath "%P" --add Microsoft.VisualStudio.Workload.VCTools --add Microsoft.VisualStudio.Workload.MSBuildTools --add Microsoft.VisualStudio.Component.VC.CMake.Project --add Microsoft.VisualStudio.Component.VC.Llvm.Clang --add Microsoft.VisualStudio.Component.VC.Llvm.ClangToolset --add Microsoft.VisualStudio.Component.Windows11SDK.26100 --includeRecommended --quiet --norestart --nocache
) else (
    winget install --scope machine --id Microsoft.VisualStudio.BuildTools -e --silent --disable-interactivity --force --accept-source-agreements --accept-package-agreements --override "--quiet --wait --norestart --nocache --add Microsoft.VisualStudio.Workload.VCTools --includeRecommended --add Microsoft.VisualStudio.Workload.MSBuildTools --add Microsoft.VisualStudio.Component.VC.CMake.Project --add Microsoft.VisualStudio.Component.VC.Llvm.Clang --add Microsoft.VisualStudio.Component.VC.Llvm.ClangToolset --add Microsoft.VisualStudio.Component.Windows11SDK.26100"
)

REM 破損時の修復（任意、動作がおかしくなった場合）
REM "C:\Program Files (x86)\Microsoft Visual Studio\Installer\setup.exe" repair --installPath "C:\Program Files (x86)\Microsoft Visual Studio\18\BuildTools" --quiet --norestart

REM 導入確認（インストールパスが表示されれば正常）
"C:\Program Files (x86)\Microsoft Visual Studio\Installer\vswhere.exe" -products * -requires Microsoft.VisualStudio.Workload.VCTools -property installationPath

REM NVIDIA CUDA Toolkit 12.8 をシステム領域にインストール
winget install --scope machine --id Nvidia.CUDA --version 12.8 -e --silent --disable-interactivity --force --uninstall-previous --accept-source-agreements --accept-package-agreements --override "-s -n"

REM 環境変数TEMP, TMPの設定（一時ファイルの保存先を短いパスに変更）
mkdir C:\TEMP
setx TEMP "C:\TEMP" /M
setx TMP "C:\TEMP" /M

nvcc --version

pip install --no-user -U numpy torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu128

Python の開発環境 Visual Studio Code のインストールと Python 用の設定

Python の開発環境Visual Studio Code（プログラムを編集するソフトウェア。以下、VS Code）を整える。

REM ============================================================
REM Microsoft Visual Studio Code
REM ============================================================
winget uninstall -e --id Microsoft.VisualStudioCode --silent --disable-interactivity --accept-source-agreements
rmdir /s /q C:\ProgramData\vscode-extensions 2>nul
rmdir /s /q "%APPDATA%\Code" 2>nul
rmdir /s /q "%USERPROFILE%\.vscode" 2>nul
rmdir /s /q "%LOCALAPPDATA%\Microsoft\vscode-update" 2>nul

REM VS Code をシステム領域に新規インストール
winget install --scope machine --id Microsoft.VisualStudioCode -e --silent --accept-source-agreements --accept-package-agreements

REM 全ユーザー共有の拡張機能フォルダ
mkdir C:\ProgramData\vscode-extensions 2>nul
icacls "C:\ProgramData\vscode-extensions" /grant "Everyone:(OI)(CI)M" /T

REM スタートメニューのショートカットを --extensions-dir 付きで再作成
rmdir /s /q "C:\ProgramData\Microsoft\Windows\Start Menu\Programs\Visual Studio Code" 2>nul
del "C:\ProgramData\Microsoft\Windows\Start Menu\Programs\Visual Studio Code.lnk" 2>nul
powershell -NoProfile -Command "$s=New-Object -ComObject WScript.Shell; $lnk=$s.CreateShortcut('C:\ProgramData\Microsoft\Windows\Start Menu\Programs\Visual Studio Code.lnk'); $lnk.TargetPath='C:\Program Files\Microsoft VS Code\Code.exe'; $lnk.Arguments='--extensions-dir \"C:\ProgramData\vscode-extensions\"'; $lnk.Save()"
REM ショートカットの検証
powershell -NoProfile -Command "$s=New-Object -ComObject WScript.Shell; $lnk=$s.CreateShortcut('C:\ProgramData\Microsoft\Windows\Start Menu\Programs\Visual Studio Code.lnk'); Write-Host 'TargetPath:' $lnk.TargetPath; Write-Host 'Arguments:' $lnk.Arguments"

REM ファイル / フォルダ右クリックの「Code で開く」を登録
reg add "HKLM\SOFTWARE\Classes\*\shell\VSCode\command" /ve /d "\"C:\Program Files\Microsoft VS Code\Code.exe\" --extensions-dir \"C:\ProgramData\vscode-extensions\" \"%1\"" /f
reg add "HKLM\SOFTWARE\Classes\Directory\shell\VSCode\command" /ve /d "\"C:\Program Files\Microsoft VS Code\Code.exe\" --extensions-dir \"C:\ProgramData\vscode-extensions\" \"%1\"" /f
reg add "HKLM\SOFTWARE\Classes\Directory\Background\shell\VSCode\command" /ve /d "\"C:\Program Files\Microsoft VS Code\Code.exe\" --extensions-dir \"C:\ProgramData\vscode-extensions\" \"%V\"" /f

REM --extensions-dir 付きで起動する code.cmd ラッパを作成
REM （%* を echo で書くと対話的 cmd で失われるため、PowerShell で [char]37+'*' を書き出す）
powershell -NoProfile -Command "$pct=[char]37; $q=[char]34; $c='@echo off'+[char]13+[char]10+$q+'C:\Program Files\Microsoft VS Code\bin\code.cmd'+$q+' --extensions-dir '+$q+'C:\ProgramData\vscode-extensions'+$q+' '+$pct+'*'+[char]13+[char]10; [IO.File]::WriteAllText('C:\ProgramData\vscode-extensions\vscode.cmd',$c,[Text.Encoding]::ASCII)"

REM 拡張機能のインストール
set "CODE=C:\Program Files\Microsoft VS Code\bin\code.cmd"
"%CODE%" --extensions-dir "C:\ProgramData\vscode-extensions" --uninstall-extension GitHub.copilot
"%CODE%" --extensions-dir "C:\ProgramData\vscode-extensions" --uninstall-extension GitHub.copilot-chat
"%CODE%" --extensions-dir "C:\ProgramData\vscode-extensions" --install-extension ms-python.python
"%CODE%" --extensions-dir "C:\ProgramData\vscode-extensions" --install-extension ms-python.vscode-pylance
"%CODE%" --extensions-dir "C:\ProgramData\vscode-extensions" --install-extension ms-python.debugpy
"%CODE%" --extensions-dir "C:\ProgramData\vscode-extensions" --install-extension MS-CEINTL.vscode-language-pack-ja
"%CODE%" --extensions-dir "C:\ProgramData\vscode-extensions" --install-extension saoudrizwan.claude-dev
"%CODE%" --extensions-dir "C:\ProgramData\vscode-extensions" --install-extension rust-lang.rust-analyzer
"%CODE%" --extensions-dir "C:\ProgramData\vscode-extensions" --install-extension tamasfe.even-better-toml
"%CODE%" --extensions-dir "C:\ProgramData\vscode-extensions" --install-extension anthropic.claude-code
"%CODE%" --extensions-dir "C:\ProgramData\vscode-extensions" --install-extension almenon.arepl
"%CODE%" --extensions-dir "C:\ProgramData\vscode-extensions" --list-extensions --show-versions
echo === セットアップ完了 ===

Python プログラム実行手順

1. 分類：ImageNet-1k／22k 画像分類

タスク定義単一のRGB画像を入力とし、所属クラスを出力する。ImageNet-22kで事前学習し、1k（1000クラス）にfine-tuneした重みを用いるのが標準である。

紹介技術：CPU利用時＝ConvNeXt-V2-Nano ／ GPU利用時＝EVA-02-Large

EVA-02はMIMで事前学習したViT系で、Large（約304Mパラメータ）が公開データのみでImageNet-1k検証セットのtop-1精度90.0%を達成する。ConvNeXt-V2は純畳み込みモデルで、Atto（3.7M、76.7%）からHuge（650M、88.9%）まで幅広いサイズの重みを持ち、Nanoは軽量でCPU推論・ONNX化が現実的である。いずれもtimm（PyTorch Image Models）から読み込める。

学習済みモデル：pip install timm で導入し、重みは初回実行時に自動取得される。Windows動作可。

• timm：https://github.com/huggingface/pytorch-image-models
• EVA-02 論文：https://arxiv.org/abs/2303.11331
• ConvNeXt-V2：https://github.com/facebookresearch/ConvNeXt-V2

GPU／CPU：EVA-02-LargeはGPU推奨。ConvNeXt-V2-NanoはCPUで実用的に動作する。

利用の理由：top-1精度90%帯のEVA-02-Largeと、軽量・CPU実用のConvNeXt-V2-Nanoの組み合わせを上回り、3条件を満たす手法が2026年5月時点で確認できないため、継続して採用する。ライセンス：ConvNeXt-V2のImageNet学習済み重みはCC-BY-NC（非商用）。商用時は要確認。

事前準備：次を管理者権限のコマンドプロンプトで実行

pip install -U --no-user timm pillow matplotlib

ソースコード：

# timm：画像を分類し、Top-5を画像と棒グラフで可視化
import urllib.request
from pathlib import Path
import torch, timm
from timm.data import ImageNetInfo, infer_imagenet_subset
from PIL import Image
import matplotlib.pyplot as plt

IMG_URL = "https://ultralytics.com/images/bus.jpg"
img_path = Path(Path(IMG_URL).name)
if not img_path.exists():
    urllib.request.urlretrieve(IMG_URL, img_path)        # 入力画像をダウンロード

name = "eva02_large_patch14_448.mim_m38m_ft_in22k_in1k" if torch.cuda.is_available() else "convnextv2_nano.fcmae_ft_in22k_in1k"  # GPUならEVA-02-Large、CPUならConvNeXt-V2-Nanoを選択
model = timm.create_model(name, pretrained=True).eval() # 初回実行時に重みを自動ダウンロード
cfg = timm.data.resolve_model_data_config(model)
tf = timm.data.create_transform(**cfg, is_training=False)

img = Image.open(img_path).convert("RGB")
prob = model(tf(img).unsqueeze(0)).softmax(dim=1)        # 推論

info = ImageNetInfo(infer_imagenet_subset(model))
top5 = prob.topk(5, dim=1)
labels = [info.index_to_description(i, detailed=False) for i in top5.indices[0].tolist()]
scores = top5.values[0].tolist()

fig, (ax_img, ax_bar) = plt.subplots(1, 2, figsize=(11, 5))  # 可視化結果を表示
ax_img.imshow(img)
ax_img.axis("off")
ax_img.set_title(f"{labels[0]} ({scores[0] * 100:.1f}%)")
ax_bar.barh(labels[::-1], [s * 100 for s in scores[::-1]])
ax_bar.set_xlabel("probability (%)")
ax_bar.set_xlim(0, 100)
fig.tight_layout()
plt.show()

2. 分類：ImageNet-22k 大規模分類（21,841クラスを直接出力）

タスク定義単一のRGB画像を入力とし、ImageNet-22kの21,841クラスを直接出力する。1kにfine-tuneせず、22kヘッドを保持した重みを用いる。1000クラスを出力するタスク1とは出力空間が異なる。

紹介技術：CPU利用時＝ConvNeXt-Tiny（22k）／ GPU利用時＝ViT-Large／16（22k）

ViT-Large／16の22k事前学習重み（vit_large_patch16_224.augreg_in21k）は21,841クラスの分類ヘッドを保持し、1kにfine-tuneせず22kクラスを直接出力できる。CPU向けにはConvNeXt-Tinyの22k事前学習重み（convnext_tiny.fb_in22k、出力21,841クラス）を用いる。こちらも22kヘッドを保持したままで軽量なため、CPUで動作する。いずれもtimmから読み込める。

学習済みモデル：pip install timm で導入し、重みは初回実行時に自動取得される。Windows動作可。

• timm：https://github.com/huggingface/pytorch-image-models

GPU／CPU：ViT-Large／16はGPU推奨。ConvNeXt-TinyはCPUで動作する。

利用の理由：22kヘッドを保持したViT系・ConvNeXt系の重みがtimmで安定して入手でき、これを上回り、3条件を満たす手法が2026年5月時点で確認できないため、継続して採用する。ライセンス：ViT（augreg）・ConvNeXtのImageNet-22k学習済み重みは、いずれも商用利用可能な寛容ライセンスで配布されている。

事前準備：次を管理者権限のコマンドプロンプトで実行

pip install -U --no-user timm pillow matplotlib

ソースコード：

# timm：ImageNet-22kクラスを直接出力し、Top-5を画像と棒グラフで可視化
import urllib.request
from pathlib import Path
import torch, timm
from timm.data import ImageNetInfo, infer_imagenet_subset
from PIL import Image
import matplotlib.pyplot as plt

IMG_URL = "https://ultralytics.com/images/bus.jpg"
img_path = Path(Path(IMG_URL).name)
if not img_path.exists():
    urllib.request.urlretrieve(IMG_URL, img_path)        # 入力画像をダウンロード

name = "vit_large_patch16_224.augreg_in21k" if torch.cuda.is_available() else "convnext_tiny.fb_in22k"  # GPUならViT-Large／16、CPUならConvNeXt-Tinyを選択
model = timm.create_model(name, pretrained=True).eval() # 初回実行時に重みを自動ダウンロード
cfg = timm.data.resolve_model_data_config(model)
tf = timm.data.create_transform(**cfg, is_training=False)

img = Image.open(img_path).convert("RGB")
prob = model(tf(img).unsqueeze(0)).softmax(dim=1)        # 推論

info = ImageNetInfo(infer_imagenet_subset(model))
top5 = prob.topk(5, dim=1)
labels = [info.index_to_description(i, detailed=False) for i in top5.indices[0].tolist()]
scores = top5.values[0].tolist()

fig, (ax_img, ax_bar) = plt.subplots(1, 2, figsize=(11, 5))  # 可視化結果を表示
ax_img.imshow(img)
ax_img.axis("off")
ax_img.set_title(f"{labels[0]} ({scores[0] * 100:.1f}%)")
ax_bar.barh(labels[::-1], [s * 100 for s in scores[::-1]])
ax_bar.set_xlabel("probability (%)")
ax_bar.set_xlim(0, 100)
fig.tight_layout()
plt.show()

3. 検出：物体検出（COCO・Objects365）

タスク定義単一のRGB画像または映像フレームを入力とし、各物体のバウンディングボックスとクラス・信頼度を出力する。固定クラス集合（COCO 80クラス等）に対する高精度検出を主目的とする。

紹介技術：CPU利用時＝YOLO26-n ／ GPU利用時＝DEIMv2-X

DEIMv2（DEIMの後継、2025年9月公開）はDINOv3バックボーンとSpatial Tuning Adapter（STA）を組み合わせたDETR系のリアルタイム検出器であり、最大のDEIMv2-Xは50.3MパラメータでCOCO 57.8 APを達成し、より大きい前世代のX規模モデル（60M超のパラメータで56.5 AP）を少ないパラメータ・計算量で上回る。XからAttoまで8サイズの重みが公開される。一方、YOLO26（2026年1月リリース）はNMSフリーのend-to-end検出器で、CPU推論が最大43%高速化されており、nano版はCPU環境でも実用的な速度で動作する。

学習済みモデル：YOLO26は pip install ultralytics で導入し、重みは初回実行時に自動取得される。DEIMv2の学習済み重みはGitHubで配布される。Windows動作可。

• YOLO26（Ultralytics）：https://docs.ultralytics.com/models/yolo26
• DEIMv2：https://github.com/Intellindust-AI-Lab/DEIMv2（arXiv 2509.20787）

GPU／CPU：DEIMv2-XはGPU推奨。YOLO26-nはCPUで実用的に動作し、GPUでも利用できる。

利用の理由：少ないパラメータ・計算量で前世代を上回るDEIMv2-X（Apache 2.0系）と、軽量・NMSフリーのYOLO26-nの組み合わせを上回り、3条件を満たす手法が2026年5月時点で確認できないため、採用する。ライセンス：YOLO系はAGPL-3.0。

事前準備：次を管理者権限のコマンドプロンプトで実行

pip install -U --no-user ultralytics matplotlib

ソースコード：

# YOLO26：画像から物体を検出し、結果を可視化（CPU枠。GPUでも同コードで動作）
import urllib.request
from pathlib import Path
import matplotlib.pyplot as plt
from ultralytics import YOLO

IMG_URL = "https://ultralytics.com/images/bus.jpg"
img_path = Path(Path(IMG_URL).name)
if not img_path.exists():
    urllib.request.urlretrieve(IMG_URL, img_path)        # 入力画像をダウンロード

model = YOLO("yolo26n.pt")                               # 初回実行時に重みを自動ダウンロード
r = model(img_path)[0]                                   # 推論

for b in r.boxes:
    print(b.xyxy[0].tolist(), float(b.conf), int(b.cls)) # 枠・信頼度・クラス

plt.figure(figsize=(8, 6))                               # 可視化結果を表示
plt.imshow(r.plot()[:, :, ::-1])                         # BGR→RGB
plt.axis("off")
plt.tight_layout()
plt.show()

4. 検出：回転ボックス検出（DOTA）

タスク定義航空・衛星画像を入力とし、傾いた物体を回転バウンディングボックス（OBB）で検出する。小さく密に並ぶ物体を対象とする。軸平行の矩形を返すタスク3とは出力形式が異なる。

紹介技術：CPU利用時＝YOLO11n-OBB＋SAHI ／ GPU利用時＝YOLO26-OBB

YOLO26-OBBは、OBBの境界不連続問題に対応する角度損失を備え、DOTA学習済み重みとともに配布される。CPU環境では、軽量なYOLO11n-OBBに、高解像度画像を重複パッチへ分割して推論し結果を統合するSAHIを併用することで、密集する小物体を拾いやすくなる。

学習済みモデル：pip install ultralytics（SAHIは pip install sahi）で導入し、重みは初回実行時に自動取得される。Windows動作可。

• YOLO（OBB）：https://docs.ultralytics.com/tasks/obb/
• SAHI：https://github.com/obss/sahi

GPU／CPU：YOLO26-OBBはGPUで高速に動作する。YOLO11n-OBB＋SAHIはCPUでも動作するが、分割数の増加に応じて処理負荷が増す。

利用の理由：研究系の高精度バックボーン（LSKNet・PKINet・LEGNet等）はmmrotate／OpenMMLabに依存し、Windowsでの構築難度が高く、WSLや事前ビルド環境の検討を要する。配布の容易さからYOLO系を主軸とし、これを上回り、3条件を満たす手法が2026年5月時点で確認できないため、継続して採用する。ライセンス：YOLO系はAGPL-3.0。

事前準備：次を管理者権限のコマンドプロンプトで実行

pip install -U --no-user ultralytics matplotlib

ソースコード：

# YOLO26-OBB：航空・衛星画像から回転ボックスを検出し、結果を可視化
import urllib.request
from pathlib import Path
import matplotlib.pyplot as plt
from ultralytics import YOLO

IMG_URL = "https://ultralytics.com/images/boats.jpg"     # 航空画像（OBBモデルの想定視点）
img_path = Path(Path(IMG_URL).name)
if not img_path.exists():
    urllib.request.urlretrieve(IMG_URL, img_path)        # 入力画像をダウンロード

model = YOLO("yolo26n-obb.pt")                           # 初回実行時に重みを自動ダウンロード
r = model(img_path)[0]                                   # 推論

for b in r.obb:
    print(b.xyxyxyxy[0].tolist(), float(b.conf), int(b.cls)) # 4頂点・信頼度・クラス

plt.figure(figsize=(8, 6))                               # 可視化結果を表示
plt.imshow(r.plot()[:, :, ::-1])                         # BGR→RGB
plt.axis("off")
plt.tight_layout()
plt.show()

5. セグメンテーション：セマンティックセグメンテーション（ADE20K・COCO）

タスク定義単一のRGB画像を入力とし、各ピクセルが属するクラスを出力する。個体は区別しない。

紹介技術：CPU利用時＝SegFormer-B0 ／ GPU利用時＝Mask2Former-Swin-Large

Mask2Formerはセマンティック・インスタンス・パノプティックの三つを統合する枠組みで、ADE20Kで高水準のmIoUを示す。重みはADE20K版とCOCO版が分かれて配布される。SegFormerは軽量なTransformerで、最小構成のB0はCPU推論が現実的である。いずれもHugging Face transformersから読み込める。

学習済みモデル：pip install transformers で導入し、重みは初回実行時に自動取得される。Windows動作可。

• Mask2Former：https://huggingface.co/docs/transformers/model_doc/mask2former
• SegFormer：https://huggingface.co/docs/transformers/model_doc/segformer

GPU／CPU：Mask2Former-Swin-LargeはGPU推奨。SegFormer-B0はCPUで動作する。

利用の理由：高精度のMask2Formerと、CPUで実用的なSegFormer-B0（いずれもApache 2.0系）の組み合わせを上回り、3条件を満たす手法が2026年5月時点で確認できないため、継続して採用する。

事前準備：次を管理者権限のコマンドプロンプトで実行

pip install -U --no-user torch transformers pillow numpy matplotlib

ソースコード：

# SegFormer-B0：各ピクセルのクラスを推定し、結果を可視化（CPU枠）
import urllib.request
from pathlib import Path
import torch
import numpy as np
import matplotlib.pyplot as plt
from PIL import Image
from transformers import AutoImageProcessor, AutoModelForSemanticSegmentation

IMG_URL = "https://ultralytics.com/images/bus.jpg"
img_path = Path(Path(IMG_URL).name)
if not img_path.exists():
    urllib.request.urlretrieve(IMG_URL, img_path)        # 入力画像をダウンロード
img = Image.open(img_path).convert("RGB")

ckpt = "nvidia/segformer-b0-finetuned-ade-512-512"
proc = AutoImageProcessor.from_pretrained(ckpt)          # 初回実行時に重みを自動ダウンロード
model = AutoModelForSemanticSegmentation.from_pretrained(ckpt).eval()

inputs = proc(images=img, return_tensors="pt")
with torch.no_grad():
    outputs = model(**inputs)
seg = proc.post_process_semantic_segmentation(outputs, target_sizes=[img.size[::-1]])[0].numpy()  # 各ピクセルのクラスID

palette = np.random.randint(0, 255, (model.config.num_labels, 3))  # クラス別の配色
overlay = (np.array(img) * 0.5 + palette[seg] * 0.5).astype(np.uint8)  # 元画像へ重畳

for cid in np.unique(seg):                               # 検出クラスを出力
    print(cid, model.config.id2label[int(cid)])

plt.figure(figsize=(8, 6))                               # 可視化結果を表示
plt.imshow(overlay)
plt.axis("off")
plt.tight_layout()
plt.show()

6. セグメンテーション：インスタンスセグメンテーション（COCO）

タスク定義単一のRGB画像を入力とし、物体個体ごとに領域マスクとクラスを出力する。同一クラスの別個体を区別する。

紹介技術：CPU利用時＝YOLO26-seg-n ／ GPU利用時＝Mask2Former-Swin-Base（COCO）

Mask2FormerのCOCOインスタンス向け重み（facebook/mask2former-swin-base-coco-instance）は高水準のAPを示し、transformersで読み込める。YOLO26-seg-nはセグメンテーション損失とマルチスケールprotoを備える軽量版で、CPUで実用速度が出る。

学習済みモデル：Mask2Formerは pip install transformers、YOLO26は pip install ultralytics で導入し、重みは初回実行時に自動取得される。Windows動作可。

• Mask2Former：https://huggingface.co/facebook/mask2former-swin-base-coco-instance
• YOLO26：https://docs.ultralytics.com/models/yolo26

GPU／CPU：Mask2Former-Swin-BaseはGPU推奨。YOLO26-seg-nはCPUで実用的に動作する。

利用の理由：高精度のMask2Former-Baseと、軽量なYOLO26-seg-nの組み合わせを上回り、3条件を満たす手法が2026年5月時点で確認できないため、継続して採用する。RF-DETRも単一APIで検出＋インスタンスセグメンテーションに対応し、代替となる。ライセンス：YOLO系はAGPL-3.0、Mask2FormerはApache 2.0系。

事前準備：次を管理者権限のコマンドプロンプトで実行

pip install -U --no-user ultralytics matplotlib

ソースコード：

# YOLO26-seg：個体ごとのマスクを推定し、結果を可視化（CPU枠）
import urllib.request
from pathlib import Path
import numpy as np
import matplotlib.pyplot as plt
from ultralytics import YOLO

IMG_URL = "http://images.cocodataset.org/val2017/000000039769.jpg"
img_path = Path(Path(IMG_URL).name)
if not img_path.exists():
    urllib.request.urlretrieve(IMG_URL, img_path)        # 入力画像をダウンロード

model = YOLO("yolo26n-seg.pt")                           # 初回実行時に重みを自動ダウンロード
results = model(img_path, retina_masks=True)[0]          # 推論（マスクを元画像解像度で取得）
img = results.orig_img[..., ::-1]                        # BGR→RGB

masks = results.masks.data.cpu().numpy()                 # 個体ごとのマスク
cls = results.boxes.cls.cpu().numpy().astype(int)        # 個体ごとのクラス
cmap = plt.colormaps["tab10"]                            # 個体別の配色
overlay = img.copy()
for i, (m, c) in enumerate(zip(masks, cls)):             # 個体ごとに着色
    color = np.array(cmap(i % 10)[:3]) * 255
    overlay[m > 0.5] = overlay[m > 0.5] * 0.4 + color * 0.6
    print(i, model.names[c])                             # 個体番号とクラス

plt.figure(figsize=(8, 6))                               # 可視化結果を表示
plt.imshow(overlay.astype(np.uint8))
plt.axis("off")
plt.tight_layout()
plt.show()

7. セグメンテーション：パノプティックセグメンテーション（COCO）

タスク定義単一のRGB画像を入力とし、物体個体（things）と背景領域（stuff）を1つの出力へ統合する。全ピクセルにクラスと個体IDを割り当てる。

紹介技術：CPU利用時＝Mask2Former-Swin-Tiny（COCO）／ GPU利用時＝OneFormer-Swin-Large（COCO）

OneFormerは単一モデルでセマンティック・インスタンス・パノプティックの3タスクを扱うユニバーサルモデルで、個別学習のMask2Formerを上回り、COCO panoptic学習済み重みを備える。CPU環境ではMask2FormerのTinyバックボーン版を用いる。いずれもtransformersで読み込める。

学習済みモデル：pip install transformers で導入し、重みは初回実行時に自動取得される。Windows動作可。

• OneFormer：https://huggingface.co/docs/transformers/model_doc/oneformer
• Mask2Former：https://huggingface.co/docs/transformers/model_doc/mask2former

GPU／CPU：OneFormer-Swin-LargeはGPU推奨。Mask2Former-Swin-TinyはCPUで動作する（負荷は大きい）。

利用の理由：3タスク統合で高精度なOneFormerと、CPUで動作するMask2Former-Tiny（いずれもApache 2.0系）の組み合わせを上回り、3条件を満たす手法が2026年5月時点で確認できないため、継続して採用する。

事前準備：次を管理者権限のコマンドプロンプトで実行

pip install -U --no-user torch transformers pillow numpy matplotlib

ソースコード：

# OneFormer／Mask2Former：パノプティックセグメンテーションの結果を可視化
import urllib.request
from pathlib import Path
import torch
import numpy as np
import matplotlib.pyplot as plt
from PIL import Image
from transformers import AutoProcessor, AutoModelForUniversalSegmentation

IMG_URL = "https://ultralytics.com/images/bus.jpg"
img_path = Path(Path(IMG_URL).name)
if not img_path.exists():
    urllib.request.urlretrieve(IMG_URL, img_path)        # 入力画像をダウンロード
img = Image.open(img_path).convert("RGB")

cuda = torch.cuda.is_available()                         # GPUならOneFormer-Large、CPUならMask2Former-Tinyを選択
ckpt = "shi-labs/oneformer_coco_swin_large" if cuda else "facebook/mask2former-swin-tiny-coco-panoptic"
device = "cuda" if cuda else "cpu"
proc = AutoProcessor.from_pretrained(ckpt)               # 初回実行時に重みを自動ダウンロード
model = AutoModelForUniversalSegmentation.from_pretrained(ckpt).to(device).eval()

if cuda:                                                 # パノプティック推論（OneFormerはtask_inputsを指定）
    inputs = proc(images=img, task_inputs=["panoptic"], return_tensors="pt").to(device)
else:
    inputs = proc(images=img, return_tensors="pt").to(device)
with torch.no_grad():
    outputs = model(**inputs)
result = proc.post_process_panoptic_segmentation(outputs, target_sizes=[img.size[::-1]])[0]
seg = result["segmentation"].cpu().numpy()               # 各ピクセルの個体ID

cmap = plt.colormaps["tab10"]                            # 個体別の配色
overlay = np.array(img).astype(float)
for i, info in enumerate(result["segments_info"]):       # 個体ごとに着色
    m = seg == info["id"]
    color = np.array(cmap(i % 10)[:3]) * 255
    overlay[m] = overlay[m] * 0.4 + color * 0.6
    print(i, model.config.id2label[info["label_id"]])    # 個体番号とクラス

plt.figure(figsize=(8, 6))                               # 可視化結果を表示
plt.imshow(overlay.astype(np.uint8))
plt.axis("off")
plt.tight_layout()
plt.show()

8. 検出：ゼロショット物体検出（COCO・LVIS）

タスク定義画像と検出したい物体名のテキストを入力とし、そのデータセットで個別に学習することなく（ゼロショットで）物体を検出する。あらかじめ定義された固定クラスに縛られず、任意の物体名を指定できる。

紹介技術：CPU利用時＝LLMDet-Tiny ／ GPU利用時＝LLMDet（Swin-L）

LLMDet（CVPR 2025 highlight）は、MM-Grounding-DINOを基盤に、大規模言語モデルの監督（画像・領域の詳細キャプション生成）を併用して学習した検出器であり、推論時はLLMを切り離すため追加コストがない。ゼロショットのLVIS minivalで、Swin-Lが51.1 AP、最小のSwin-T（Tiny）でも44.7 APを達成し、同サイズ・同アーキテクチャのMM-Grounding-DINOを上回る。推論コードはMM-Grounding-DINOと同一で、Hugging Face transformersに統合済みである。Tiny版はCPUでも動作する。

学習済みモデル：pip install transformers で導入し、重みは初回実行時に自動取得される。Windows動作可。

• LLMDet：https://github.com/iSEE-Laboratory/LLMDet（CVPR 2025）
• LLMDet（HF）：https://huggingface.co/iSEE-Laboratory/llmdet_large

GPU／CPU：GPUで高速に動作し、Tiny版はCPUでも動作する。

利用の理由：完全オープン（Apache 2.0系）で、同規模のままMM-Grounding-DINOのゼロショット精度を更新し、transformersから容易に利用できる。これを上回り、3条件を満たす手法が2026年5月時点で確認できないため、採用する。

事前準備：次を管理者権限のコマンドプロンプトで実行

pip install -U --no-user torch transformers pillow numpy matplotlib

ソースコード：

# LLMDet：テキストで指定した物体をゼロショット検出し、結果を可視化
import urllib.request
from pathlib import Path
import torch
import numpy as np
import matplotlib.pyplot as plt
from PIL import Image
from transformers import AutoProcessor, AutoModelForZeroShotObjectDetection

IMG_URL = "https://ultralytics.com/images/bus.jpg"
img_path = Path(Path(IMG_URL).name)
if not img_path.exists():
    urllib.request.urlretrieve(IMG_URL, img_path)        # 入力画像をダウンロード
img = Image.open(img_path).convert("RGB")

cuda = torch.cuda.is_available()                         # GPUならLLMDet（Swin-L）、CPUならLLMDet-Tinyを選択
ckpt = "iSEE-Laboratory/llmdet_large" if cuda else "iSEE-Laboratory/llmdet_tiny"
device = "cuda" if cuda else "cpu"
proc = AutoProcessor.from_pretrained(ckpt)               # 初回実行時に重みを自動ダウンロード
model = AutoModelForZeroShotObjectDetection.from_pretrained(ckpt).to(device).eval()

texts = [["person", "bus"]]                              # 検出したい物体名をテキストで指定
inputs = proc(images=img, text=texts, return_tensors="pt").to(device)
with torch.no_grad():
    outputs = model(**inputs)
result = proc.post_process_grounded_object_detection(
    outputs, threshold=0.4, target_sizes=[img.size[::-1]])[0]

cmap = plt.colormaps["tab10"]                            # 検出別の配色
plt.figure(figsize=(8, 6))                               # 可視化結果を表示
plt.imshow(np.array(img))
ax = plt.gca()
for i, (box, score, label) in enumerate(zip(result["boxes"], result["scores"], result["text_labels"])):
    x0, y0, x1, y1 = box.tolist()                        # 検出ごとに矩形とラベルを描画
    ax.add_patch(plt.Rectangle((x0, y0), x1 - x0, y1 - y0, fill=False, edgecolor=cmap(i % 10), linewidth=2))
    ax.text(x0, y0, f"{label} {score:.2f}", color="white", backgroundcolor=cmap(i % 10))
    print(i, label, round(score.item(), 2))              # 検出番号・クラス・スコア
plt.axis("off")
plt.tight_layout()
plt.show()

9. 検出：少数ショット物体検出（PASCAL VOC・COCO）

タスク定義少数（数枚）の例から新クラスを検出するタスクである。VOC／COCOのfew-shot splitで評価する。大量の学習データを要する通常の物体検出とは前提が異なる。

紹介技術：CPU利用時＝— ／ GPU利用時＝DeFRCN

DeFRCN（ICCV 2021）は、Gradient Decoupled LayerとPrototypical Calibration BlockによってFaster R-CNNを拡張し、few-shot設定で高い性能を示す。Detectron2をベースとし、VOC・COCOのfew-shot split向けの重みを配布している。学習・推論ともにGPUを前提とするため、CPU枠は設けない（まとめ表ではCPU枠＝—、動作のCPU側＝×）。

学習済みモデル：GitHubで配布される。Detectron2のWindows導入では、WSLや事前ビルド版の利用を検討するとよい。Windows動作は可能だがGPUを前提とする。

• DeFRCN：https://github.com/er-muyue/DeFRCN（ICCV 2021）

GPU/CPU：GPU推奨。

利用の理由：CPU向けに最適化された完成配布の少数ショット検出は限定的であり、DeFRCNを上回りつつ3条件を満たす手法が2026年5月時点で確認できないため、本手法を継続採用する。CPUで軽量に済ませたい場合は、ゼロショット検出（タスク8）やオープンボキャブラリ検出（タスク11）を「テキスト／数枚の例」で代替する運用が現実的である。なお本来はリポジトリ付属スクリプトを用いるが、ここでは関連タスクの理解を補うため、YOLOによるインスタンスセグメンテーションを1ファイルで完結する最小コードとして示す。

事前準備：次を管理者権限のコマンドプロンプトで実行

pip install -U --no-user ultralytics matplotlib

ソースコード：

# YOLOv8-seg：個体ごとのマスクを推定し、結果を可視化（関連タスクの最小コード）
import urllib.request
from pathlib import Path
import numpy as np
import matplotlib.pyplot as plt
from ultralytics import YOLO

IMG_URL = "https://ultralytics.com/images/bus.jpg"
img_path = Path(Path(IMG_URL).name)
if not img_path.exists():
    urllib.request.urlretrieve(IMG_URL, img_path)

model = YOLO("yolov8n-seg.pt")                          # 初回実行時に重みを自動ダウンロード
results = model(img_path, retina_masks=True)[0]         # 推論（マスクを元画像解像度で取得）
img = results.orig_img[..., ::-1]                       # BGR→RGB

masks = results.masks.data.cpu().numpy()                 # 個体ごとのマスク
cls = results.boxes.cls.cpu().numpy().astype(int)        # 個体ごとのクラス
cmap = plt.colormaps["tab10"]                            # 個体別の配色
overlay = img.copy()
for i, (m, c) in enumerate(zip(masks, cls)):             # 個体ごとに着色
    color = np.array(cmap(i % 10)[:3]) * 255
    overlay[m > 0.5] = overlay[m > 0.5] * 0.4 + color * 0.6
    print(i, model.names[c])                             # 個体番号とクラス

plt.figure(figsize=(8, 6))                               # 可視化結果を表示
plt.imshow(overlay.astype(np.uint8))
plt.axis("off")
plt.tight_layout()
plt.show()

10. セグメンテーション：少数ショットセグメンテーション（PASCAL-5i・COCO-20i）

タスク定義少数の参照画像（とマスク）から、新クラスの領域を分割する。PASCAL-5i／COCO-20iで評価する。多くがSAMの学習済み重みを利用する。

紹介技術：CPU利用時＝PerSAM（学習不要）／ GPU利用時＝VRP-SAM

VRP-SAM（CVPR 2024）はVRPエンコーダで参照画像からSAM用のプロンプト埋め込みを生成するSAMベースの少数ショット分割手法で、PASCAL-5i・COCO-20iで評価される。PerSAM（ICLR 2024）は1ショットの参照とマスクからSAMをカスタマイズする学習不要の手法で、特徴類似度で対象位置を求め、SAMのデコーダにプロンプトを与える。学習不要のためCPUでも軽量である。

学習済みモデル：いずれもGitHubで配布される（SAM本体の重みを別途利用）。Windows動作可。

• VRP-SAM：https://github.com/syp2ysy/VRP-SAM（CVPR 2024）
• PerSAM：https://github.com/ZrrSkywalker/Personalize-SAM（ICLR 2024）

GPU／CPU：VRP-SAMはGPU推奨。PerSAMは学習不要でCPUでも軽量に動作する。

利用の理由：高精度のVRP-SAMと、学習不要でCPU軽量のPerSAMの組み合わせを上回り、3条件を満たす手法が2026年5月時点で確認できないため、継続して採用する。タスク12のSAM 3の概念セグメンテーション（画像exemplar対応）も代替として有力である。リポジトリ付属スクリプトを利用するため、コード例は実行コマンドで示す。

# PerSAM：1ショットの参照からSAMで新クラスを分割（付属スクリプトを利用、学習不要）
# python persam.py --data <参照画像とマスク> --outdir output/
# 出力：対象クラスの領域マスク

11. 検出：オープンボキャブラリ物体検出（LVIS・COCO）

タスク定義画像とテキスト（任意のクラス名）を入力とし、固定クラスに縛られず物体を検出する。LVIS（1203クラス）等で評価する。リアルタイム性を重視する系統である。

紹介技術：CPU利用時＝YOLO-World-S ／ GPU利用時＝YOLOE26-L

YOLOEは検出とインスタンスセグメンテーションをリアルタイムで行うオープンボキャブラリモデルで、YOLO26ベースのYOLOE26-LがLVISで36.8% mAP、T4 GPUで161 FPSを示す。テキスト・ビジュアル・プロンプトフリーの各モードに対応する。CPU向けには軽量なYOLO-World-S（LVIS 26.2 AP帯）を用いる。

学習済みモデル：pip install ultralytics で導入し、重みは初回実行時に自動取得される。Windows動作可。

• YOLOE（Ultralytics）：https://docs.ultralytics.com/models/yoloe
• YOLO-World：https://docs.ultralytics.com/models/yolo-world

GPU／CPU：YOLOE26-LはGPUで高速に動作する。YOLO-World-SはCPUで動作する。

利用の理由：高精度・NMSフリーのYOLOE26-Lと、軽量なYOLO-World-Sの組み合わせを上回り、3条件を満たす手法が2026年5月時点で確認できないため、継続して採用する。MediaPipeはオープンボキャブラリ検出に対応していない。ライセンス：YOLO系はAGPL-3.0。

事前準備：次を管理者権限のコマンドプロンプトで実行

pip install -U --no-user ultralytics matplotlib

ソースコード：

# YOLOE：任意のテキストクラスで検出し、結果を可視化（GPU利用時。CPUは YOLO-World-S に置換）
import urllib.request
from pathlib import Path
import numpy as np
import matplotlib.pyplot as plt
from ultralytics import YOLOE

IMG_URL = "https://ultralytics.com/images/bus.jpg"
img_path = Path(Path(IMG_URL).name)
if not img_path.exists():
    urllib.request.urlretrieve(IMG_URL, img_path)        # 入力画像をダウンロード

model = YOLOE("yoloe-26l-seg.pt")                        # 初回実行時に重みを自動ダウンロード
names = ["person", "backpack"]                           # 検出したいクラスをテキストで指定
model.set_classes(names, model.get_text_pe(names))
results = model(img_path, retina_masks=True)[0]          # 推論（マスクを元画像解像度で取得）
img = results.orig_img[..., ::-1]                        # BGR→RGB

masks = results.masks.data.cpu().numpy()                 # 個体ごとのマスク
cls = results.boxes.cls.cpu().numpy().astype(int)        # 個体ごとのクラス
cmap = plt.colormaps["tab10"]                            # 個体別の配色
overlay = img.copy()
for i, (m, c) in enumerate(zip(masks, cls)):             # 個体ごとに着色
    color = np.array(cmap(i % 10)[:3]) * 255
    overlay[m > 0.5] = overlay[m > 0.5] * 0.4 + color * 0.6
    print(i, model.names[c])                             # 個体番号とクラス

plt.figure(figsize=(8, 6))                               # 可視化結果を表示
plt.imshow(overlay.astype(np.uint8))
plt.axis("off")
plt.tight_layout()
plt.show()

12. セグメンテーション：概念セグメンテーション（オープンボキャブラリ）

タスク定義画像とテキスト（または参照画像）を入力とし、指定した概念のすべてのインスタンスをピクセル単位で分割・追跡する（PCS）。矩形を返すタスク8・11とは出力形式が異なる。

紹介技術：CPU利用時＝LLMDet-Tiny＋MobileSAM ／ GPU利用時＝SAM 3

SAM 3（Metaが2025年11月リリース）は、テキストや画像exemplarで指定した概念の全インスタンスを検出・分割・追跡するPCSの基盤モデルで、画像・動画のPCSで既存システムの2倍の性能を示す。ultralyticsに統合済みである。CPU向けには、タスク8のLLMDet-Tinyで位置を検出し、MobileSAM／FastSAMでピクセル分割する分離構成が現実的である。

学習済みモデル：SAM 3は pip install ultralytics（8.3.237以降）で利用できるが、重み（sam3.pt）は自動取得されない。Hugging Faceのfacebook/sam3でアクセスを申請し、承認後にsam3.ptをダウンロードして作業ディレクトリに配置する。MobileSAM等はGitHubで配布される。Windows動作可。

• SAM 3（Ultralytics）：https://docs.ultralytics.com/models/sam-3
• LLMDet（HF）：https://huggingface.co/iSEE-Laboratory/llmdet_tiny

GPU／CPU：SAM 3はGPU推奨（CPUでも動作するが大きめ）。分離構成はCPUで動作する。

利用の理由：単一モデルで概念分割・追跡を行うSAM 3を上回り、3条件を満たす手法が2026年5月時点で確認できないため、継続して採用する。ライセンス：SAM 3はMetaの独自ライセンス（SAM License）で配布される。

事前準備：次を管理者権限のコマンドプロンプトで実行

pip install -U --no-user ultralytics matplotlib
pip install git+https://github.com/ultralytics/CLIP.git

ソースコード：

# SAM 3：テキストで指定した概念の全インスタンスを分割し、結果を可視化
import urllib.request
from pathlib import Path
import numpy as np
import matplotlib.pyplot as plt
from ultralytics import SAM

IMG_URL = "https://ultralytics.com/images/bus.jpg"
img_path = Path(Path(IMG_URL).name)
if not img_path.exists():
    urllib.request.urlretrieve(IMG_URL, img_path)        # 入力画像をダウンロード

model = SAM("sam3.pt")                                   # 事前に入手したsam3.ptを読み込み（自動取得されない）
results = model(img_path, text=["bus"])[0]               # 概念をテキストで指定して推論
img = results.orig_img[..., ::-1]                        # BGR→RGB

masks = results.masks.data.cpu().numpy()                 # 概念に一致した全インスタンスのマスク
print(masks.shape)
cmap = plt.colormaps["tab10"]                            # 個体別の配色
overlay = img.copy()
for i, m in enumerate(masks):                            # 個体ごとに着色
    color = np.array(cmap(i % 10)[:3]) * 255
    overlay[m > 0.5] = overlay[m > 0.5] * 0.4 + color * 0.6

plt.figure(figsize=(8, 6))                               # 可視化結果を表示
plt.imshow(overlay.astype(np.uint8))
plt.axis("off")
plt.tight_layout()
plt.show()

13. キーポイント：人体キーポイント検出（COCO Keypoints）

タスク定義画像または映像を入力とし、人体の関節等のキーポイント（COCO標準では17点）を出力する。複数人物に対応する。

紹介技術：CPU利用時＝YOLO11n-pose ／ GPU利用時＝YOLO26-pose

YOLO26-poseはRLE（Residual Log-Likelihood Estimation）を用いて高精度な姿勢推定を行い、COCO Keypoints学習済み重みで配布される。CPU向けには軽量なYOLO11n-poseを用いる。いずれも複数人物に対応し、COCO標準の17点を出力する。

学習済みモデル：pip install ultralytics で導入し、重みは初回実行時に自動取得される。Windows動作可。

• YOLO（pose）：https://docs.ultralytics.com/tasks/pose/

GPU／CPU：YOLO26-poseはGPUで高速に動作する。YOLO11n-poseはCPUで実用的に動作する。

利用の理由：複数人物・COCO 17点を高精度に出力し、サイズ選択で精度／軽量を切り替えられるYOLO26／YOLO11 poseを上回り、3条件を満たす手法が2026年5月時点で確認できないため、継続して採用する。ライセンス：YOLO系はAGPL-3.0。

事前準備：次を管理者権限のコマンドプロンプトで実行

pip install -U --no-user ultralytics matplotlib

ソースコード：

# YOLO11-pose：人体キーポイントを検出し、結果を可視化（CPU枠。GPUは yolo26-pose に置換）
import urllib.request
from pathlib import Path
import matplotlib.pyplot as plt
from ultralytics import YOLO

IMG_URL = "https://ultralytics.com/images/bus.jpg"
img_path = Path(Path(IMG_URL).name)
if not img_path.exists():
    urllib.request.urlretrieve(IMG_URL, img_path)        # 入力画像をダウンロード

model = YOLO("yolo11n-pose.pt")                          # 初回実行時に重みを自動ダウンロード
results = model(img_path)[0]                             # 推論
img = results.orig_img[..., ::-1]                        # BGR→RGB

kpts = results.keypoints.data.cpu().numpy()              # 人物ごとのキーポイント
cmap = plt.colormaps["tab10"]                            # 人物別の配色
plt.figure(figsize=(8, 6))                               # 可視化結果を表示
plt.imshow(img)
for i, kp in enumerate(kpts):                            # 人物ごとに描画
    v = kp[:, 2] > 0.5                                   # 信頼度の高い点のみ
    plt.scatter(kp[v, 0], kp[v, 1], s=20, color=cmap(i % 10))
    print(i, kp.shape)                                   # 人物番号と [17, 3]（x, y, 信頼度）
plt.axis("off")
plt.tight_layout()
plt.show()

まとめ表

GPU／CPU欄の記号は次の意味で用いる。◎＝リアルタイム（目安約15FPS以上）で快適に動作する。○＝動作するが速度や条件に留意が必要。△＝動作するが負荷が大きく、実用性は限定的（静止画単位向け）。×＝実用的な動作は確認できない（その側に採用枠を置けない理由）。「—」＝該当枠に実用候補を置かない（GPU必須タスクのCPU枠など）。CPU枠・GPU利用時は採用手法を、◎○△×—はそれぞれの動作特性を示す。

ライセンス注意：YOLO26／YOLOE26／YOLO11系はAGPL-3.0（配布・SaaS提供時にソース公開義務が生じうる。商用にはEnterpriseライセンスが別途必要な場合がある）。ConvNeXt-V2のImageNet学習済み重みはCC-BY-NC（非商用）。DEIMv2・LLMDet・MM-Grounding-DINO・RF-DETR・EVA-02・SegFormer・Mask2Former・OneFormer等はApache 2.0系／MIT系が中心。SAM 3はMetaの独自ライセンス（SAM License）で配布される。少数ショット系（DeFRCN等）やSAM派生は研究用配布を含む。商用利用時は各リポジトリのLICENSEを必ず確認すること。導入容易性の観点では、timm（分類）・ultralytics（検出／seg／pose）・transformers（ゼロショット／seg）の3系統で大半を賄える。