LLaVAの仕組みと概念モデルの実装

import io
import torch
import torch.nn as nn
from transformers import CLIPVisionModel, AutoModelForCausalLM, AutoTokenizer, AutoImageProcessor
import requests
from PIL import Image
from torch.optim import AdamW
import json
import matplotlib.pyplot as plt

# 簡易的なLLaVAモデルの定義クラス
class SimpleHuggingFaceLLaVA(nn.Module):
    def __init__(self, clip_model_id="openai/clip-vit-base-patch32", llm_model_id="gpt2"):
        super().__init__()
        # 画像の特徴量を抽出するフリーズ対象のVision Encoder (CLIP)
        self.vision_encoder = CLIPVisionModel.from_pretrained(clip_model_id)
        # テキスト生成を担当する causal言語モデル (ここでは軽量化のためGPT-2)
        self.llm = AutoModelForCausalLM.from_pretrained(llm_model_id)

        # 各エンコーダの出力次元数を取得して、プロジェクタを定義
        vision_hidden_size = self.vision_encoder.config.hidden_size
        text_hidden_size = self.llm.config.hidden_size

        # ビジュアル特徴量（画像次元）をテキスト特徴量（言語次元）に変換する「ビジュアル・プロジェクタ」
        self.projector = nn.Linear(vision_hidden_size, text_hidden_size)

    def forward(self, pixel_values, input_ids, labels=None):
        # 1. Vision Encoderから画像の特徴マップを抽出
        vision_outputs = self.vision_encoder(pixel_values=pixel_values)
        # 2. 特徴マップをプロジェクタに通してテキスト空間へ投影: 次元は (バッチ数, 画像トークン数, 言語モデル次元) になる
        visual_embeds = self.projector(vision_outputs.last_hidden_state)
        # 3. 言語モデルの埋め込み層からテキストの埋め込みベクトルを取得
        text_embeds = self.llm.get_input_embeddings()(input_ids)

        # 4. 画像とテキストの埋め込みベクトルをシーケンス（時系列）方向に結合して、マルチモーダル入力を構成
        multimodal_embeds = torch.cat([visual_embeds, text_embeds], dim=1)

        # 5. ラベル（正解データ）がある場合、画像部分の損失計算をスキップするように処理
        if labels is not None:
            batch_size = labels.shape[0]
            num_image_tokens = visual_embeds.shape[1]
            # 画像トークンの位置に対応するラベルには、クロスエントロピー損失で無視される特別な値 -100 を敷き詰める
            ignore_labels = torch.full((batch_size, num_image_tokens), -100, dtype=labels.dtype, device=labels.device)
            # 画像用のダミーラベルと、本物のテキストラベルを結合
            labels = torch.cat([ignore_labels, labels], dim=1)

        # 結合した埋め込みベクトルと言い換えラベルを言語モデルに流して順伝播
        return self.llm(inputs_embeds=multimodal_embeds, labels=labels)

    def generate(self, pixel_values, input_ids, max_new_tokens=30):
        # 推論（テキスト生成）用の処理。forwardと同様に埋め込みベクトルを結合
        vision_outputs = self.vision_encoder(pixel_values=pixel_values)
        visual_embeds = self.projector(vision_outputs.last_hidden_state)
        text_embeds = self.llm.get_input_embeddings()(input_ids)
        multimodal_embeds = torch.cat([visual_embeds, text_embeds], dim=1)

        # 結合したマルチモーダル特徴量を入力として自動トークン生成を実行
        generated_ids = self.llm.generate(
            inputs_embeds=multimodal_embeds,
            max_new_tokens=max_new_tokens,
            pad_token_id=self.llm.config.eos_token_id
        )
        return generated_ids

    # Phase 1 用の設定（プロジェクタのみ学習）
    # 画像エンコーダと言語モデルの重みを固定（勾配計算をオフ）し、接続層であるプロジェクタのみを更新可能にします
    def setup_for_pretraining(self):
        for param in self.vision_encoder.parameters(): param.requires_grad = False
        for param in self.llm.parameters(): param.requires_grad = False
        for param in self.projector.parameters(): param.requires_grad = True

    # Phase 2 用の設定（プロジェクタ ＋ LLM を学習）
    # 画像エンコーダはフリーズしたまま、プロジェクタと言語モデルの両方を更新できるように解放します
    def setup_for_finetuning(self):
        for param in self.vision_encoder.parameters(): param.requires_grad = False
        for param in self.projector.parameters(): param.requires_grad = True
        for param in self.llm.parameters(): param.requires_grad = True

# 利用可能な最高速の計算デバイス（GPU、Apple Silicon用のMPS、またはCPU）を自動判別
device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"
print(f"使用デバイス: {device}")

# 定義した簡易LLaVAモデルのインスタンスを生成し、選択したデバイスへ転送
model = SimpleHuggingFaceLLaVA().to(device)

# 画像をCLIPが理解できるテンソルへ正規化するプロセッサのロード
image_processor = AutoImageProcessor.from_pretrained("openai/clip-vit-base-patch32")
# GPT-2のテキストトークナイザのロード
tokenizer = AutoTokenizer.from_pretrained("gpt2")
# GPT-2には標準でパディングトークンがないため、EOS（終了トークン）で代用
if tokenizer.pad_token is None:
    tokenizer.pad_token = tokenizer.eos_token

# 【注意】テストに使用している猫の画像はWikimedia Commonsのコンテンツです。
# クリエイティブ・コモンズ（CC）ライセンスに基づき、記事の末尾などで
# クレジット表記（作者名、ライセンス種別）を行う必要があります。
print("テスト用画像を読み込み中...")
wiki_image_url = "https://upload.wikimedia.org/wikipedia/commons/thumb/1/15/Cat_August_2010-4.jpg/1920px-Cat_August_2010-4.jpg"

headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)'}
response = requests.get(wiki_image_url, headers=headers)

# 取得したバイナリデータをメモリ上で画像に変換
image = Image.open(io.BytesIO(response.content)).convert('RGB')

# 過学習させるための手作りテキスト
# Phase 1用（単なる説明文）
caption = "壁の上で寝ている猫です。"
# Phase 2用（対話形式）
human_text = "この画像に写っている動物は何ですか？"
gpt_text = "壁の上で寝ている猫です。"

image_inputs = image_processor(images=image, return_tensors="pt").to(device)

print("\n=== Phase 1: 事前学習（プロジェクタのみ最適化）を開始 ===")
model.setup_for_pretraining()
optimizer_p1 = AdamW(filter(lambda p: p.requires_grad, model.parameters()), lr=1e-3) # 過学習させるため少し高め

model.train()
for epoch in range(20): # 確実に記憶させるため20回ループ
    text_inputs = tokenizer(caption, return_tensors="pt", truncation=True, max_length=512).to(device)
    
    outputs = model(pixel_values=image_inputs["pixel_values"], input_ids=text_inputs["input_ids"], labels=text_inputs["input_ids"])
    loss = outputs.loss

    loss.backward()
    optimizer_p1.step()
    optimizer_p1.zero_grad()
    
    if (epoch + 1) % 5 == 0: # ログが長くなるので5回ごとに表示
        print(f"[Phase 1 - Epoch {epoch+1}/20] Loss: {loss.item():.4f}")

print("\n=== Phase 2: ファインチューニング（プロジェクタ＋LLM全体を最適化）を開始 ===")
model.setup_for_finetuning()
optimizer_p2 = AdamW(filter(lambda p: p.requires_grad, model.parameters()), lr=1e-4) # ここも少し高めに

model.train()
for epoch in range(20):
    prompt = f"USER: {human_text}\nASSISTANT: {gpt_text}"
    text_inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=512).to(device)

    outputs = model(pixel_values=image_inputs["pixel_values"], input_ids=text_inputs["input_ids"], labels=text_inputs["input_ids"])
    loss = outputs.loss

    loss.backward()
    optimizer_p2.step()
    optimizer_p2.zero_grad()
    
    if (epoch + 1) % 5 == 0:
        print(f"[Phase 2 - Epoch {epoch+1}/20] Loss: {loss.item():.4f}")

print("\n=== 予測（推論）テストを開始 ===")
model.eval()

plt.figure(figsize=(5, 5))
plt.imshow(image)
plt.axis('off')
plt.title("Input Image (Wikipedia)")
plt.show()

# 質問文（ASSISTANTの回答を空にして予測させる）
test_prompt = f"USER: {human_text}\nASSISTANT:"
test_text_inputs = tokenizer(test_prompt, return_tensors="pt").to(device)

with torch.no_grad():
    generated_ids = model.generate(
        pixel_values=image_inputs["pixel_values"],
        input_ids=test_text_inputs["input_ids"],
        max_new_tokens=20
    )

generated_text = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
output_text = generated_text.split("ASSISTANT:")[-1].strip()

print(f"【質問】\n{human_text}")
print(f"\n【正解（学習したテキスト）】\n{gpt_text}")
print(f"\n↓↓↓ AIの予測結果 ↓↓↓\n{output_text}")

使用デバイス: cuda

テスト用画像を読み込み中...

=== Phase 1: 事前学習（プロジェクタのみ最適化）を開始 ===
[transformers] `loss_type=None` was set in the config but it is unrecognized. Using the default loss: `ForCausalLMLoss`.
[Phase 1 - Epoch 5/20] Loss: 5.5496
[Phase 1 - Epoch 10/20] Loss: 4.0730
[Phase 1 - Epoch 15/20] Loss: 4.1008
[Phase 1 - Epoch 20/20] Loss: 3.4197

=== Phase 2: ファインチューニング（プロジェクタ＋LLM全体を最適化）を開始 ===
[Phase 2 - Epoch 5/20] Loss: 2.4626
[Phase 2 - Epoch 10/20] Loss: 0.6448
[Phase 2 - Epoch 15/20] Loss: 0.1243
[Phase 2 - Epoch 20/20] Loss: 0.0502

=== 予測（推論）テストを開始 ===

【質問】
この画像に写っている動物は何ですか？

【正解（学習したテキスト）】
壁の上で寝ている猫です。

↓↓↓ AIの予測結果 ↓↓↓
壁の上で寝ている猫です。何で

import torch
import requests
import io # ←修正①: ioモジュールをインポート
from PIL import Image
import matplotlib.pyplot as plt
from transformers import AutoProcessor, LlavaForConditionalGeneration

# ==========================================
# 1. 準備：Hugging Face公式モデル（LLaVA 1.5）の読み込み
# ==========================================
device = "cuda" if torch.cuda.is_available() else "cpu"

model_id = "llava-hf/llava-1.5-7b-hf"
# プロセッサ（画像の前処理とテキストのトークナイズを両方自動で行ってくれます）
processor = AutoProcessor.from_pretrained(model_id)

# モデル本体（メモリ節約のため float16 で読み込みます）
model = LlavaForConditionalGeneration.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    low_cpu_mem_usage=True,
).to(device)

# ==========================================
# 2. データの準備：商用利用可能なフリー素材（Wikipedia）を取得
# ==========================================
# 【注意】テストに使用している猫の画像はWikimedia Commonsのコンテンツです。
# クリエイティブ・コモンズ（CC）ライセンスに基づき、記事の末尾などで
# クレジット表記（作者名、ライセンス種別）を行う必要があります。
print("\nテスト用画像を読み込み中...")
wiki_image_url = "https://upload.wikimedia.org/wikipedia/commons/thumb/1/15/Cat_August_2010-4.jpg/1920px-Cat_August_2010-4.jpg"
headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)'}
response = requests.get(wiki_image_url, headers=headers)

# 取得したバイナリデータをメモリ上で画像に変換
# ←修正②: 変数名を test_image に統一
test_image = Image.open(io.BytesIO(response.content)).convert('RGB') 

# AIへの質問文
# ※LLaVAのフォーマットに従い、画像が挿入される位置に <image> タグを含めます
human_text = "<image>\nこの画像に写っている動物について詳しく説明してください。"

# 画像の表示（matplotlibを使用）
plt.figure(figsize=(5, 5))
plt.imshow(test_image)
plt.axis('off')
plt.title("Input Image (Wikipedia)")
plt.show()

# ==========================================
# 3. 推論フロー（予測の実行）
# ==========================================
# プロンプトの構築（Hugging Faceのフォーマットに合わせる）
prompt = f"USER: {human_text}\nASSISTANT:"

# プロセッサを使って、画像とテキストを一括でモデルに入力できる形式（テンソル）に変換
inputs = processor(text=prompt, images=test_image, return_tensors="pt").to(device, torch.float16)

# 推論の実行（AIに回答を生成させる）
with torch.no_grad():
    generated_ids = model.generate(**inputs, max_new_tokens=100)

# ==========================================
# 4. 結果のデコードと表示
# ==========================================
# 生成された数値をテキストに戻す
generated_text = processor.decode(generated_ids[0], skip_special_tokens=True)

# プロンプト部分を除外し、AIが生成した回答のみを抽出
output_text = generated_text.split("ASSISTANT:")[-1].strip()

# 質問文から <image> タグを消して綺麗に表示
print(f"【質問】\n{human_text.replace('<image>', '').strip()}")
print(f"\n【LLaVA公式モデルの予測結果】\n{output_text}")

テスト用画像を読み込み中...

【質問】
この画像に写っている動物について詳しく説明してください。

【LLaVA公式モデルの予測結果】
この画像には、猫が描かれています。猫は、白い壁に乗っているように、壁の上に寝ています。猫は、目を瞑っているように、目を閉じています。猫は、壁の上に��