第3章: マルチモーダル生成

3.1 テキストから画像生成

テキストから画像モデルは、自然言語の説明から画像を生成します。この機能はクリエイティブワークフローを変革し、ビジュアルコンテンツ作成を民主化しました。

主要なテキストから画像モデル（2025年）

拡散モデル: 基盤技術

現代のテキストから画像モデルは拡散を使用します。これは画像へのノイズの段階的な追加を逆転することを学習するプロセスです。

潜在拡散（Stable Diffusionアーキテクチャ）

Stable Diffusionでの画像生成

# Stable Diffusionによるテキストから画像
from diffusers import StableDiffusionPipeline
import torch

# モデルの読み込み
pipe = StableDiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    torch_dtype=torch.float16,
    variant="fp16"
)
pipe = pipe.to("cuda")

# 画像の生成
prompt = "桜が咲く静かな日本庭園、鯉の池、\
          伝統的な木製の橋、朝霧、フォトリアリスティック、8k"

negative_prompt = "ぼやけた、低品質、歪んだ、醜い"

image = pipe(
    prompt=prompt,
    negative_prompt=negative_prompt,
    num_inference_steps=50,
    guidance_scale=7.5,
    height=1024,
    width=1024
).images[0]

image.save("japanese_garden.png")

DALL-E 3 APIの使用

# OpenAI API経由のDALL-E 3
import openai
from PIL import Image
import requests
from io import BytesIO

client = openai.OpenAI(api_key="your-api-key")

response = client.images.generate(
    model="dall-e-3",
    prompt="空飛ぶ車がある未来の東京の夜景、\
            日本語のネオンサイン、サイバーパンク美学",
    size="1024x1024",
    quality="hd",
    n=1
)

# 画像をダウンロードして表示
image_url = response.data[0].url
image_response = requests.get(image_url)
image = Image.open(BytesIO(image_response.content))
image.save("cyberpunk_tokyo.png")

# 修正されたプロンプトを取得（DALL-E 3はプロンプトを修正する場合がある）
print(f"修正されたプロンプト: {response.data[0].revised_prompt}")

3.2 動画理解モデル

動画理解は、画像理解に時間的推論を拡張します - シーンが時間とともにどのように変化するかを理解します。

動画理解の課題

• 時間的推論: 因果関係、イベントのシーケンスの理解
• 長距離依存性: 動画の初期のイベントが後の解釈に影響
• 計算コスト: 動画ごとに数百フレームを処理
• 行動認識: 人物/オブジェクトが何をしているかを識別

動画トークン化戦略

# 時間トークンによる動画理解
import torch
import torch.nn as nn
from transformers import CLIPProcessor, CLIPModel

class SimpleVideoEncoder(nn.Module):
    """フレームを処理し時間情報を追加して動画をエンコード"""

    def __init__(self, clip_model_name="openai/clip-vit-base-patch32"):
        super().__init__()
        self.clip = CLIPModel.from_pretrained(clip_model_name)
        self.clip_processor = CLIPProcessor.from_pretrained(clip_model_name)

        # 学習可能な時間位置埋め込み
        self.temporal_embed = nn.Embedding(100, 512)  # 最大100フレーム

        # 時間アテンション
        self.temporal_attn = nn.TransformerEncoder(
            nn.TransformerEncoderLayer(d_model=512, nhead=8, batch_first=True),
            num_layers=2
        )

    def forward(self, frames):
        """
        frames: PIL画像のリストまたはテンソル (B, T, C, H, W)
        """
        B, T = len(frames), len(frames[0])

        # CLIPでフレーム特徴を抽出
        frame_features = []
        for batch in frames:
            inputs = self.clip_processor(images=batch, return_tensors="pt")
            with torch.no_grad():
                features = self.clip.get_image_features(**inputs)
            frame_features.append(features)

        # スタック: (B, T, D)
        frame_features = torch.stack(frame_features)

        # 時間位置埋め込みを追加
        positions = torch.arange(T).unsqueeze(0).expand(B, -1)
        temporal_pos = self.temporal_embed(positions)
        frame_features = frame_features + temporal_pos

        # 時間アテンションを適用
        video_features = self.temporal_attn(frame_features)

        # 動画レベル表現にプール
        video_embedding = video_features.mean(dim=1)

        return video_embedding, video_features

最先端: Molmo 2（2025年）

AI2のMolmo 2は動画理解の現在の最前線を代表しています。

• 軽量な時間トークンで動画フレームを処理
• 視覚トークンとタイムスタンプ情報をインターリーブ
• 動画追跡ベンチマークでGemini 3 Proを上回る
• 動画コンテンツに関するマルチターン会話をサポート

3.3 Any-to-Anyマルチモーダルモデル

「Any-to-Any」モデルは複数の入力モダリティを受け付け、複数の出力モダリティを生成できます。

GPT-4V/4oの機能

# GPT-4o: マルチモーダル推論
import openai
import base64

client = openai.OpenAI()

def encode_image_to_base64(image_path):
    with open(image_path, "rb") as f:
        return base64.b64encode(f.read()).decode('utf-8')

# 複数の画像を一緒に分析
def compare_images(image_paths, question):
    content = [{"type": "text", "text": question}]

    for path in image_paths:
        content.append({
            "type": "image_url",
            "image_url": {
                "url": f"data:image/jpeg;base64,{encode_image_to_base64(path)}"
            }
        })

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": content}],
        max_tokens=500
    )

    return response.choices[0].message.content

# 例: ビフォー/アフター画像を比較
result = compare_images(
    ["room_before.jpg", "room_after.jpg"],
    "この部屋にどんな変更が加えられましたか？具体的な違いを挙げてください。"
)
print(result)

DeepSeek Janus-Pro: オープンソース統一モデル

Janus-Pro（2025年1月）は統一された理解と生成を持つ画期的なオープンソースモデルです。

# Janus-Proで理解と生成
from transformers import AutoModelForCausalLM, AutoProcessor
import torch

# Janus-Proの読み込み
model = AutoModelForCausalLM.from_pretrained(
    "deepseek-ai/Janus-Pro-7B",
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True
)
processor = AutoProcessor.from_pretrained(
    "deepseek-ai/Janus-Pro-7B",
    trust_remote_code=True
)

# 画像理解
def understand_image(image_path, question):
    from PIL import Image
    image = Image.open(image_path)

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

    inputs = processor(conversation, return_tensors="pt").to(model.device)
    outputs = model.generate(**inputs, max_new_tokens=256)
    return processor.decode(outputs[0], skip_special_tokens=True)

# 画像生成
def generate_image(prompt):
    inputs = processor(
        text=prompt,
        return_tensors="pt",
        mode="generation"
    ).to(model.device)

    outputs = model.generate(**inputs, max_new_tokens=1024)
    image = processor.decode_image(outputs)
    return image

# 使用例
answer = understand_image("chart.png", "このチャートはどのようなトレンドを示していますか？")
generated = generate_image("夕日に照らされた雄大な山岳風景")

3.4 音声-視覚モデル

音声-視覚モデルはスピーチ、サウンド、視覚情報を統合します。

応用

• 音声-視覚音声認識（AVSR）: より良いASRのために唇の動き + 音声を使用
• 音声付き動画キャプション: 視覚と音声コンテンツの両方を説明
• 音源定位: 動画内で音がどこから来るかを特定
• マルチモーダル感情分析: 表情、トーン、言葉を組み合わせる

# 音声-視覚処理の例
import torch
import torchaudio
from transformers import Wav2Vec2Processor, Wav2Vec2Model

class AudioVisualEncoder(nn.Module):
    """音声と視覚特徴を組み合わせる"""

    def __init__(self, visual_dim=512, audio_dim=768, hidden_dim=512):
        super().__init__()

        # 音声エンコーダー（Wav2Vec2）
        self.audio_processor = Wav2Vec2Processor.from_pretrained(
            "facebook/wav2vec2-base"
        )
        self.audio_encoder = Wav2Vec2Model.from_pretrained(
            "facebook/wav2vec2-base"
        )

        # 射影層
        self.visual_proj = nn.Linear(visual_dim, hidden_dim)
        self.audio_proj = nn.Linear(audio_dim, hidden_dim)

        # クロスモーダルアテンション
        self.cross_attn = nn.MultiheadAttention(hidden_dim, num_heads=8)

        # 融合
        self.fusion = nn.Linear(hidden_dim * 2, hidden_dim)

    def forward(self, visual_features, audio_waveform, sample_rate=16000):
        # 音声を処理
        audio_inputs = self.audio_processor(
            audio_waveform,
            sampling_rate=sample_rate,
            return_tensors="pt"
        )
        audio_features = self.audio_encoder(**audio_inputs).last_hidden_state

        # 共通空間に射影
        visual_proj = self.visual_proj(visual_features)
        audio_proj = self.audio_proj(audio_features)

        # クロスモーダルアテンション（音声が視覚にクエリ）
        attended, _ = self.cross_attn(
            audio_proj.transpose(0, 1),
            visual_proj.transpose(0, 1),
            visual_proj.transpose(0, 1)
        )
        attended = attended.transpose(0, 1)

        # モダリティを融合
        combined = torch.cat([audio_proj, attended], dim=-1)
        fused = self.fusion(combined)

        return fused

3.5 実践的な考慮事項

適切なモデルの選択

3.6 まとめ

演習

演習1: 画像用プロンプトエンジニアリング

DALL-EとStable Diffusionで同じコンセプトを生成してください。結果を比較し、プロンプトの修正が出力品質にどう影響するか分析してください。

演習2: 動画フレーム分析

動画からキーフレームを抽出し、GPT-4Vを使って何が起きているかを説明してください。次に、時間平均を実装して動画サマリーを作成してください。

演習3: モデル比較

視覚的QAタスクで、GPT-4V、Claude 3、Janus-Proからの応答を比較してください。各モデルの長所と短所を分析してください。

演習4: コスト最適化

品質要件と予算制約に基づいて画像生成リクエストを異なるモデルにルーティングするシステムを設計してください。