✍️ 필사 모드: Vision モデル開発・fine-tuning 完全ガイド 2026 — CNN、ViT、DETR、SAM 2、VLM の実戦 decision tree

プロローグ — 2026 年の vision engineer が向き合う本当の問い

2026 年 5 月のある月曜日、vision チームのリードに届いた 1 行のチケット:

「工場ラインの camera 映像から不良部品を mark してください。class は 12 個、1 日 30 万枚処理、accuracy 95% 以上、edge デバイス(Jetson Orin Nano) で 30 fps。」

同じ要件を 2018 年に受けていたら答えは明確だった — ResNet50 backbone に RetinaNet head、COCO で事前学習してから自前データで fine-tune。終わり。

2026 年の答えは 8 個ほどある。

1. YOLOv11/12 で普通に fine-tune
2. RT-DETR で transformer ベースの detection
3. SAM 2 で mask を出して classifier を載せる
4. Florence-2 のような vision foundation model に prompt だけ投げる
5. Gemini 2.5 Vision や Claude Vision に写真を送って自然言語で結果を受け取る
6. CLIP で embedding を取って kNN で classify
7. OWLv2/Grounding DINO で text prompt ベースの zero-shot detection
8. 上記の 2、3 個を pipeline として組み合わせる

この記事はその 8 個の選択肢をいつ、なぜ、どう選ぶかの指針だ。単に「最新のモデルが良い」ではなく、データ規模・accuracy 要求・latency 予算・運用 cost の 4 軸で decision tree を作る。

2026 年の vision engineer のコアスキルは、もはや「モデル学習」ではない。「どのモデルを学習するか、そもそも学習が必要なのかを決めること」だ。

1 章 · architecture ファミリー — CNN から VLM まで一望

vision モデルは結局「画像 → 何か」であって、その「何か」が何かによって architecture のファミリーが分かれる。

この表は暗記する価値がある。次の 8 章で各行を展開する。

コア原理: 全ての vision モデルは結局 「画像を token の sequence として見る」 — CNN は空間 grid として、ViT は patch sequence として、SAM は prompt と一緒に、VLM は LLM の入力 token として。representation がモデルを定義する。

2 章 · CNN は死んでいない — 2026 年での位置

ViT が全部呑み込んだという marketing と違って、2026 年でも CNN は生きている。特に次のような場合に。

CNN を選ぶべきとき

1. データが少ない — label 1 万枚以下。ViT は事前学習なしではほぼ学習が進まない。
2. edge で動かす必要がある — Jetson、Coral、携帯。ConvNeXt-Tiny は ViT-Tiny より同じ FLOPs で速い。
3. latency が本当に厳しい — 1 ms 以下。小さい CNN は GPU で 0.5 ms も可能。
4. 解像度が極めて高い — 4K の medical 画像。ViT は patch 数が爆発する。

timm でモデルを 1 行 load

PyTorch Image Models(timm) は 2026 年でも vision backbone の事実上の標準だ。1,000 以上の事前学習済み backbone を 1 行で呼べる。

import timm
import torch

# ConvNeXt v2 large、ImageNet-22k 事前学習、22k-1k で fine-tune
model = timm.create_model(
    'convnextv2_large.fcmae_ft_in22k_in1k_384',
    pretrained=True,
    num_classes=12,  # 我々の task の class 数
)

# 入力 transform はモデルが教えてくれる
data_config = timm.data.resolve_model_data_config(model)
transform = timm.data.create_transform(**data_config, is_training=True)

# batch 次元を含む tensor の形は `B x C x H x W`
x = torch.randn(2, 3, 384, 384)
logits = model(x)  # shape: 2 x 12

timm.list_models('convnext*', pretrained=True) で候補を確認できる。pretrained_cfg の中に mean、std、input_size、crop_pct が入っているので transform を統一しやすい。

CNN 学習レシピ — 小さなデータでうまく動かす方法

• 事前学習 → head のみ学習 → 全体 fine-tune の 3 段階
• Mixup、CutMix、RandAugment — label 1 万枚以下ならほぼ必須
• EMA(Exponential Moving Average) — validation accuracy が 1〜2 pp タダで得られる
• Cosine schedule + 短い warmup — OneCycleLR も悪くない
• AdamW + weight decay 0.05 — 昔の SGD は忘れよう

3 章 · ViT — データが十分なときの champion

ViT(Vision Transformer) は画像を 16x16 のような patch に切って sequence にし、その上に Transformer を載せる。核心の洞察は 「画像に inductive bias が少ないモデルは、データさえあれば CNN を超える」 だった。

2026 年の ViT 派生

• Swin Transformer v2 — window attention、高解像度入力に効率的
• DeiT III — データ効率的な学習レシピ
• EVA-02 — Masked Image Modeling、22B parameter まで scale
• DINOv2 — 自己教師あり学習、ラベルなしで学習された強力 backbone
• SigLIP / SigLIP 2 — contrastive learning ベース、強力な image-text embedding

ViT を選ぶべきとき

Hugging Face transformers で ViT classifier を 1 行

from transformers import AutoImageProcessor, AutoModelForImageClassification
import torch
from PIL import Image

processor = AutoImageProcessor.from_pretrained('facebook/dinov2-large')
model = AutoModelForImageClassification.from_pretrained(
    'facebook/dinov2-large',
    num_labels=12,
    ignore_mismatched_sizes=True,  # head のみ新しく
)

img = Image.open('part.jpg').convert('RGB')
inputs = processor(images=img, return_tensors='pt')
with torch.no_grad():
    outputs = model(**inputs)
pred = outputs.logits.argmax(-1).item()

facebook/dinov2-large の代わりに microsoft/swinv2-large-patch4-window12-192-22k のような backbone でも同じ API だ。

4 章 · object detection — YOLO vs DETR vs RT-DETR

detection は「どこに何があるか」を同時に解く task だ。2026 年時点で実務は大きく 2 つに分かれる。

YOLO family — 圧倒的な実戦シェア

Ultralytics の YOLOv8 から YOLOv12 まで、そして YOLO-NAS、YOLOv9、YOLOv10 などの派生。速度と deployment のしやすさで YOLO はまだ 1 位だ。

from ultralytics import YOLO

# 事前学習モデル load
model = YOLO('yolo11x.pt')

# 自前データセットで fine-tune
results = model.train(
    data='factory_parts.yaml',  # train/val の path + class 名
    epochs=100,
    imgsz=640,
    batch=32,
    device=0,
    optimizer='AdamW',
    lr0=0.001,
    cos_lr=True,
    patience=20,  # early stopping
    project='runs/factory',
)

# ONNX に export(edge 配備)
model.export(format='onnx', dynamic=True, simplify=True)
# TensorRT に export(Jetson)
model.export(format='engine', half=True)

factory_parts.yaml はこんな形だ。

path: /data/factory
train: images/train
val: images/val
names:
  0: scratch
  1: dent
  2: discoloration
  3: missing_screw

YOLO の弱み: NMS ベースなので密集した小さい object に弱く、DETR 系より global context が弱い。

DETR family — NMS 不要の transformer detection

DETR(DEtection TRansformer) は object query と Hungarian matching で NMS を取り除いた。2026 年では RT-DETR が実用的な選択だ。

from transformers import RTDetrV2ForObjectDetection, RTDetrImageProcessor

processor = RTDetrImageProcessor.from_pretrained('PekingU/rtdetr_v2_r50vd')
model = RTDetrV2ForObjectDetection.from_pretrained(
    'PekingU/rtdetr_v2_r50vd',
    num_labels=12,
    ignore_mismatched_sizes=True,
)

YOLO vs DETR — 意思決定

OpenMMLab はいつ使うか

mmdetection、mmsegmentation などの OpenMMLab エコシステムは研究・実験に強い。同じ codebase で 50 種類以上の detection モデルを比較でき、config 1 行で backbone を入れ替えられる。ただし学習曲線が急で、deployment は別 tool が必要。production の最初のモデルとしては Ultralytics の方が圧倒的に速い。

5 章 · segmentation と SAM 2

segmentation は「pixel 単位でどこ」だ。2026 年では SAM 2 がほぼ全ケースの出発点になる。

SAM 2 — 画像と動画の両方を扱う promptable segmentation

Meta が 2024 年 7 月に公開した SAM 2 は 「click・box・mask の prompt を与えれば、どんな object でも分割し、video frame 間で自動 tracking する」 モデルだ。要点:

• image + video 統合 — 同じモデルで両方
• memory attention — video 内で object を追跡するために過去 frame の representation を記憶
• promptable — mask ではなく click/box のような user 入力で分割

from sam2.build_sam import build_sam2
from sam2.sam2_image_predictor import SAM2ImagePredictor
import numpy as np
from PIL import Image

sam2 = build_sam2('configs/sam2.1/sam2.1_hiera_l.yaml', 'sam2.1_hiera_large.pt')
predictor = SAM2ImagePredictor(sam2)

img = np.array(Image.open('part.jpg'))
predictor.set_image(img)

# click 1 回で mask
point_coords = np.array([[450, 320]])
point_labels = np.array([1])  # 1 = foreground
masks, scores, _ = predictor.predict(
    point_coords=point_coords,
    point_labels=point_labels,
    multimask_output=True,
)

SAM 2 の本当の使い方 — 「分割は SAM、分類は別」

SAM 2 はそれが何かを教えてくれない。「この mask は object 1、あの mask は object 2」 と言うだけだ。semantic label が欲しければ 2 段階の pipeline になる。

1. SAM 2 で mask 生成
2. 各 mask 領域を切り出して CLIP または SigLIP で分類

これが 2026 年の「zero-shot segmentation」の標準レシピだ。label データなしで動く。

HQ-SAM、MobileSAM、EfficientSAM の位置

• HQ-SAM — より精密な境界、medical・衛星画像
• MobileSAM / EfficientSAM — edge デバイス用の軽量
• SAM 2.1 — 動画 tracking 精度強化版

6 章 · VLM — 自然言語で画像を扱う時代

Vision-Language Model は 「画像を LLM の入力 token に変換」 する。user は自然言語で問い、モデルは自然言語で答える。

2026 年の主要 VLM

VLM を「prompt だけ」で使うとき

label データがほぼなく、class が頻繁に変わり、「なぜそう判断したか」の説明が必要な場合 — VLM に写真と system prompt だけ投げるのが ROI 最高だ。

import anthropic
import base64

client = anthropic.Anthropic()

with open('part.jpg', 'rb') as f:
    img_b64 = base64.standard_b64encode(f.read()).decode()

resp = client.messages.create(
    model='claude-opus-4-7',
    max_tokens=512,
    system=(
        'あなたは自動車部品の検査員だ。写真を見て、次の JSON のみで答えよ。'
        'schema: {"defect": one of [scratch, dent, discoloration, missing_screw, none], '
        '"severity": one of [low, medium, high], "reasoning": short string}'
    ),
    messages=[{
        'role': 'user',
        'content': [
            {'type': 'image', 'source': {'type': 'base64', 'media_type': 'image/jpeg', 'data': img_b64}},
            {'type': 'text', 'text': 'この部品を検査せよ。'},
        ],
    }],
)
print(resp.content[0].text)

VLM の限界 — 万能ではない

• cost — 写真 1 枚あたり 0.01〜0.05 ドル。1 日 30 万枚で月 9 万〜45 万ドル。自前学習 cost と比較せよ。
• latency — 200 ms〜2 s。30 fps の edge では使えない。
• 非決定性 — 同じ写真に違う答えが出ることがある。閾値ベースの意思決定には calibration が必要。
• JSON を守らない — response_format または tool use で強制する必要がある。
• データガバナンス — 写真を外部 API に送って良いか。法務と先に相談しよう。

7 章 · どの task → どの architecture matrix

上の 6 章を 1 枚の表に圧縮する。最初のモデルを選ぶときはこの表だけで 80% は正解できる。

1 行ルール: データ少なら事前学習済みの巨大 backbone + 小さな head。データ多なら自前学習。label がないなら VLM または embedding。

8 章 · データ — どれくらい、どうやって、どこから

「モデルよりデータが重要」というクリシェは 2026 年でも事実だ。

必要なデータ量(目安)

2026 年でも生きている公開データセット

• ImageNet-22k / -1k — classification 事前学習の不変の基準
• COCO 2017 — detection・keypoint・caption、まだ benchmark の標準
• Open Images V7 — 900 万枚以上、弱い label を含む
• LAION-5B / DataComp — CLIP 系学習向け大規模 image-text pair(著作権要確認)
• LVIS — 1,200 以上の class、long-tail detection
• ADE20K、Cityscapes、Mapillary — segmentation
• DocVQA、ChartQA、InfographicVQA — document/chart VQA
• OpenX-Embodiment、Ego4D — robotics・1 人称 video
• SA-1B — SAM 学習データ、11 億 mask

labeling tool — 2026 年の実用比較

2026 年の labeling の秘密: 1 次は SAM 2 + Grounding DINO で自動 labeling → Roboflow/CVAT で人が修正。labeling 時間が 5〜10 倍縮む。

9 章 · train vs fine-tune vs prompt — cost モデル

ルール: データが増えるほど学習 cost が正当化される。推論 traffic が増えるほど自前モデルが正当化される。 両軸を同時に見る必要がある。

LoRA / QLoRA — VLM fine-tune の実戦標準

VLM を full fine-tune するのは 80 GB VRAM 4 枚時代でも厳しい。LoRA が答えだ。

from transformers import AutoModelForVision2Seq, AutoProcessor
from peft import LoraConfig, get_peft_model
from trl import SFTTrainer, SFTConfig
import torch

model_id = 'Qwen/Qwen2.5-VL-7B-Instruct'
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForVision2Seq.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map='auto',
)

lora_cfg = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=['q_proj', 'k_proj', 'v_proj', 'o_proj'],
    lora_dropout=0.05,
    bias='none',
    task_type='CAUSAL_LM',
)
model = get_peft_model(model, lora_cfg)
model.print_trainable_parameters()  # 通常 0.1〜1% のみ学習

cfg = SFTConfig(
    output_dir='runs/qwen-vl-defect',
    num_train_epochs=3,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=8,
    learning_rate=1e-4,
    lr_scheduler_type='cosine',
    warmup_ratio=0.03,
    bf16=True,
    gradient_checkpointing=True,
    logging_steps=20,
    save_strategy='epoch',
)

# train_dataset は {"image": PIL.Image, "messages": [...]} の sequence
trainer = SFTTrainer(model=model, args=cfg, train_dataset=train_ds, processing_class=processor)
trainer.train()

QLoRA(4 bit 量子化 + LoRA) なら 24 GB VRAM 1 枚で 7B の VLM の fine-tune が可能だ。70B 級は 80 GB 1 枚。

10 章 · deployment — ONNX、TensorRT、Core ML、TFLite

学習は終わりの始まりだ。deployment 段階で誤った選択をすると推論 cost が 10 倍かかる。

deployment target 別推奨

PyTorch → ONNX → TensorRT の流れ

import torch
import torch.onnx
from ultralytics import YOLO

model = YOLO('runs/factory/best.pt')

# 1) ONNX
model.export(format='onnx', dynamic=True, simplify=True, opset=17)

# 2) TensorRT(NVIDIA GPU) — Ultralytics が直接 support
model.export(format='engine', half=True, workspace=4)

手動でやるなら trtexec --onnx=model.onnx --saveEngine=model.engine --fp16 が最も簡単だ。INT8 量子化には calibration dataset が必要。

Core ML / TFLite — mobile

# Core ML
import coremltools as ct
mlmodel = ct.convert(traced_model, inputs=[ct.ImageType(shape=(1, 3, 224, 224))])
mlmodel.save('Model.mlpackage')

# TFLite(PyTorch → TF は ai-edge-torch 推奨)
import ai_edge_torch
edge_model = ai_edge_torch.convert(model.eval(), sample_inputs)
edge_model.export('model.tflite')

11 章 · failure mode — 現場でぶつかる本当の問題たち

現場の格言: 「accuracy が出ないならモデルを変えるな、データを見直せ。5 回中 4 回はデータの問題だ。」

12 章 · decision tree — 30 秒で決める

新しい vision 問題が来たらこの順序で問う。

1. 「この問題、VLM 1 発で解ける?」 — Claude/Gemini Vision に写真 10 枚を手で投げてみよう。90% accuracy が出るならそれが baseline だ。
2. 「label データはあるか?」 — なければ VLM または zero-shot(CLIP、Grounding DINO、SAM 2)。
3. 「label が 1 万枚以上あるか?」 — Yes なら自前学習。No なら事前学習 + fine-tune。
4. 「edge で動かす必要があるか?」 — Yes なら CNN または小さい YOLO。No なら ViT 自由。
5. 「30 fps 以上必要か?」 — Yes なら YOLO + TensorRT/Core ML。No なら DETR 系も OK。
6. 「なぜそう判断したかの説明が必要か?」 — Yes なら VLM または attention 可視化。No なら通常モデル。
7. **「エラーの代償が大きいか?」(medical・自動運転) — Yes なら ensemble、calibration、human-in-the-loop。

この 7 つの問いで最初のモデル選択の 80% は終わる。

エピローグ — checklist、anti-pattern、次回予告

最初の vision モデルを作る前の checklist

• データの label 分布を見たか?(class imbalance は学習前に知るべき)
• validation set が train と時間 / source で重複していないか?
• baseline はあるか?(最も単純なモデル、または人間の accuracy、または常に多数 class)
• VLM の 1 発呼び出しでの accuracy と cost は測定したか?
• 学習 cost と推論 cost を一緒に比較したか?
• deployment target の memory・latency 制約を知っているか?
• annotator 間合意(IAA) を測定したか?
• corner case を 100 枚集めた別 evaluation set を作ったか?
• monitoring — production distribution shift をどう検出するか?
• rollback — モデルが壊れたとき以前の version に戻せるか?

よく見る anti-pattern

• 「最新の SOTA は?」で始める — まずデータを見よう。
• 事前学習なしで ViT から始める — 1 万枚以下ならほぼ失敗する。
• validation set を学習中に何度も覗いてチューニング — 実質 training data。別の test set が必要。
• mAP だけ見て deploy — class 別 PR curve、小さい object の metric、推論 latency も一緒に。
• VLM の結果を post-processing なしで信用 — JSON schema validation、fallback、caching。
• 単一モデルで全 class を扱おうとする欲 — 頻出 class と long-tail を分ける。
• augmentation をモデルより後で気にする — augmentation がモデル選択より accuracy に効くことが多い。
• 学習 code と評価 code の transform 不一致 — 最もよくある debug 時間の浪費理由ナンバー 1。

次回予告

• 「vision モデルの運用 — distribution shift 検出、A/B、canary、active learning loop まで」
• 「VLM で labeling を自動化する — Claude/Gemini/Qwen-VL で annotation を 90% 自動化する pipeline」
• 「edge vision 推論 — Jetson、Coral、iPhone、Android で同じモデルを動かす」

参考 / References

architecture 論文

• ViT — "An Image is Worth 16x16 Words" — https://arxiv.org/abs/2010.11929
• Swin Transformer v2 — https://arxiv.org/abs/2111.09883
• ConvNeXt v2 — https://arxiv.org/abs/2301.00808
• DINOv2 — https://arxiv.org/abs/2304.07193
• DETR — "End-to-End Object Detection with Transformers" — https://arxiv.org/abs/2005.12872
• RT-DETR — https://arxiv.org/abs/2304.08069
• SAM — https://arxiv.org/abs/2304.02643
• SAM 2 — https://arxiv.org/abs/2408.00714
• LLaVA — https://arxiv.org/abs/2304.08485
• Qwen2.5-VL — https://arxiv.org/abs/2502.13923
• InternVL — https://arxiv.org/abs/2312.14238
• Grounding DINO — https://arxiv.org/abs/2303.05499
• Florence-2 — https://arxiv.org/abs/2311.06242
• LoRA — https://arxiv.org/abs/2106.09685
• QLoRA — https://arxiv.org/abs/2305.14314

tool / library

• timm(PyTorch Image Models) — https://github.com/huggingface/pytorch-image-models
• Hugging Face transformers — https://huggingface.co/docs/transformers
• Ultralytics YOLO — https://docs.ultralytics.com/
• OpenMMLab MMDetection — https://github.com/open-mmlab/mmdetection
• Segment Anything 2 — https://github.com/facebookresearch/sam2
• PEFT(LoRA/QLoRA) — https://github.com/huggingface/peft
• TRL(SFT) — https://github.com/huggingface/trl

labeling tool

• Label Studio — https://labelstud.io/
• CVAT — https://www.cvat.ai/
• Roboflow — https://roboflow.com/
• V7 Darwin — https://www.v7labs.com/
• Encord — https://encord.com/

dataset

• ImageNet — https://www.image-net.org/
• COCO — https://cocodataset.org/
• Open Images V7 — https://storage.googleapis.com/openimages/web/index.html
• LAION — https://laion.ai/
• LVIS — https://www.lvisdataset.org/
• ADE20K — https://groups.csail.mit.edu/vision/datasets/ADE20K/
• SA-1B — https://ai.meta.com/datasets/segment-anything/

deployment / 推論

• ONNX Runtime — https://onnxruntime.ai/
• NVIDIA TensorRT — https://developer.nvidia.com/tensorrt
• Apple Core ML Tools — https://github.com/apple/coremltools
• ai-edge-torch(PyTorch → TFLite) — https://github.com/google-ai-edge/ai-edge-torch
• OpenVINO — https://docs.openvino.ai/

VLM API

• Anthropic Claude Vision — https://docs.anthropic.com/en/docs/build-with-claude/vision
• Google Gemini Vision — https://ai.google.dev/gemini-api/docs/vision
• OpenAI Vision — https://platform.openai.com/docs/guides/vision