マルチモーダル大規模モデルデプロイ実践：視覚言語モデル推論と本番最適化

AI与大数据

概要

  • マルチモーダル大規模モデル（VLM）は2026年に研究室から本番環境へ：Qwen2.5-VL、InternVL3、LLaVA-OneVisionの三強体制
  • VLM推論のVRAMボトルネックはVision Encoderにあり：1枚の1080p画像で576〜2,048の視覚Tokenを生成
  • 動的解像度処理がVLMの中核的な課題：画像サイズによりToken数が最大4倍変動
  • 視覚Token圧縮（Pooling/Projection）によりVLM推論レイテンシを40%以上削減可能
  • 本記事ではモデル選定から本番デプロイまでの完全なソリューションを提供します（Qwen2.5-VL K8sデプロイ含む）

目次

マルチモーダル大規模モデル2026年の状況

主要VLM比較

項目 Qwen2.5-VL-72B InternVL3-78B LLaVA-OneVision-72B Gemini 2.5 Pro
開発元 Alibaba 上海AI Lab AI2 Google
LLM基盤 Qwen2.5-72B InternLM3 Qwen2-72B Gemini
視覚エンコーダ ViT (675M) InternViT (6B) SigLIP (0.4B) 独自
最大解像度 動的（メガピクセル） 4K 768x768 動的
動画理解 ✅ ✅ ✅ ✅
OCR ✅ 強 ✅ 強 ⚠️ 普通 ✅ 強
オープンソース ✅ ✅ ✅ ❌
MMBoardスコア 82.5 83.1 79.8 85.2

VLM選定の判断基準

ユースケース 推奨モデル 理由
汎用画像理解 Qwen2.5-VL-7B デプロイが簡単、日本語・中国語に強い
高精度OCR InternVL3-26B OCR能力が最も高い
動画理解 Qwen2.5-VL-72B 動的解像度＋動画対応
エッジデプロイ Qwen2.5-VL-3B モデルが小さい、高速
クローズドソースAPI Gemini 2.5 Pro 総合的に最も優秀

VLMアーキテクチャ解説：画像からTokenへ

VLM 3段階アーキテクチャ

┌──────────────────────────────────────────────────────────────┐
│              VLM 3段階アーキテクチャ                            │
│                                                                │
│  段階1: 視覚エンコーディング                                   │
│  ┌──────────┐   ┌──────────────┐   ┌──────────────────┐     │
│  │ 原始     │──→│ Vision       │──→│ 視覚Token        │     │
│  │ 画像     │   │ Encoder(ViT) │   │ シーケンス        │     │
│  │ 1080p    │   │              │   │ 576-2048 tokens  │     │
│  └──────────┘   └──────────────┘   └──────────────────┘     │
│                         ↓                                      │
│  段階2: 視覚-言語投影                                         │
│  ┌──────────────────┐   ┌──────────────────┐               │
│  │ 視覚Token        │──→│ Projection       │──→ 言語空間   │
│  │ シーケンス        │   │ (MLP/Q-Former)   │   Token       │
│  │ 576-2048 tokens  │   │                  │               │
│  └──────────────────┘   └──────────────────┘               │
│                         ↓                                      │
│  段階3: 言語モデル生成                                        │
│  ┌──────────────────────────────────────────────────┐       │
│  │ LLM (Qwen2.5-7B)                                 │       │
│  │ 入力: [視覚Token] + [テキストToken]               │       │
│  │ 出力: テキスト回答                                │       │
│  └──────────────────────────────────────────────────┘       │
└──────────────────────────────────────────────────────────────┘

視覚Token数の計算

画像解像度 ViT Patchサイズ 視覚Token数 VRAM使用量（FP16）
224x224 14x14 256 0.5MB
512x512 14x14 1,296 2.5MB
1080p 14x14 5,616 11MB
4K 14x14 22,528 44MB

VLM推論最適化：視覚Token圧縮

3つのToken圧縮戦略

戦略 圧縮比 精度低下 レイテンシ削減 適用シナリオ
2x2 Pooling 4x 1-2% 35% 汎用推奨
投影層圧縮 4-8x 2-3% 40% 高スループットシナリオ
動的解像度 適応的 0% 20-50% 混合解像度

2x2 Poolingの実装

import torch
import torch.nn as nn

class VisualTokenPooler(nn.Module):
    def __init__(self, pool_size: int = 2):
        super().__init__()
        self.pool_size = pool_size

    def forward(self, visual_tokens: torch.Tensor) -> torch.Tensor:
        batch_size, seq_len, hidden_dim = visual_tokens.shape
        h = w = int(seq_len ** 0.5)
        tokens = visual_tokens.view(batch_size, h, w, hidden_dim)
        tokens = tokens.permute(0, 3, 1, 2)
        pooled = nn.functional.avg_pool2d(tokens, kernel_size=self.pool_size)
        pooled = pooled.permute(0, 2, 3, 1)
        _, new_h, new_w, _ = pooled.shape
        return pooled.reshape(batch_size, new_h * new_w, hidden_dim)

動的解像度処理

from qwen_vl_utils import process_vision_info

def prepare_vlm_inputs(image_path: str, question: str, tokenizer, max_pixels: int = 1003520):
    messages = [{
        "role": "user",
        "content": [
            {"type": "image", "image": image_path, "resized_height": None, "resized_width": None},
            {"type": "text", "text": question},
        ],
    }]

    text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
    image_inputs, video_inputs = process_vision_info(messages)

    inputs = tokenizer(
        text=[text],
        images=image_inputs,
        videos=video_inputs,
        padding=True,
        return_tensors="pt",
    ).to("cuda")

    return inputs

画像理解パイプライン：アップロードから回答まで

完全パイプライン実装

from transformers import Qwen2_5_VLForConditionalGeneration, AutoProcessor
from qwen_vl_utils import process_vision_info
import base64
import io
from PIL import Image

class ImageUnderstandingPipeline:
    def __init__(self, model_id: str = "Qwen/Qwen2.5-VL-7B-Instruct"):
        self.model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
            model_id,
            torch_dtype=torch.bfloat16,
            device_map="auto",
        )
        self.processor = AutoProcessor.from_pretrained(model_id)

    async def understand(self, image_base64: str, question: str) -> str:
        image_bytes = base64.b64decode(image_base64)
        image = Image.open(io.BytesIO(image_bytes))

        messages = [{
            "role": "user",
            "content": [
                {"type": "image", "image": image},
                {"type": "text", "text": question},
            ],
        }]

        text = self.processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
        image_inputs, video_inputs = process_vision_info(messages)
        inputs = self.processor(
            text=[text],
            images=image_inputs,
            videos=video_inputs,
            padding=True,
            return_tensors="pt",
        ).to(self.model.device)

        output_ids = self.model.generate(**inputs, max_new_tokens=1024)
        generated_ids = [output_ids[len(input_ids):] for input_ids, output_ids in zip(inputs.input_ids, output_ids)]
        output_text = self.processor.batch_decode(generated_ids, skip_special_tokens=True)

        return output_text[0]

    async def batch_understand(self, images: list[str], question: str) -> list[str]:
        tasks = [self.understand(img, question) for img in images]
        return await asyncio.gather(*tasks)

VLM推論パフォーマンスベンチマーク

モデル GPU 画像解像度 Prefill(秒) Decode(tok/秒) 総VRAM
Qwen2.5-VL-7B A100x1 512x512 0.8 2800 18GB
Qwen2.5-VL-7B A100x1 1080p 2.5 2200 24GB
Qwen2.5-VL-7B+Pool A100x1 1080p 1.5 2600 20GB
Qwen2.5-VL-72B H100x4 1080p 5.2 680 85GB

Qwen2.5-VL本番デプロイ

vLLMによるVLMデプロイ

python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-VL-7B-Instruct \
    --host 0.0.0.0 \
    --port 8000 \
    --tensor-parallel-size 2 \
    --gpu-memory-utilization 0.92 \
    --max-model-len 8192 \
    --limit-mm-per-prompt image=5 \
    --enable-prefix-caching

K8s Deployment

apiVersion: apps/v1
kind: Deployment
metadata:
  name: qwen25-vl-7b
  namespace: ai-inference
spec:
  replicas: 2
  selector:
    matchLabels:
      app: qwen25-vl-7b
  template:
    spec:
      containers:
        - name: vllm
          image: vllm/vllm-openai:v0.8.0
          ports:
            - containerPort: 8000
          resources:
            limits:
              nvidia.com/gpu: 2
            requests:
              nvidia.com/gpu: 2
              cpu: "4"
              memory: 16Gi
          args:
            - --model
            - Qwen/Qwen2.5-VL-7B-Instruct
            - --host
            - "0.0.0.0"
            - --port
            - "8000"
            - --tensor-parallel-size
            - "2"
            - --gpu-memory-utilization
            - "0.92"
            - --max-model-len
            - "8192"
            - --limit-mm-per-prompt
            - image=5
            - --enable-prefix-caching
          livenessProbe:
            httpGet:
              path: /health
              port: 8000
            initialDelaySeconds: 180
            periodSeconds: 30

API呼び出し例

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="not-needed")

with open("chart.png", "rb") as f:
    import base64
    image_b64 = base64.b64encode(f.read()).decode()

response = client.chat.completions.create(
    model="Qwen/Qwen2.5-VL-7B-Instruct",
    messages=[{
        "role": "user",
        "content": [
            {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{image_b64}"}},
            {"type": "text", "text": "このチャートの主要なトレンドを分析してください"},
        ],
    }],
    max_tokens=1024,
)

print(response.choices[0].message.content)

まとめと関連記事

マルチモーダル大規模モデルは研究室から本番環境へと移行しました。Qwen2.5-VLは動的解像度と強力なOCR能力によりオープンソースVLMの第一選択となり、視覚Token圧縮により推論レイテンシを40%以上削減できます。VLMデプロイの鍵は、画像解像度とToken数のバランスを適切に取ることです。

デプロイの要点まとめ：

  1. VLM選定：汎用はQwen2.5-VL、OCRはInternVL3、クローズドソースはGemini
  2. 視覚TokenがVRAMの杀手：1080p画像で5,616個のTokenを生成
  3. 2x2 Poolingが最も実用的なToken圧縮戦略、精度低下2%未満
  4. vLLMはVLMデプロイをネイティブサポート、--limit-mm-per-promptで同時画像数を制御
  5. 動的解像度処理がVLMとテキストのみLLMの最大の違い

関連記事：

権威ある参考資料：

ブラウザローカルツールを無料で試す →

#多模态大模型部署#视觉语言模型#VLM推理优化#图像理解模型#Qwen2.5-VL部署#2026