Upload folder using huggingface_hub

README.md

@@ -0,0 +1,660 @@
+# MLX
+
+[**Quickstart**](#quickstart) | [**Installation**](#installation) |
+[**Documentation**](https://ml-explore.github.io/mlx/build/html/index.html) |
+[**Examples**](#examples)
+
+[![CircleCI](https://circleci.com/gh/ml-explore/mlx.svg?style=svg)](https://circleci.com/gh/ml-explore/mlx)
+
+MLX is an array framework for machine learning on Apple silicon,
+brought to you by Apple machine learning research.
+
+Some key features of MLX include:
+
+- **Familiar APIs**: MLX has a Python API that closely follows NumPy. MLX
+   also has fully featured C++, [C](https://github.com/ml-explore/mlx-c), and
+   [Swift](https://github.com/ml-explore/mlx-swift/) APIs, which closely mirror
+   the Python API. MLX has higher-level packages like `mlx.nn` and
+   `mlx.optimizers` with APIs that closely follow PyTorch to simplify building
+   more complex models.
+
+- **Composable function transformations**: MLX supports composable function
+  transformations for automatic differentiation, automatic vectorization,
+  and computation graph optimization.
+
+- **Lazy computation**: Computations in MLX are lazy. Arrays are only
+  materialized when needed.
+
+- **Dynamic graph construction**: Computation graphs in MLX are constructed
+  dynamically. Changing the shapes of function arguments does not trigger
+  slow compilations, and debugging is simple and intuitive.
+
+- **Multi-device**: Operations can run on any of the supported devices
+  (currently the CPU and the GPU).
+
+- **Unified memory**: A notable difference from MLX and other frameworks
+  is the *unified memory model*. Arrays in MLX live in shared memory.
+  Operations on MLX arrays can be performed on any of the supported
+  device types without transferring data.
+
+MLX is designed by machine learning researchers for machine learning
+researchers. The framework is intended to be user-friendly, but still efficient
+to train and deploy models. The design of the framework itself is also
+conceptually simple. We intend to make it easy for researchers to extend and
+improve MLX with the goal of quickly exploring new ideas.
+
+The design of MLX is inspired by frameworks like
+[NumPy](https://numpy.org/doc/stable/index.html),
+[PyTorch](https://pytorch.org/), [Jax](https://github.com/google/jax), and
+[ArrayFire](https://arrayfire.org/).
+
+## Examples
+
+The [MLX examples repo](https://github.com/ml-explore/mlx-examples) has a
+variety of examples, including:
+
+- [Transformer language model](https://github.com/ml-explore/mlx-examples/tree/main/transformer_lm) training.
+- Large-scale text generation with
+  [LLaMA](https://github.com/ml-explore/mlx-examples/tree/main/llms/llama) and
+  finetuning with [LoRA](https://github.com/ml-explore/mlx-examples/tree/main/lora).
+- Generating images with [Stable Diffusion](https://github.com/ml-explore/mlx-examples/tree/main/stable_diffusion).
+- Speech recognition with [OpenAI's Whisper](https://github.com/ml-explore/mlx-examples/tree/main/whisper).
+
+## Quickstart
+
+See the [quick start
+guide](https://ml-explore.github.io/mlx/build/html/usage/quick_start.html)
+in the documentation.
+
+## Installation
+
+MLX is available on [PyPI](https://pypi.org/project/mlx/). To install MLX on
+macOS, run:
+
+```bash
+pip install mlx
+```
+
+To install the CUDA backend on Linux, run:
+
+```bash
+pip install mlx[cuda]
+```
+
+To install a CPU-only Linux package, run:
+
+```bash
+pip install mlx[cpu]
+```
+
+Checkout the
+[documentation](https://ml-explore.github.io/mlx/build/html/install.html#)
+for more information on building the C++ and Python APIs from source.
+
+## ファインチューニング手法: LoRAとPRT
+
+このリポジトリでは、Apple Silicon上で効率的にLLMをファインチューニングするための2つの手法を実装・提供しています。
+
+### LoRA (Low-Rank Adaptation)
+
+#### 概要
+
+LoRAは、元のモデルの重みを変更せずに、低ランク行列を追加することでファインチューニングを行う手法です。メモリ効率が良く、複数のタスク用アダプターを切り替えて使用できます。
+
+#### アーキテクチャ
+
+```
+元の計算: output = W × input
+LoRA適用: output = (W + B × A) × input
+
+W: 元の重み行列（固定、変更されない）
+A, B: 低ランク行列（学習される）
+rank: 低ランクの次元数（通常4-16）
+```
+
+**特徴**:
+
+- **更新パラメータ**: 全パラメータの0.1-1%（低ランク行列のみ）
+- **メモリ使用量**: 小さい（モデルサイズの1.2-1.5倍）
+- **保存容量**: 非常に小さい（元のモデルの0.1-1%）
+- **学習時間**: 短い
+- **性能**: Full Fine-tuningに近い
+
+#### 実装方法
+
+**基本的な使い方**:
+
+```bash
+# 仮想環境を有効化
+source .venv/bin/activate
+
+# LoRAファインチューニング
+python -m mlx_lm lora \
+    --model ./models/tinyllama-1.1b \
+    --train --data ./finetune_data \
+    --num-layers 8 \
+    --lora-r 8 \
+    --learning-rate 1e-4 \
+    --iters 30
+```
+
+**推奨パラメータ**:
+
+- `--lora-r`: 8（低ランクの次元数）
+- `--num-layers`: 8（適用する層数、TinyLlamaの場合は全22層中8層）
+- `--learning-rate`: 1e-4
+- `--iters`: 30
+
+**学習済みアダプターでの推論**:
+
+```bash
+python -m mlx_lm chat \
+    --model ./models/tinyllama-1.1b \
+    --adapter-path ./adapters \
+    --prompt "### Instruction: 日本の首都はどこですか？\n### Response:"
+```
+
+#### アーキテクチャの詳細
+
+**TinyLlama-1.1Bでの実装例**:
+
+- **モデル**: TinyLlama-1.1B-Chat-v1.0
+- **LoRA適用層数**: 8層（全22層中）
+- **LoRA rank**: 8
+- **LoRA scale**: 20.0
+- **更新パラメータ**: 約0.209%（2.294M/1100.048M）
+- **アダプターサイズ**: 約8.8MB（元のモデルの0.44%）
+
+**パフォーマンス**:
+
+- トレーニング速度: 約5-6 it/sec
+- トークン速度: 約250-300 tokens/sec
+- ピークメモリ: 約2.4-2.5 GB
+
+詳細は [`examples/prt_llm/README.md`](examples/prt_llm/README.md) と [`knowledge/SLM_選定とファインチューニング手法と性能変化.md`](knowledge/SLM_選定とファインチューニング手法と性能変化.md) を参照してください。
+
+---
+
+### PRT (Portable Reward Tuning)
+
+#### 概要
+
+PRTは、ファインチューニングをreward最大化問題として再定式化し、rewardモデルを明示的に学習することで、**異なるベースモデル間で再利用可能な**ファインチューニング手法です。論文「Portable Reward Tuning: Towards Reusable Fine-Tuning across Different Pretrained Models」(arXiv:2502.12776v1)に基づいています。
+
+#### このリポジトリでの呼称（PRT1/2/3）
+
+このREADMEでは、実装の違いを分かりやすくするために以下のように呼び分けます（**いずれも「学習対象はRewardモデル」**です）。
+
+- **PRT1**: LinearのRewardヘッド（baseのhidden → vocabのreward logits）: `examples/prt_llm/prt_llm.py`
+- **PRT2**: Tiny Causal TransformerのRewardモデル（base hidden → 小型Transformer → vocab）: `examples/prt_llm/prt_llm2.py`
+- **PRT3**: Rewardモデルをベースモデルの**完全コピー（別インスタンス）**として学習: `examples/prt_llm/prt_llm_v3.py`
+
+#### アーキテクチャ
+
+**PRT1（Linear Reward Head）の基本構造**:
+
+```
+Base Model (固定)
+├── Transformer Layers (22層)
+└── LM Head (Linear)
+
+Reward Model (学習可能)
+└── Reward Head (Linear)
+    ├── Input: Base Modelのhidden states (2048次元)
+    └── Output: Reward logits (32000次元)
+
+PRT合成:
+v_θ = log softmax(base_logits) + reward_logits / λ
+π_PRT = softmax(v_θ)
+```
+
+**PRT2 (拡張版) - Tiny Causal Transformer Reward Model**:
+
+```
+RewardTransformerRewardModel
+├─ proj_in: Linear(2048 → 512)
+├─ blocks: CausalTransformerBlock × L (L=2, default)
+│   └─ block
+│      ├─ norm1: RMSNorm(512)
+│      ├─ attn: CausalSelfAttention(d=512, heads=8) + ALiBi
+│      ├─ norm2: RMSNorm(512)
+│      └─ mlp: SwiGLU FFN(512 → 2048 → 512)
+├─ norm_out: RMSNorm(512)
+└─ vocab_head: Linear(512 → 32000)
+```
+
+**特徴**:
+
+- **Base Modelのパラメータ**: 完全に固定（変更されない）
+- **Reward Model**: 独立したパラメータ（学習される）
+- **Portable性**: 同じtokenizerを使用する異なるベースモデル間でrewardモデルを再利用可能
+- **推論コスト（PRT1/2）**: Base Modelのforward passは1回のみ（効率的）
+- **パラメータ数**: PRT1は約65M、PRT2は約26M（L=2の場合）
+
+#### 実装方法
+
+**PRT1（Linear Reward Head版）の使い方**:
+
+```bash
+# 仮想環境を有効化
+source .venv/bin/activate
+
+# Rewardモデルの学習
+python3 examples/prt_llm/prt_llm.py train \
+    --model ./models/tinyllama-1.1b \
+    --data ./finetune_data \
+    --output-dir ./prt_reward \
+    --learning-rate 1e-4 \
+    --iters 30 \
+    --lambda 1.0 \
+    --entropy-coeff 0.05
+
+# PRTによる生成
+python3 examples/prt_llm/prt_llm.py generate \
+    --model ./models/tinyllama-1.1b \
+    --reward ./prt_reward \
+    --prompt "### Instruction: 日本の首都はどこですか？\n### Response:" \
+    --max-tokens 100 \
+    --temp 0.7
+```
+
+**PRT2（Tiny Transformer Reward版）の使い方**:
+
+```bash
+# Rewardモデルの学習
+python3 examples/prt_llm/prt_llm2.py train \
+    --model ./models/tinyllama-1.1b \
+    --data ./finetune_data \
+    --output-dir ./prt2_reward \
+    --lambda 1.0 \
+    --entropy-coeff 0.05 \
+    --reward-d-model 512 \
+    --reward-layers 2 \
+    --reward-heads 8 \
+    --reward-ffn-dim 2048
+
+# PRT2による生成
+python3 examples/prt_llm/prt_llm2.py generate \
+    --model ./models/tinyllama-1.1b \
+    --reward ./prt2_reward \
+    --prompt "### Instruction: 日本の首都はどこですか？\n### Response:" \
+    --max-tokens 100 \
+    --temp 0.7
+```
+
+#### 損失関数
+
+PRTの損失関数は以下の通りです：
+
+```python
+# Algorithm 1 (論��準拠)
+v_θ = log softmax(base_logits) + reward_logits / λ
+π_PRT = softmax(v_θ)
+loss = CE(π_PRT, y) + (-entropy_coeff * H(ρ_θ))
+
+# ρ_θ = softmax(reward_logits) (reward-only分布)
+# H(ρ_θ): Entropy正則化（崩壊防止）
+```
+
+**パラメータ説明**:
+
+- `--lambda`: KL正則化係数（デフォルト: 1.0）
+- `--entropy-coeff`: Entropy正則化係数（デフォルト: 0.05）
+- `--reward-d-model`: PRT2のTransformer次元（デフォルト: 512）
+- `--reward-layers`: PRT2の層数（デフォルト: 2）
+
+#### PRT vs LoRA の比較
+
+| 観点 | LoRA | PRT1 | PRT2 | PRT3 |
+|------|------|------|------|------|
+| **更新パラメータ** | 0.1-1% | 約6% | 約2.4% | ≈100%（Reward=Full Copy） |
+| **メモリ使用量** | 小さい | 中程度 | 中程度 | 大（モデル2本） |
+| **学習時間** | 短い | 中程度 | やや長い | 長い |
+| **保存容量** | 非常に小さい | 小さい | 小さい | 大 |
+| **Portable性** | なし（モデル依存） | **あり**（tokenizer一致が前提） | **あり** | **あり** |
+| **推論速度** | 高速 | 高速 | 中速 | 低〜中（forward 2回） |
+| **表現力** | 中程度 | 低（Linear） | 高（Transformer） | 高（Full Model） |
+
+詳細は [`examples/prt_llm/README.md`](examples/prt_llm/README.md) と [`knowledge/PRT_ネットワーク構造解説.md`](knowledge/PRT_ネットワーク構造解説.md) を参照してください。
+
+---
+
+### PRT Implementation History & Architectures
+
+開発の進展に伴い、PRTはその適用範囲をLLMからVLMへ、そして実験環境からHPC/実アプリケーションへと拡大してきました。以下に各バージョンの実装箇所と特徴を示します。
+
+**開発履歴一覧 (Version Summary):**
+
+| Ver | 環境 | モデル | LoRA | タスク | 実装箇所 (Path) | 特記事項 |
+| :--- | :--- | :--- | :--- | :--- | :--- | :--- |
+| **PRT1** | Mac (MLX) | TinyLlama-1.1B | × | LLM | `examples/prt_llm/prt_llm.py` | 軽量Reward Head |
+| **PRT2** | Mac (MLX) | TinyLlama-1.1B | × | LLM | `examples/prt_llm/prt_llm2.py` | 高表現力Reward |
+| **PRT3** | Mac (MLX) | TinyLlama-1.1B | ◯ | LLM | `examples/prt_llm/prt_llm_v3.py` | **LLM標準 (Twin)** |
+| **PRT4** | Mac (MLX) | DeepSeek-VL2 | ? | VLM | `examples/prt_flickr30k` | Frozen (MoE負荷大) |
+| **PRT5** | Mac (MLX) | Qwen2-VL-2B | ◯ | VLM | `examples/prt5_qwen2vl` | **VLM標準 (Efficient)** |
+| **PRT6** | Linux (PT) | Qwen2-VL-2B | ◯ | VLM | `examples/prt6_pytorch` | PyTorch移植版 |
+| **PRT7** | HPC (Sing) | Qwen2-VL-2B | ◯ | VLM | `examples/prt7_singularity` | コンテナ化 |
+| **PRT8** | Mac (MLX) | Qwen2-VL-2B | ◯ | VLM | `examples/prt8_vlm` | 汎用FW化 |
+| **PRT9** | Mac (MLX) | Qwen2-VL-2B | ◯ | DriveLM | `examples/prt9_drivelm` | 自動運転QA |
+| **PRT10**| Linux (PT) | Eagle2-1B | ◯ | DriveLM | `examples/prt10_pytorch_drivelm` | (Conceptual/WIP) |
+| **PRT11**| **Mac** | **Eagle2-1B** | **◯** | **DriveLM** | `examples/prt11_drivelm` | **Mac実用版 (Active)** |
+| **PRT12**| **Any** | **Qwen2.5-VL** | **◯** | **General** | `examples/prt12_qwen25vl` | **Transformers最小構成 (Wrapper)** |
+| **PRT13**| **Any** | **Qwen2.5-VL** | **◯** | **General** | `examples/prt13_qwen25vl` | **Transformers標準設計 (Design A)** |
+
+以下に各フェーズの実装詳細を示します。
+
+#### Phase 1: LLM Foundations (PRT1 - PRT3)
+
+初期のPRTは、LLM（TinyLlama等）を対象に、Rewardモデルの構造を探索しました。
+
+**PRT1: Linear Reward Head**
+
+- **構造**: ベースモデルの隠れ層から直接Linear層でRewardを計算。
+- **特徴**: 最も軽量だが、表現力が限定的。
+- **実装**: `examples/prt_llm/prt_llm.py`
+
+**PRT2: Transformer Reward Model**
+
+- **構造**: ベースモデルの隠れ層の上に、小さなTransformerブロックを追加。
+- **特徴**: 表現力と計算コストのバランスが良い。
+- **実装**: `examples/prt_llm/prt_llm2.py`
+
+**PRT3: Twin Model Composition (Current Standard)**
+
+- **構造**: Rewardモデルとして、ベースモデルと同じアーキテクチャのコピーを使用（別インスタンス）。
+- **特徴**: 最も表現力が高く、LoRA等の既存技術をそのまま適用可能。現在のPRTの標準形。
+- **実装**: `examples/prt_llm/prt_llm_v3.py`
+
+```mermaid
+graph TD
+    subgraph PRT1 [PRT1: Linear]
+        B1[Base Model] --> H1[Hidden]
+        H1 --> L1[Linear Head]
+        L1 --> R1[Reward Logits]
+    end
+    
+    subgraph PRT2 [PRT2: Tiny Transformer]
+        B2[Base Model] --> H2[Hidden]
+        H2 --> T2[Tiny Transformer]
+        T2 --> L2[Linear Head]
+        L2 --> R2[Reward Logits]
+    end
+    
+    subgraph PRT3 [PRT3: Twin Model]
+        B3[Base Model] --> Log3[Base Logits]
+        RM3[Reward Model (Copy)] --> R3[Reward Logits]
+        
+        Log3 -- "+" --> Sum
+        R3 -- "/ lambda" --> Sum
+    end
+```
+
+#### Phase 2: VLM Expansion on MLX (PRT4 - PRT5)
+
+視覚情報を含���VLM（Vision-Language Model）への適用フェーズです。
+
+**PRT4: MoE VLM Experiment (Archived)**
+
+- **対象**: DeepSeek-VL2 (Mixture-of-Experts)
+- **結果**: Mac M1でのMoE計算負荷とMLXの制約により開発凍結。
+- **ディレクトリ**: `examples/prt_flickr30k`
+
+**PRT5: Efficient VLM Tuning (Qwen2-VL)**
+
+- **対象**: Qwen2-VL-2B-Instruct
+- **構造**: Vision Encoderからの特徴量を、BaseとRewardの両方のLLMに入力します。メモリ効率のためBaseは4bit量子化されています。
+- **実装**: `examples/prt5_qwen2vl`
+
+```mermaid
+graph LR
+    Img[Image] --> V[Vision Encoder]
+    Txt[Text Prompt] --> Emb[Embedding]
+    
+    V --> Concat
+    Emb --> Concat
+    
+    Concat --> Base[Base LLM (4bit Frozen)]
+    Concat --> Reward[Reward LLM (LoRA Trainable)]
+    
+    Base --> BL[Base Logits]
+    Reward --> RL[Reward Logits]
+    
+    BL & RL --> PRT_Loss
+```
+
+#### Phase 3: Scaling to HPC (PRT6 - PRT7)
+
+大学や研究所のHPC（スパコン）環境での学習を見据えたスケーリングフェーズです。
+
+**PRT6: PyTorch & Accelerate Port**
+
+- **内容**: MLXの実装をPyTorch + Hugging Face Accelerateに移植。
+- **目的**: マルチGPU分散学習の実現。
+- **実装**: `examples/prt6_pytorch`
+
+**PRT7: Singularity Containerization**
+
+- **内容**: PRT6をSingularity (Apptainer) コンテナにパッケージング。
+- **目的**: 依存関係（CUDA, Libraries）の完全な再現性と、管理者権限のない共用スパコンでの実行。
+- **実装**: `examples/prt7_singularity`
+
+```mermaid
+graph LR
+    subgraph HPC_Node [HPC Compute Node]
+        subgraph Singularity [Singularity Container (PRT7)]
+            Script[run_singularity.sh]
+            Env[Python venv / Dependencies]
+            Code[PRT6 PyTorch Code]
+            
+            Script --> Env
+            Env --> Code
+        end
+        GPU[NVIDIA A100/H100 GPUs]
+        Code -.-> GPU
+    end
+```
+
+#### Phase 4: Generalization & Application (PRT8 - PRT9)
+
+実用化に向けたリファクタリングと、複雑なタスクへの応用です。
+
+**PRT8: VLM Generalization Framework**
+
+- **内容**: PRT5-7の知見を統合し、汎用的なVLM学習ライブラリとしてリファクタリング。
+- **構造**: `PRTForCausalLM` クラスによるモデルの抽象化と、共通化されたデータハンドラ。
+- **実装**: `examples/prt8_vlm`
+
+**PRT9: Autonomous Driving (DriveLM)**
+
+- **内容**: 自動運転QAデータセット「DriveLM」への適用。
+- **特徴**: Preprocessによる特殊なJSON形式の変換と、高解像度画像の取り扱い。
+- **実装**: `examples/prt9_drivelm`
+
+```mermaid
+graph TD
+    Raw[DriveLM Raw Data] --> Prep[preprocess_drivelm.py]
+    Prep --> JSONL[Formatted QA JSONL]
+    
+    JSONL --> Load[DataLoader]
+    Img[High-Res Images] --> Load
+    
+    subgraph PRT9_Training
+        Load --> PRT8[PRT8 Codebase]
+        Mod[Qwen2-VL-2B] -.-> PRT8
+    end
+    
+    PRT8 --> ModelFile[Saved Model]
+```
+
+#### Phase 5: Real-World Adaptation & Challenges (PRT10 - PRT11)
+
+実世界での運用（特にMacローカル環境やGPUリソースの制約）に向けた適応フェーズです。実装にあたり以下の「壁」がありました。
+
+**実装への壁 (Barriers):**
+
+1. **PyTorch環境**: GPU環境の準備と依存関係の複雑さ。
+2. **メモリ制約**: フルファインチューニングは不可能。LoRAであってもVLM（Vision Model + LLM）はメモリ的に厳しい。
+3. **タスクの変化**: LLMからVLM（DriveLM）への移行。論文実装にあるViT（Vision Transformer）の実装が存在しないため、独自に構築する必要があった。
+
+これらの課題を乗り越えるため、以下の2つのアプローチを実装しました。
+
+| バージョン | 環境 | モデル | LoRA | タスク | ステータス |
+| --- | --- | --- | --- | --- | --- |
+| **論文実装** | PyTorch | LLM/(ViT) | QLoRA | Llama | (Reference) |
+| **PRT10** | PyTorch (GPU) | VLM | LoRA | DriveLM | **実装済み** |
+| **PRT11** | **Mac (Metal)** | **VLM** | **LoRA** | **DriveLM** | **稼働中 (Code Exists)** |
+| **(Future)** | ? | VLM | Full FT | DriveLM | 未生成 |
+
+**PRT10: PyTorch VLM (LoRA)**
+
+- **環境**: Linux / PyTorch / CUDA
+- **特徴**: PRT9のコンセプトをPyTorchネイティブ環境に移植。標準的なGPUサーバーでの学習を想定。
+- **実装**: `examples/prt10_pytorch_drivelm` (Conceptual/WIP)
+
+**PRT11: Mac Metal VLM (LoRA)**
+
+- **環境**: Mac M1/M2/M3 (Metal/MPS)
+- **特徴**:
+  - `nvidia/Eagle2-1B` モデルを採用し、MacBook Pro等のローカル環境で学習可能に最適化。
+  - **Dynamic Patching**: `transformers` ライブラリやモデルのリモートコードに対し、実行時に動的にパッチを適用することで、FlashAttention非対応環境（Mac）での動作を強制。
+  - **Memory Efficient**: 1BクラスのモデルとLoRAを組み合わせることで、ユニファイドメモリ環境での動作を実現。
+- **実装**: `examples/prt11_drivelm/train_prt11.py`
+
+**PRT12: Transformers Minimal Implementation**
+
+- **環境**: Any (PyTorch + Transformers)
+- **特徴**:
+  - `mlx` や複雑な依存関係を排除し、`transformers` と `peft` のみで構成された最小実装。
+  - Qwen2.5-VL を対象に、Algorithm 1 (学習) と Algorithm 2 (推論) のロジックをブラックボックスなしで実装。
+  - **教育的価値**: PRTの動作原理（Logits合成）を理解するための参照実装として最適です。
+- **実装**: `examples/prt12_qwen25vl`
+
+**PRT13: Transformers Standard Implementation (Design A)**
+
+- **環境**: Any (PyTorch + Transformers)
+- **特徴**:
+  - PRTの「王道」とされる設計パターン（Design A）。
+  - **構成**:
+    - **Trainer継承**: `PRTTrainer` で学習ロジックをカプセル化し、標準エコシステム（SFT Trainer等）との親和性を確保。
+    - **Generator分離**: `PRTGenerator` で推論ロジックを独立させ、**「モデルスワッピング実験（Baseモデルを入れ替えてAdapterのポータビリティを検証）」** を容易に。
+  - **成果物**: 純粋なLoRAアダプタのみ（モデルコード不要）。
+- **実装**: `examples/prt13_qwen25vl`
+
+---
+
+### PRT Architecture Details (Mechanism of Portability)
+
+PRTの最大の利点である「ポータビリティ（学習時と推論時で異なるモデルサイズを扱える）」を実現するアーキテクチャの詳細です。
+
+#### 1. Core Concept: Logits Composition
+
+PRTはモデル内部の隠れ層ではなく、最終出力である **「語彙空間（Logits）」** のレベルで結合を行います。これにより、モデルサイズ（7B vs 2B）が異なっていても、使用している「辞書（Tokenizer）」さえ同じであれば計算が可能になります。
+
+$$ v_\theta(y|x) = \log P_{\text{Base}}(y|x) + \frac{R_\phi(y|x)}{\lambda} $$
+
+#### 2. Architecture: Training vs Inference
+
+**学習フェーズ (Training Phase)**:
+計算コストを抑えるため、**「小さなモデル同士」**（2B + 2B）で学習を行います。
+
+- **Base Model (Reference)**: Qwen2-VL-**2B** (Frozen)
+- **Reward Model**: Qwen2-VL-**2B** (Frozen) + **LoRA Adapter** (Trainable)
+
+```mermaid
+graph LR
+    Dataset --> Input
+    Input --> Base["Reference (2B)"]
+    Input --> Reward["Reward (2B)"]
+    
+    subgraph RewardModel [Reward Model Composition]
+        Reward --> LoRA["LoRA Adapter (Trainable)"]
+        LoRA -.-> RewardOut[Logits]
+    end
+    
+    Base -.-> Loss
+    RewardOut --> Loss
+    Loss --> Update["Update LoRA Params"]
+    
+    style LoRA fill:#f96,stroke:#333,stroke-width:2px
+    style Base fill:#eee,stroke:#333,stroke-dasharray: 5 5
+```
+
+**推論フェーズ (Inference Phase)**:
+獲得したRewardモデル（2B + LoRA）を、**「大きなモデル（7B）」** の推論プロセスに組み込みます。
+重要な点として、**Rewardモデルを7Bモデルに移植するわけではありません**。Rewardモデルは2Bのまま独立して並走し、その出力を7Bモデルの出力に「加算」することで生成をガイドします。
+
+- **Base Model**: Qwen2-VL-**7B** (Frozen)  <-- **ここだけ入れ替える**
+- **Reward Model**: Qwen2-VL-**2B** (Frozen) + **LoRA Adapter** (Frozen) <-- **ずっと2Bのまま並走**
+- **操作**: **Logits Level Addition (出力の単純合成)**
+
+```mermaid
+graph LR
+    Prompt --> Input
+    Input --> Base["Base (swapped to 7B)"]
+    Input --> Reward["Reward (stays 2B)"]
+    
+    subgraph RewardComponents [Reward + LoRA]
+        Reward --> LoRA_Inf["LoRA Adapter (Frozen)"]
+        LoRA_Inf --> RewardLogits[Reward Logits]
+    end
+
+    Base --> BaseLogits[Base Logits]
+    
+    BaseLogits -- "Log Probability" --> Add
+    RewardLogits -- "Reward (R/λ)" --> Add
+    Add["Compose (Logits Addition) v = log P + R/λ"] --> Output
+    
+    style LoRA_Inf fill:#f96,stroke:#333,stroke-width:2px
+```
+
+このアーキテクチャにより、**「学習コストは2B相当、推論能力は7B相当」** という効率的な運用が可能になります。
+
+#### 3. Full Fine-Tuning (Original PRT) vs LoRA
+
+現在の実装 (`train_prt5.py`) はメモリ効率のため **LoRA** を使用していますが、論文通りの **Full Fine-Tuning**（全パラメータ学習）を行うことも可能です。
+その場合はコードの以下の部分を変更します（ロジックやLoss関数は変更不要です）。
+
+```python
+# train_prt5.py の変更イメージ
+
+# Current (LoRA)
+reward_model.freeze()          # 1. 全体を凍結
+apply_lora(reward_model)       # 2. LoRA層のみ追加・学習
+
+# Target (Full FT)
+# reward_model.freeze()        # 1. 凍結しない（または Unfreeze）
+# apply_lora(reward_model)     # 2. LoRAは適用しない（スキップ）
+```
+
+これにより、Optimizerはモデ��全体のパラメータを学習対象として更新するようになります。
+
+---
+
+## Contributing
+
+Check out the [contribution guidelines](https://github.com/ml-explore/mlx/tree/main/CONTRIBUTING.md) for more information
+on contributing to MLX. See the
+[docs](https://ml-explore.github.io/mlx/build/html/install.html) for more
+information on building from source, and running tests.
+
+We are grateful for all of [our
+contributors](https://github.com/ml-explore/mlx/tree/main/ACKNOWLEDGMENTS.md#Individual-Contributors). If you contribute
+to MLX and wish to be acknowledged, please add your name to the list in your
+pull request.
+
+## Citing MLX
+
+The MLX software suite was initially developed with equal contribution by Awni
+Hannun, Jagrit Digani, Angelos Katharopoulos, and Ronan Collobert. If you find
+MLX useful in your research and wish to cite it, please use the following
+BibTex entry:
+
+```text
+@software{mlx2023,
+  author = {Awni Hannun and Jagrit Digani and Angelos Katharopoulos and Ronan Collobert},
+  title = {{MLX}: Efficient and flexible machine learning on Apple silicon},
+  url = {https://github.com/ml-explore},
+  version = {0.0},
+  year = {2023},
+}
+```

examples/prt12_qwen25vl/README.md

@@ -0,0 +1,74 @@
+# PRT12: Qwen2.5-VL with Portable Reward Tuning (Minimal)
+
+Transformers + PEFT のみを使用した、Qwen2.5-VL に対する PRT (Portable Reward Tuning) の最小実装例です。
+複雑な依存関係を排除し、シンプルな構成で PRT の中核ロジック (Algorithm 1 & 2) を理解・実行できるようにしています。
+
+## 概要
+
+PRT (Portable Reward Tuning) は、学習済みのベースモデル (Reference) と、LoRAで追加学習する報酬モデル (Reward) を組み合わせる手法です。
+本実装 (`prt12`) では、カスタムトレーナー等を使わず、Hugging Face の標準 `Trainer` とモデルラッパーのみでこれを実現しています。
+
+### ディレクトリ構成
+
+* **`modeling_prt.py`**: モデル定義
+  * `PRTQwenVL` クラス: 2つのモデル (Ref, Reward) を保持し、`forward` メソッドで Algorithm 1 の損失計算を行います。
+* **`train_prt12.py`**: 学習スクリプト
+  * Hugging Face `Trainer` を使用した学習ループ。
+  * データセットの読み込みと前処理 (Qwen2.5-VL用)。
+* **`inference_prt12.py`**: 推論スクリプト
+  * Algorithm 2 に基づく Greedy Search 生成の実装。
+  * ステップごとに Ref と Reward の出力を合成します。
+
+## 動作原理 (Algorithm 1 & 2)
+
+### 学習 (Algorithm 1)
+
+`modeling_prt.py` の `forward` メソッドで実装されています。
+
+1. **Ref Model (凍結)**: 入力 $x$ に対する対数確率 $\log \pi_{\text{ref}}(y|x)$ を計算します (Log Blob)。
+2. **Reward Model (LoRA学習)**: 入力 $x$ に対するスカラー値 (ロジット) $r_\phi(x, y)$ を計算します。
+3. **合成**: $v_\theta = \log \pi_{\text{ref}} + r_\phi$
+4. **損失**: 合成された分布 $v_\theta$ と正解ラベル $y$ との間で Cross Entropy Loss を計算します。
+
+### 推論 (Algorithm 2)
+
+`inference_prt12.py` の `prt_greedy_generate` 関数で実装されています。
+
+1. トークン生成の各ステップで、Ref Model と Reward Model の両方を推論します。
+2. 学習時と同様にLogitsを合成し、最大スコアを持つトークンを選択します。
+
+## 実行方法
+
+### 必要ライブラリ
+
+```bash
+pip install -r requirements.txt
+```
+
+### 学習コマンド例
+
+```bash
+python train_prt12.py \
+    --model_id "Qwen/Qwen2.5-VL-3B-Instruct" \
+    --data_path "dummy_data.jsonl" \
+    --output_dir "output_prt12" \
+    --epochs 3 \
+    --bf16
+```
+
+※ GPUメモリ要件: 3Bモデルを2つロードするため、最低でも 24GB 程度のVRAMを持つGPU (A10G, A100, RTX3090/4090等) が推奨されます。Macではメモリ不足になる可能性があります。
+
+### 推論コマンド例
+
+```bash
+python inference_prt12.py \
+    --model_id "Qwen/Qwen2.5-VL-3B-Instruct" \
+    --image_path "test_image.jpg" \
+    --prompt "Describe this image." \
+    --adapter_path "output_prt12"  # 学習済みアダプタがある場合
+```
+
+## コードのポイント
+
+全てのPythonスクリプトには詳細な日本語コメントを追加しています。
+特に `modeling_prt.py` の `forward` メソッドと、`inference_prt12.py` のループ処理を見ることで、PRTの具体的な計算処理を確認できます。

examples/prt12_qwen25vl/dummy_data.jsonl

@@ -0,0 +1,2 @@
+{"image": "test_image.jpg", "question": "Describe this image.", "answer": "A woman and her dog on the beach."}
+{"image": "test_image.jpg", "question": "What is the dog doing?", "answer": "The dog is sitting next to the woman."}

examples/prt12_qwen25vl/inference_prt12.py

@@ -0,0 +1,213 @@
+import torch
+import torch.nn.functional as F
+from transformers import Qwen2VLForConditionalGeneration, AutoProcessor
+from peft import PeftModel
+from PIL import Image
+import requests
+import argparse
+
+@torch.no_grad()
+def prt_greedy_generate(
+    ref_model,
+    reward_model,
+    input_ids,
+    attention_mask=None,
+    pixel_values=None,
+    image_grid_thw=None,
+    video_grid_thw=None,
+    max_new_tokens=64,
+    eos_token_id=None,
+):
+    """
+    PRT (Portable Reward Tuning) を用いた Greedy 生成関数
+    
+    論文の Algorithm 2 (Inference/Generation) を実装しています。
+    毎回のトークン生成ステップにおいて、RefモデルとRewardモデルの両方を推論し、
+    その出力を合成して次のトークンを決定します。
+
+    数式: v_theta = log_softmax(ref_logits) + reward_logits
+    """
+    # 評価モードへ
+    ref_model.eval()
+    reward_model.eval()
+
+    # KV Cache (過去の計算結果) の初期化
+    # これを使うことで、過去のトークンを再計算せずに済み、高速化できます。
+    past_ref = None
+    past_reward = None
+
+    # 入力IDの形状確認 (Batch, Seq)
+    if input_ids.dim() == 1:
+        input_ids = input_ids.unsqueeze(0)
+
+    current_input_ids = input_ids
+    generated_ids = input_ids.clone()
+    
+    first_step = True # 最初のステップだけ画像入力を渡すフラグ
+
+    # トークン生成ループ
+    for i in range(max_new_tokens):
+        
+        # --- 1. 報酬モデル (Reward Model) の推論 ---
+        reward_kwargs = {
+            "use_cache": True,
+            "past_key_values": past_reward
+        }
+        # 初回のみ画像関連の入力を渡します (以降は past_key_values に保存されるため不要)
+        if first_step:
+            reward_kwargs.update({
+                "attention_mask": attention_mask,
+                "pixel_values": pixel_values,
+                "image_grid_thw": image_grid_thw,
+                "video_grid_thw": video_grid_thw,
+            })
+        
+        out_r = reward_model(
+            input_ids=current_input_ids,
+            **reward_kwargs
+        )
+        past_reward = out_r.past_key_values
+        # 最後のトークンのロジットのみを取得 [Batch, Vocab]
+        reward_logits = out_r.logits[:, -1, :]  
+
+        # --- 2. 参照モデル (Ref Model) の推論 ---
+        ref_kwargs = {
+            "use_cache": True,
+            "past_key_values": past_ref
+        }
+        if first_step:
+            ref_kwargs.update({
+                "attention_mask": attention_mask,
+                "pixel_values": pixel_values,
+                "image_grid_thw": image_grid_thw,
+                "video_grid_thw": video_grid_thw,
+            })
+
+        out_ref = ref_model(
+            input_ids=current_input_ids,
+            **ref_kwargs
+        )
+        past_ref = out_ref.past_key_values
+        # 最後のトークンのロジットのみを取得 [Batch, Vocab]
+        ref_logits = out_ref.logits[:, -1, :]
+
+        # --- 3. PRT合成 (Composition) ---
+        # ここで2つのモデルの出力を合成します。
+        # Refモデルは確率分布に変換してから対数を取り (LogSoftmax)、
+        # Rewardモデルは生のロジット (Logits) をそのまま足します。
+        scores = torch.log_softmax(ref_logits, dim=-1) + reward_logits
+
+        # Greedy Search: スコアが最大のトークンを選択
+        next_token = torch.argmax(scores, dim=-1, keepdim=True)
+        
+        # 生成結果に追加
+        generated_ids = torch.cat([generated_ids, next_token], dim=-1)
+        
+        # 次のステップの入力は、今生成したトークンのみ
+        current_input_ids = next_token 
+        first_step = False
+        
+        # 終了判定 (EOSトークンが出たら終了)
+        if eos_token_id is not None and (next_token == eos_token_id).all():
+            break
+
+    return generated_ids
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model_id", type=str, default="Qwen/Qwen2.5-VL-3B-Instruct")
+    parser.add_argument("--adapter_path", type=str, default=None, help="学習済みアダプタのパス")
+    parser.add_argument("--image_path", type=str, default="http://images.cocodataset.org/val2017/000000039769.jpg")
+    parser.add_argument("--prompt", type=str, default="Describe this image.")
+    args = parser.parse_args()
+
+    # デバイス設定 (CUDA > MPS > CPU)
+    device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"
+    dtype = torch.bfloat16 if device != "cpu" else torch.float32 # CPUはBFloat16未対応の場合があるため
+
+    print(f"Using device: {device}")
+
+    # --- モデルのロード ---
+    
+    # 1. Reference Model (凍結モデル)
+    print(f"Loading Ref Model: {args.model_id}...")
+    ref_model = Qwen2VLForConditionalGeneration.from_pretrained(
+        args.model_id, 
+        torch_dtype=dtype, 
+        device_map=device, 
+        trust_remote_code=True
+    ).eval()
+    
+    # 2. Reward Model (ベース + アダプタ)
+    print(f"Loading Reward Model Base: {args.model_id}...")
+    reward_model = Qwen2VLForConditionalGeneration.from_pretrained(
+        args.model_id, 
+        torch_dtype=dtype, 
+        device_map=device, 
+        trust_remote_code=True
+    )
+    
+    if args.adapter_path:
+        print(f"Loading Adapter from {args.adapter_path}...")
+        # 学習済みのLoRAアダプタをマージしてロード
+        reward_model = PeftModel.from_pretrained(reward_model, args.adapter_path)
+    else:
+        print("アダプタパスが指定されていません。ベースモデルのみ(報酬なし)として動作します。")
+    
+    reward_model.to(device).eval()
+
+    # --- データ処理 ---
+    
+    processor = AutoProcessor.from_pretrained(args.model_id, trust_remote_code=True)
+
+    # 画像ロード
+    if args.image_path.startswith("http"):
+        image = Image.open(requests.get(args.image_path, stream=True).raw).convert("RGB")
+    else:
+        image = Image.open(args.image_path).convert("RGB")
+
+    # プロンプト作成
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image", "image": image},
+                {"type": "text", "text": args.prompt},
+            ],
+        }
+    ]
+    text_prompt = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+    
+    # 入力テンソル作成
+    inputs = processor(
+        text=[text_prompt],
+        images=[image],
+        padding=True,
+        return_tensors="pt",
+    ).to(device)
+
+    # --- 生成実行 ---
+    print("Generating...")
+    gen_ids = prt_greedy_generate(
+        ref_model=ref_model,
+        reward_model=reward_model,
+        input_ids=inputs.input_ids,
+        attention_mask=inputs.attention_mask,
+        pixel_values=inputs.pixel_values,
+        image_grid_thw=inputs.image_grid_thw,
+        max_new_tokens=100,
+        eos_token_id=processor.tokenizer.eos_token_id
+    )
+
+    # デコードして表示
+    # 入力プロンプト部分を除去して、生成されたテキストのみを取り出します
+    generated_ids_trimmed = [
+        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, gen_ids)
+    ]
+    output_text = processor.batch_decode(generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False)
+    
+    print("\n[Output]:")
+    print(output_text[0])
+
+if __name__ == "__main__":
+    main()

examples/prt12_qwen25vl/modeling_prt.py

@@ -0,0 +1,136 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from transformers import AutoModelForCausalLM
+from transformers.modeling_outputs import CausalLMOutputWithPast
+
+class PRTQwenVL(nn.Module):
+    """
+    Qwen2.5-VL 用の PRT (Portable Reward Tuning) ラッパークラス
+    
+    論文の Algorithm 1 (Training) を実装しています。
+    学習時の損失関数計算において、ベースモデルの出力と報酬モデルの出力を合成します。
+    
+    仕組み:
+      combined_logits (v_theta) = log_softmax(ref_logits) + reward_logits
+      Loss = CrossEntropy(v_theta, labels)
+    """
+    def __init__(self, ref_model: nn.Module, reward_model: nn.Module):
+        super().__init__()
+        # --- 参照モデル (Reference Model) ---
+        # 重みは固定 (Frozen) され、勾配計算は行いません。
+        # これは「アンカー」として機能し、ベースモデルの知識分布を維持します。
+        self.ref_model = ref_model.eval()
+        for p in self.ref_model.parameters():
+            p.requires_grad_(False)
+            
+        # --- 報酬モデル (Reward Model) ---
+        # 学習対象 (Trainable) です。ここには LoRA アダプタが適用されています。
+        # ベースモデルからの偏差（どのトークンが良いか/悪いか）を学習します。
+        self.reward_model = reward_model
+        
+        # モデル設定を共有（Trainer等が参照するため）
+        self.config = self.reward_model.config
+
+    def forward(
+        self,
+        input_ids=None,
+        attention_mask=None,
+        labels=None,
+        pixel_values=None,
+        image_grid_thw=None,
+        video_grid_thw=None, # Qwen2.5-VL video input support
+        **kwargs
+    ):
+        """
+        順伝播 (Forward Pass)
+        ここでは2つのモデルを実行し、出力を合成して損失を計算します。
+        """
+        
+        # 1. 報酬モデルの Forward (学習対象)
+        # 通常の因果的言語モデルとして実行し、ロジット (logits) を取得します。
+        # gradient checkpointing 等に対応するため、use_cache 以外はそのまま渡します。
+        reward_out = self.reward_model(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            pixel_values=pixel_values,
+            image_grid_thw=image_grid_thw,
+            video_grid_thw=video_grid_thw,
+            use_cache=kwargs.get("use_cache", False),
+            output_attentions=False,
+            output_hidden_states=False,
+            return_dict=True,
+            **{k:v for k,v in kwargs.items() if k not in ["use_cache", "output_attentions", "output_hidden_states", "return_dict"]}
+        )
+        reward_logits = reward_out.logits  # 形状: [Batch, SeqLen, Vocab]
+
+        # 2. 参照モデルの Forward (学習しない)
+        # 勾配計算を無効化 (no_grad) してメモリを節約します。
+        with torch.no_grad():
+            ref_out = self.ref_model(
+                input_ids=input_ids,
+                attention_mask=attention_mask,
+                pixel_values=pixel_values,
+                image_grid_thw=image_grid_thw,
+                video_grid_thw=video_grid_thw,
+                use_cache=kwargs.get("use_cache", False),
+                output_attentions=False,
+                output_hidden_states=False,
+                return_dict=True,
+                **{k:v for k,v in kwargs.items() if k not in ["use_cache", "output_attentions", "output_hidden_states", "return_dict"]}
+            )
+            ref_logits = ref_out.logits  # 形状: [Batch, SeqLen, Vocab]
+
+        # 3. PRT合成ロジック (Composition)
+        # 数式: v_theta = log(p_ref(y|x)) + r_phi(x, y)
+        # つまり、「参照モデルの対数確率」に「報酬モデルのロジット（スコア）」を加算します。
+        
+        # log_softmax を適用して対数確率 (Log Probabilities) に変換
+        ref_logp = F.log_softmax(ref_logits, dim=-1)
+        
+        # 単純加算 (PRTの核となる操作)
+        combined_logits = ref_logp + reward_logits
+
+        loss = None
+        if labels is not None:
+            # Shift操作: 言語モデルは「次のトークン」を予測するため、ラベルを1つずらします。
+            # inputs: [A, B, C] -> labels: [B, C, END]
+            shift_logits = combined_logits[..., :-1, :].contiguous()
+            shift_labels = labels[..., 1:].contiguous()
+            
+            # CrossEntropyLoss の計算
+            # 合成された分布 v_theta に対して、正解ラベルの確率を最大化（損失を最小化）します。
+            loss = F.cross_entropy(
+                shift_logits.view(-1, shift_logits.size(-1)),
+                shift_labels.view(-1),
+                ignore_index=-100,
+            )
+
+        # Trainer が期待する形式 (CausalLMOutputWithPast) で返します。
+        # combined_logits を返すことで、eval 時の指標もこの分布に基づきます。
+        return CausalLMOutputWithPast(
+            loss=loss,
+            logits=combined_logits,
+            past_key_values=reward_out.past_key_values,
+            hidden_states=None,
+            attentions=None,
+        )
+
+    def gradient_checkpointing_enable(self, gradient_checkpointing_kwargs=None):
+        """
+        Gradient Checkpointing の有効化
+        Trainerから呼ばれた際、内部の学習対象である reward_model に対して有効化を委譲します。
+        """
+        self.reward_model.gradient_checkpointing_enable(gradient_checkpointing_kwargs=gradient_checkpointing_kwargs)
+
+    def save_pretrained(self, output_dir, **kwargs):
+        """
+        モデル保存時のフック
+        全体を保存するのではなく、学習された LoRA アダプタ部分だけを保存するようにします。
+        """
+        # Reward Model (PeftModel) の save_pretrained を呼び出す
+        if hasattr(self.reward_model, "save_pretrained"):
+            self.reward_model.save_pretrained(output_dir, **kwargs)
+        else:
+            # 万が一 PeftModel でない場合のフォールバック
+            torch.save(self.reward_model.state_dict(), f"{output_dir}/pytorch_model.bin")

examples/prt12_qwen25vl/requirements.txt

@@ -0,0 +1,7 @@
+transformers
+peft
+accelerate
+datasets
+torch
+torchvision
+qwen_vl_utils

examples/prt12_qwen25vl/train_prt12.py

@@ -0,0 +1,251 @@
+import argparse
+import json
+import logging
+import os
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Union
+
+import torch
+from datasets import Dataset
+from peft import LoraConfig, TaskType, get_peft_model
+from PIL import Image
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    AutoProcessor,
+    Trainer,
+    TrainingArguments,
+)
+
+from modeling_prt import PRTQwenVL
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def build_models(model_id: str, torch_dtype, device_map=None, lora_rank=16, lora_alpha=32):
+    """
+    PRT学習用にモデルを構築する関数
+    
+    1. Reference Model (凍結): 比較基準となる元のモデル
+    2. Reward Model (学習): LoRAを適用し、学習を行うモデル
+    
+    これらを PRTQwenVL でラップして返します。
+    """
+    logger.info(f"Loading Reference Model from {model_id}...")
+    # Reference Model: 推論モード (eval) でロード
+    # device_map="auto" は Trainer と競合して "meta tensor" エラーを起こすことがあるため、
+    # 2B程度のサイズであれば明示的に指定しない (None) か、"cpu" 等を指定するのが安全です。
+    ref_model = Qwen2VLForConditionalGeneration.from_pretrained(
+        model_id,
+        torch_dtype=torch_dtype,
+        device_map=device_map, # トレーニング時はTrainerに任せるため None 推奨
+        trust_remote_code=True,
+    ).eval()
+
+    logger.info(f"Loading Reward Model Base from {model_id}...")
+    # Reward Model: こちらも同じチェックポイントからロード
+    reward_model = Qwen2VLForConditionalGeneration.from_pretrained(
+        model_id,
+        torch_dtype=torch_dtype,
+        device_map=device_map,
+        trust_remote_code=True,
+    )
+
+    # LoRA (Low-Rank Adaptation) の適用
+    # Qwen2.5-VL の主要な層 (Attention Projections, MLP Gates) をターゲットにします。
+    target_modules = ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"]
+    logger.info(f"Applying LoRA to Reward Model with rank={lora_rank}, alpha={lora_alpha}, targets={target_modules}")
+    
+    lora_cfg = LoraConfig(
+        task_type=TaskType.CAUSAL_LM,
+        r=lora_rank,
+        lora_alpha=lora_alpha,
+        lora_dropout=0.05,
+        target_modules=target_modules,
+        bias="none",
+    )
+    reward_model = get_peft_model(reward_model, lora_cfg)
+    
+    # 学習可能なパラメータ数を表示
+    reward_model.print_trainable_parameters()
+
+    # PRTラッパーで包む
+    # これにより forward 内で ref + reward の計算が行われるようになります。
+    prt_model = PRTQwenVL(ref_model=ref_model, reward_model=reward_model)
+    return prt_model
+
+@dataclass
+class DataCollatorForPRT:
+    """
+    Qwen2.5-VL 用のデータコレーター
+    リスト形式のサンプルを受け取り、バッチ処理可能な Tensor に変換します。
+    """
+    processor: AutoProcessor
+
+    def __call__(self, features: List[Dict[str, Union[List, str]]]) -> Dict[str, torch.Tensor]:
+        # features は Dataset から取得された生の辞書のリスト
+        # {"image": PIL.Image, "text": "User: <image>..."}
+        
+        texts = []
+        images = []
+        
+        for feature in features:
+            texts.append(feature["text"])
+            images.append(feature["image"])
+
+        # Processor で一括変換 (Padding, Resize 等)
+        inputs = self.processor(
+            text=texts,
+            images=images,
+            return_tensors="pt",
+            padding=True,
+        )
+
+        # ラベルの作成
+        # 教師あり学習 (SFT) と同様に、input_ids を正解ラベルとして使用します。
+        # パディング部分 (Attention Mask が 0 の部分) は計算対象外 (-100) にします。
+        labels = inputs["input_ids"].clone()
+        
+        if "attention_mask" in inputs:
+             labels[inputs["attention_mask"] == 0] = -100
+
+        inputs["labels"] = labels
+        return inputs
+
+
+class PRTDataset(torch.utils.data.Dataset):
+    """
+    JSONL データを読み込むデータセットクラス
+    画像とテキストをペアにして返します。
+    """
+    def __init__(self, jsonl_path, processor):
+        self.data = []
+        self.processor = processor
+        self.root_dir = os.path.dirname(jsonl_path)
+        
+        # JSONL 読み込み
+        with open(jsonl_path, "r") as f:
+            for line in f:
+                if line.strip():
+                    self.data.append(json.loads(line))
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, idx):
+        item = self.data[idx]
+        
+        # 画像の読み込み
+        image_path = item.get("image")
+        if not os.path.isabs(image_path):
+            image_path = os.path.join(self.root_dir, image_path)
+            
+        try:
+            image = Image.open(image_path).convert("RGB")
+        except Exception as e:
+            logger.error(f"Failed to load image {image_path}: {e}")
+            raise e
+
+        # テキストプロンプトの構築
+        # Processor が期待するメッセージ形式を作成します。
+        # Qwen2.5-VL は "image" タイプと "text" タイプを含むリストをサポートしています。
+        question = item.get("question", "Describe this image.")
+        answer = item.get("answer", "")
+        
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "image", "image": image_path},
+                    {"type": "text", "text": question},
+                ]
+            },
+            {
+                "role": "assistant",
+                "content": [{"type": "text", "text": answer}]
+            }
+        ]
+        
+        # apply_chat_template でフォーマット済みのテキストを取得
+        # (例: <|im_start|>user\n<|vision_start|><|image_pad|>...<|vision_end|>Question<|im_end|>\n<|im_start|>assistant\nAnswer<|im_end|>)
+        text_prompt = self.processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=False)
+        
+        return {
+            "image": image,
+            "text": text_prompt
+        }
+
+def train(args):
+    # データ型 (BFloat16 推奨)
+    dtype = torch.bfloat16 if args.bf16 else torch.float16
+    
+    # プロセッサの準備
+    processor = AutoProcessor.from_pretrained(args.model_id, trust_remote_code=True)
+    
+    # モデルの準備 (PRT構成)
+    prt_model = build_models(
+        args.model_id, 
+        torch_dtype=dtype, 
+        device_map=None, # Trainerにデバイス管理を委譲
+        lora_rank=args.lora_rank, 
+        lora_alpha=args.lora_alpha
+    )
+    
+    # データセットとコレーター
+    train_dataset = PRTDataset(args.data_path, processor)
+    collator = DataCollatorForPRT(processor)
+    
+    # Trainer 設定
+    training_args = TrainingArguments(
+        output_dir=args.output_dir,
+        per_device_train_batch_size=args.batch_size,
+        gradient_accumulation_steps=args.gradient_accumulation_steps,
+        learning_rate=args.learning_rate,
+        num_train_epochs=args.epochs,
+        eval_strategy="no",
+        save_strategy="steps",
+        save_steps=args.save_steps,
+        logging_steps=10,
+        bf16=args.bf16,
+        fp16=not args.bf16,
+        remove_unused_columns=False, # PRTWrapperやマルチモーダルのために必須
+        report_to="none", 
+        ddp_find_unused_parameters=False, # ラッパー使用時はFalse推奨
+    )
+    
+    # Trainer 初期化
+    trainer = Trainer(
+        model=prt_model,
+        args=training_args,
+        train_dataset=train_dataset,
+        data_collator=collator,
+    )
+    
+    logger.info("Starting PRT Training...")
+    trainer.train()
+    
+    logger.info(f"Saving Reward Model Adapter to {args.output_dir}")
+    # save_model -> PRTQwenVL.save_pretrained -> RewardModel.save_pretrained
+    # これにより、アダプタのみが保存されます。
+    trainer.save_model()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model_id", type=str, default="Qwen/Qwen2.5-VL-3B-Instruct")
+    parser.add_argument("--data_path", type=str, required=True, help="Path to training jsonl")
+    parser.add_argument("--output_dir", type=str, default="output_prt12")
+    parser.add_argument("--batch_size", type=int, default=1)
+    parser.add_argument("--gradient_accumulation_steps", type=int, default=8)
+    parser.add_argument("--learning_rate", type=float, default=2e-4)
+    parser.add_argument("--epochs", type=int, default=1)
+    parser.add_argument("--save_steps", type=int, default=100)
+    parser.add_argument("--lora_rank", type=int, default=16)
+    parser.add_argument("--lora_alpha", type=int, default=32)
+    parser.add_argument("--bf16", action="store_true", help="Use bfloat16")
+    
+    args = parser.parse_args()
+    
+    if not torch.cuda.is_available() and not torch.backends.mps.is_available():
+        logger.warning("No GPU detected. Training might be extremely slow.")
+        
+    train(args)

examples/prt14_qwen25vl/README.md

@@ -0,0 +1,138 @@
+# PRT14: Portable Reward Tuning (Design A + Hydra + Batch Eval)
+
+このディレクトリには、**PRT (Portable Reward Tuning)** の第14版実装が含まれています。
+PRT14は、これまでの実験で確立された **Design A (Trainer/Generator Separation)** パターンを採用し、設定管理に **Hydra** を導入、さらに評価時の **バッチ推論** に対応した実用的な実装セットです。
+
+## 概要
+
+PRTは、大規模な言語モデル(VL含む)の生成スタイルや特定の報酬を、小型の **Reward Model (LoRA Adapter)** として学習・転移させる技術です。
+本実装では、以下の構成で動作します：
+
+* **学習 (Train)**: ベースモデルを2つ用意し（Ref:凍結, Reward:学習）、KL制約付きの報酬最大化（実際にはCrossEntropyによる模倣学習的アプローチ）を行います。
+* **推論 (Eval)**: 学習したReward Adapterをロードし、StepごとにRefモデルとRewardモデルのLogitsを合成して生成を行います。
+
+## アーキテクチャ
+
+### Training Phase (Design A-Train)
+
+学習時は `PRTTrainer` を使用し、Reference Model の出力を基準として Reward Model を更新します。
+
+```mermaid
+graph LR
+    Input["Input Image/Text"] --> Ref["Reference Model (Frozen)"]
+    Input --> Rew["Reward Model (LoRA Trainable)"]
+    
+    Ref -->|Logits| Loss
+    Rew -->|Logits| Loss
+    
+    Loss["PRT Loss"] -->|Backprop| Rew
+    
+    subgraph Loss Calculation
+    L["Logits Composition"]
+    L -->|"ref_logits + lambda * reward_logits"| CE["CrossEntropy w/ Labels"]
+    end
+```
+
+* **Reference Model**: ベースモデルそのまま (Frozen)。分布の基準となります。
+* **Reward Model**: ベースモデル + LoRA Adapter。報酬信号（正解テキストへの誘導）を学習します。
+* **PRT Loss**: `ref_logits + prt_lambda * reward_logits` を合成し、これをTarget Labelに近づけるように学習します。
+  * *Note*: `ref_logits` は確率分布の基準なので `log_softmax` を適用しますが、`reward_logits` は「報酬値」そのものとして扱うため、`log_softmax` を適用せずにそのまま加算します。
+
+### Inference Phase (Design A-Gen)
+
+推論時は `PRTGenerator` を使用し、2つのモデルを並列で回しながらLogitsを合成してトークンを選択します。
+
+```mermaid
+graph TD
+    User["User Input"] --> P[Processor]
+    P --> Ref["Reference Model (Base)"]
+    P --> Rew["Reward Model (Base + Adapter)"]
+    
+    Ref -->|Logits| Mix(("Composition"))
+    Rew -->|Logits| Mix
+    
+    Mix -->|"v = ref + lambda * rew"| Samp["Sampler / Greedy"]
+    Samp -->|"Next Token"| Out["Output Text"]
+    Out -->|Autoregressive| P
+```
+
+* **Portable**: このAdapterは、同じトークナイザ/埋め込み空間を持つ他のモデル（サイズ違いなど）にも適用できる可能性があります（実験的機能）。
+
+## ファイル構成
+
+* `train_prt14.py`: 学習スクリプト。Hydraで設定を読み込み、`PRTTrainer`でLoRAを学習します。
+* `eval_prt14.py`: 評価スクリプト。`PRTGenerator`を使用し、テストデータのバッチ推論を行います。
+* `configs/`: Hydra設定ファイルディレクトリ。
+  * `config.yaml`: メイン設定ファイル。モデルID、データパス、ハイパーパラメータ等を記述します。
+
+## 使用方法
+
+### 1. 環境構築
+
+```bash
+# （推奨）プロジェクトルートの仮想環境を有効化
+source .venv/bin/activate
+
+# 依存関係インストール（このExample用）
+pip install -r examples/prt14_qwen25vl/requirements.txt
+```
+
+### 2. データセット準備
+
+JSONL形式のデータセットが必要です。
+各行は以下のフォーマットです：
+
+```json
+{"image": "path/to/image.jpg", "question": "Describe...", "answer": "Target answer..."}
+```
+
+### 3. 学習 (Training)
+
+`config.yaml` を編集するか、コマンドライン引数で設定を上書きして実行します。
+
+```bash
+# 基本実行 (config.yamlの設定を使用)
+python examples/prt14_qwen25vl/train_prt14.py
+
+# パラメータを上書きして実行
+python examples/prt14_qwen25vl/train_prt14.py \
+    model.model_id="Qwen/Qwen2-VL-2B-Instruct" \
+    data.path="data/my_dataset.jsonl" \
+    training.batch_size=4 \
+    training.prt_lambda=1.5
+```
+
+### 4. 推論・評価 (Evaluation)
+
+学習したAdapter（`output_prt14`など）を指定して推論を行います。
+PRT14ではDataLoaderによるバッチ処理に対応しており、大量の評価データを効率的に処理できます。
+
+```bash
+# 基本実行 (学習時のoutput_dirが自動的にadapter_pathとして使われる設定の場合)
+python examples/prt14_qwen25vl/eval_prt14.py
+
+# データセットとパラメータを指定して実行
+python examples/prt14_qwen25vl/eval_prt14.py \
+    data.path="data/test_data.jsonl" \
+    training.batch_size=8 \
+    training.output_dir="output_prt14" \
+    generation.max_new_tokens=100
+```
+
+## 主なクラス
+
+### `PRTTrainer` (`train_prt14.py`)
+
+`transformers.Trainer` を継承。`compute_loss` をオーバーライドし、Algorithm 1 に基づく PRT Loss 計算を実装しています。
+
+### `PRTGenerator` (`eval_prt14.py`)
+
+推論専用クラス。RefモデルとRewardモデルを保持し、`generate` メソッド内で Step-by-Step の Logits 合成 (Algorithm 2) を行います。
+
+### `EvalDataset` (`eval_prt14.py`)
+
+評価用データローダー。画像パスの解決と読み込み、バッチ化のための前処理を行います。
+
+## 更新履歴
+
+* **PRT14**: Hydra設定管理の導入、DataLoaderによるBatch Eval対応、コード構造の整理。

examples/prt14_qwen25vl/configs/config.yaml

@@ -0,0 +1,39 @@
+defaults:
+  - _self_
+
+model:
+  model_id: "Qwen/Qwen2-VL-2B-Instruct"
+  bf16: true
+  use_lora: true
+
+data:
+  path: "examples/prt12_qwen25vl/dummy_data.jsonl"
+  test_image_path: "examples/prt12_qwen25vl/test_image.jpg"
+  test_prompt: "Describe this image."
+
+generation:
+  max_new_tokens: 100
+  temperature: 0.7
+  top_p: 0.9
+
+
+training:
+  output_dir: "output_prt14"
+  batch_size: 1
+  gradient_accumulation_steps: 8
+  learning_rate: 2.0e-4
+  epochs: 1
+  save_steps: 100
+  prt_lambda: 1.0
+
+lora:
+  rank: 16
+  alpha: 32
+  target_modules: 
+    - "q_proj"
+    - "k_proj"
+    - "v_proj"
+    - "o_proj"
+    - "gate_proj"
+    - "up_proj"
+    - "down_proj"

examples/prt14_qwen25vl/eval_prt14.py

@@ -0,0 +1,305 @@
+import sys,os,gc
+import torch
+import torch.nn.functional as F
+import json
+from transformers import Qwen2VLForConditionalGeneration, AutoProcessor
+from peft import PeftModel
+from PIL import Image
+import requests
+import math
+import hydra
+from tqdm import tqdm
+from torch.utils.data import Dataset, DataLoader
+from omegaconf import DictConfig, OmegaConf
+import logging
+import importlib
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class EvalDataset(Dataset):
+    def __init__(self, data_path):
+        self.data = []
+        with open(data_path, 'r') as f:
+            for line in f:
+                if line.strip():
+                    self.data.append(json.loads(line))
+        self.image_dir = os.path.dirname(data_path) # Assuming images are relative to the data_path's directory
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, idx):
+        item = self.data[idx]
+        image_filename = item.get('image', None)
+        image = None
+        if image_filename:
+            image_path = image_filename if os.path.isabs(image_filename) else os.path.join(self.image_dir, image_filename)
+            try:
+                image = Image.open(image_path).convert("RGB")
+            except Exception as e:
+                logger.warning(f"Could not load image {image_path}: {e}")
+                image = None # Handle missing/corrupt images
+        
+        return {
+            'id': item.get('id', idx), # Use index if 'id' is not present
+            'image': image,
+            'question': item.get('question', ''),
+            'answer': item.get('answer', '')
+        }
+
+def eval_collate_fn(batch):
+    ids = [item['id'] for item in batch]
+    images = [item['image'] for item in batch]
+    questions = [item['question'] for item in batch]
+    answers = [item['answer'] for item in batch]
+    return {
+        'ids': ids,
+        'images': images,
+        'questions': questions,
+        'answers': answers
+    }
+
+class PRTGenerator:
+    """
+    推論専用の PRT ジェネレータークラス (Design A + Hydra)
+    RefモデルとRewardモデルを保持し、PRTによる生成を管理します。
+    """
+    def __init__(self, base_model_id, adapter_path=None, device="cuda", dtype=torch.bfloat16):
+        self.device = device
+        self.dtype = dtype
+        
+        logger.info(f"Loading Base Models from {base_model_id}...")
+        # 1. Reference Model (Base)
+        self.ref_model = Qwen2VLForConditionalGeneration.from_pretrained(
+            base_model_id,
+            torch_dtype=dtype,
+            device_map=device,
+            trust_remote_code=True,
+        ).eval()
+
+        # 2. Reward Model (Base + Adapter)
+        #    初期状態では Base と同じ
+        self.reward_model = Qwen2VLForConditionalGeneration.from_pretrained(
+            base_model_id,
+            torch_dtype=dtype,
+            device_map=device,
+            trust_remote_code=True,
+        )
+
+        if adapter_path:
+            logger.info(f"Loading Adapter from {adapter_path}...")
+            # Check if adapter_model.bin exists (simple check)
+            import os
+            if os.path.exists(os.path.join(adapter_path, "adapter_model.bin")) or os.path.exists(os.path.join(adapter_path, "adapter_model.safetensors")):
+                self.reward_model = PeftModel.from_pretrained(self.reward_model, adapter_path)
+            else:
+                logger.warning(f"Adapter file not found at {adapter_path}. Proceeding with raw base model (Identity PRT).")
+        else:
+            logger.info("Adapter not specified. Reward model is same as Ref model (Identity PRT).")
+        
+        self.reward_model.to(device).eval()
+        
+        # Processor
+        self.processor = AutoProcessor.from_pretrained(base_model_id, trust_remote_code=True)
+
+    @torch.no_grad()
+    def generate(self, image_input, prompt, max_new_tokens=100, prt_lambda=1.0, temperature=0.7, top_p=0.9):
+        """
+        PRT Generation (Greedy or Sampling)
+        Algorithm 2 に基づき、Stepごとに Logits を合成して生成します。
+        """
+        
+        # --- Preprocessing ---
+        # logger.info(f"Processing image...")
+        try:
+            if isinstance(image_input, Image.Image):
+                image = image_input
+            elif isinstance(image_input, str):
+                if image_input.startswith("http"):
+                    image = Image.open(requests.get(image_input, stream=True).raw).convert("RGB")
+                else:
+                    image = Image.open(image_input).convert("RGB")
+            else:
+                 raise ValueError("image_input must be PIL.Image or str path")
+        except Exception as e:
+            logger.error(f"Failed to load image: {e}")
+            return "Error: Image load failed."
+
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "image", "image": image},
+                    {"type": "text", "text": prompt},
+                ],
+            }
+        ]
+        text_prompt = self.processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+        inputs = self.processor(
+            text=[text_prompt],
+            images=[image],
+            padding=True,
+            return_tensors="pt",
+        ).to(self.device)
+
+        input_ids = inputs.input_ids
+        attention_mask = inputs.attention_mask
+        pixel_values = inputs.pixel_values
+        image_grid_thw = inputs.image_grid_thw
+        
+        # --- Generation Loop ---
+        
+        # KV Caches (Ref/Reward で独立して管理)
+        past_ref = None
+        past_reward = None
+        
+        generated_ids = input_ids.clone()
+        current_input_ids = input_ids
+        
+        first_step = True
+        
+        for _ in range(max_new_tokens):
+            
+            # 共通のkwargs (cache利用)
+            fwd_kwargs = {"use_cache": True}
+            
+            # 初回のみ画像等のFull Inputを渡す
+            if first_step:
+                fwd_kwargs.update({
+                    "attention_mask": attention_mask,
+                    "pixel_values": pixel_values,
+                    "image_grid_thw": image_grid_thw,
+                })
+            
+            # 1. Ref Model Forward
+            ref_out = self.ref_model(
+                input_ids=current_input_ids,
+                past_key_values=past_ref,
+                **fwd_kwargs
+            )
+            past_ref = ref_out.past_key_values
+            ref_logits = ref_out.logits[:, -1, :]
+            
+            # 2. Reward Model Forward
+            rew_out = self.reward_model(
+                input_ids=current_input_ids,
+                past_key_values=past_reward,
+                **fwd_kwargs
+            )
+            past_reward = rew_out.past_key_values
+            reward_logits = rew_out.logits[:, -1, :]
+
+            # 3. Logits Composition (Algorithm 2)
+            #    v = log_softmax(ref) + lambda * reward
+            ref_logp = F.log_softmax(ref_logits, dim=-1)
+            combined_logits = ref_logp + (prt_lambda * reward_logits)
+            
+            # 4. Token Selection (Sampling or Greedy)
+            if temperature > 0:
+                # Apply Temperature
+                logits = combined_logits / temperature
+                probs = F.softmax(logits, dim=-1)
+                
+                # Apply Top-P (Nucleus Sampling)
+                if top_p < 1.0:
+                    sorted_probs, sorted_indices = torch.sort(probs, descending=True)
+                    cumulative_probs = torch.cumsum(sorted_probs, dim=-1)
+                    
+                    # Remove tokens with cumulative probability above the threshold
+                    sorted_indices_to_remove = cumulative_probs > top_p
+                    # Shift the indices to the right to keep also the first token above the threshold
+                    sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone()
+                    sorted_indices_to_remove[..., 0] = 0
+                    
+                    indices_to_remove = sorted_indices_to_remove.scatter(1, sorted_indices, sorted_indices_to_remove)
+                    probs[indices_to_remove] = 0.0
+                    probs = probs / probs.sum(dim=-1, keepdim=True) # Re-normalize
+
+                next_token = torch.multinomial(probs, num_samples=1)
+            else:
+                # Greedy
+                next_token = torch.argmax(combined_logits, dim=-1, keepdim=True)
+            
+            # Append & Update
+            generated_ids = torch.cat([generated_ids, next_token], dim=-1)
+            current_input_ids = next_token
+            first_step = False
+            
+            # Stop Check
+            if next_token.item() == self.processor.tokenizer.eos_token_id:
+                break
+
+        # Decode
+        generated_ids_trimmed = generated_ids[:, inputs.input_ids.shape[1]:]
+        output_text = self.processor.batch_decode(generated_ids_trimmed, skip_special_tokens=True)[0]
+        
+        return output_text
+
+
+@hydra.main(version_base=None, config_path="configs", config_name="config")
+def main(cfg: DictConfig):
+    logger.info(f"Configuration:\n{OmegaConf.to_yaml(cfg)}")
+    # Hydra はデフォルトで実行ディレクトリを outputs/... に変更するため、
+    # 学習成果物やローカル画像パスは to_absolute_path で元のcwd基準に解決して扱う。
+    adapter_path = hydra.utils.to_absolute_path(cfg.training.output_dir)
+    
+    device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"
+    dtype = torch.float32 if device == "cpu" else torch.bfloat16
+
+    generator = PRTGenerator(
+        base_model_id=cfg.model.model_id,
+        adapter_path=adapter_path, # 学習時のoutput_dirをadapter_pathとみなす
+        device=device,
+        dtype=dtype
+    )
+    
+    # Setup DataLoader
+    data_path = hydra.utils.to_absolute_path(cfg.data.path)
+    logger.info(f"Loading dataset from {data_path}")
+    dataset = EvalDataset(data_path)
+    dataloader = DataLoader(
+        dataset, 
+        batch_size=cfg.training.batch_size, 
+        shuffle=False, 
+        # NOTE: PIL.Image を返す Dataset をマルチプロセス DataLoader で扱うと
+        # 環境によっては不安定になりやすいので安全側で 0 に固定。
+        num_workers=0,
+        collate_fn=eval_collate_fn
+    )
+
+    logger.info("--- Starting Evaluation ---")
+    
+    for batch in tqdm(dataloader):
+        ids = batch['ids']
+        images = batch['images']
+        questions = batch['questions']
+        answers = batch['answers']
+        
+        try:
+            for i, idx in enumerate(ids):
+                img = images[i]
+                q = questions[i]
+                
+                if img is None:
+                    logger.warning(f"Skipping ID {idx} due to image loading error.")
+                    continue
+
+                output = generator.generate(
+                    image_input=img,
+                    prompt=q,
+                    max_new_tokens=cfg.generation.max_new_tokens,
+                    prt_lambda=cfg.training.prt_lambda,
+                    temperature=cfg.generation.get("temperature", 0.0), # Default to Greedy if not specified
+                    top_p=cfg.generation.get("top_p", 1.0)
+                )
+                
+                print(f"\n[ID: {idx}] Q: {q}\nA (GT): {answers[i]}\nA (Pred): {output}")
+        except Exception as e:
+            logger.error(f"Error in batch: {e}")
+
+    logger.info("Evaluation Completed.")
+
+if __name__ == "__main__":
+    main()

examples/prt14_qwen25vl/requirements.txt

@@ -0,0 +1,12 @@
+transformers
+peft
+accelerate
+datasets
+torch
+torchvision
+pillow
+requests
+tqdm
+qwen_vl_utils
+hydra-core
+omegaconf

examples/prt14_qwen25vl/train_prt14.py

@@ -0,0 +1,265 @@
+import logging
+import os
+import json
+import hydra
+from omegaconf import DictConfig, OmegaConf
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Union
+
+import torch
+import torch.nn.functional as F
+from torch.utils.data import Dataset
+from peft import LoraConfig, TaskType, get_peft_model
+from PIL import Image
+from transformers import (
+    Qwen2VLForConditionalGeneration,
+    AutoProcessor,
+    Trainer,
+    TrainingArguments,
+    get_scheduler,
+)
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+@dataclass
+class PRTTrainingArguments(TrainingArguments):
+    """PRT固有のパラメータを追加したTrainingArguments"""
+    prt_lambda: float = 1.0  # Rewardの強さ
+
+class PRTTrainer(Trainer):
+    """
+    PRT (Portable Reward Tuning) 用のカスタムトレーナー
+    標準の Trainer を継承し、compute_loss をオーバーライドして PRT の損失計算を行います。
+    Architecture:
+      - self.model: 学習対象の Reward Model (LoRA適用済み)
+      - self.ref_model: 凍結された Reference Model (コンストラクタで受け取る)
+    """
+    def __init__(self, ref_model, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.ref_model = ref_model
+        # Reference Model は常に評価モード＆勾配計算なし
+        self.ref_model.eval()
+        for p in self.ref_model.parameters():
+            p.requires_grad_(False)
+        
+        # args から prt_lambda を取得 (デフォルトは 1.0)
+        self.prt_lambda = getattr(self.args, "prt_lambda", 1.0)
+        logger.info(f"Initialized PRTTrainer with lambda={self.prt_lambda}")
+
+    def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None):
+        """
+        PRT ロス計算ロジック (Algorithm 1)
+        Loss = CrossEntropy( log_softmax(ref_logits) + lambda * reward_logits, labels )
+        """
+        device = model.device
+        
+        # ref_model が同じデバイスにあるか確認 (なければ移動)
+        if self.ref_model.device != device:
+             self.ref_model.to(device)
+
+        with torch.no_grad():
+            ref_outputs = self.ref_model(**inputs)
+            ref_logits = ref_outputs.logits
+
+        # Reward Model Forward
+        outputs = model(**inputs)
+        reward_logits = outputs.logits
+
+        # Logits 合成
+        ref_logp = F.log_softmax(ref_logits, dim=-1)
+        # Rewardモデルはスカラー値(Logits)として扱うため、log_softmaxはかけない
+        combined_logits = ref_logp + (self.prt_lambda * reward_logits)
+
+        # Cross Entropy Loss 計算
+        labels = inputs.get("labels")
+        if labels is None:
+             raise ValueError("Labels are required for PRT training")
+
+        shift_logits = combined_logits[..., :-1, :].contiguous()
+        shift_labels = labels[..., 1:].contiguous()
+        
+        loss_fct = torch.nn.CrossEntropyLoss()
+        loss = loss_fct(
+            shift_logits.view(-1, shift_logits.size(-1)),
+            shift_labels.view(-1)
+        )
+
+        return (loss, outputs) if return_outputs else loss
+
+
+@dataclass
+class DataCollatorForPRT:
+    """Qwen2.5-VL 用のデータコレーター"""
+    processor: AutoProcessor
+
+    def __call__(self, features: List[Dict[str, Union[List, str]]]) -> Dict[str, torch.Tensor]:
+        texts = [f["text"] for f in features]
+        images = [f["image"] for f in features]
+
+        inputs = self.processor(
+            text=texts,
+            images=images,
+            return_tensors="pt",
+            padding=True,
+        )
+
+        labels = inputs["input_ids"].clone()
+        if "attention_mask" in inputs:
+             labels[inputs["attention_mask"] == 0] = -100
+        inputs["labels"] = labels
+        return inputs
+
+class PRTDataset(Dataset):
+    """JSONL データセット"""
+    def __init__(self, jsonl_path, processor):
+        self.data = []
+        self.processor = processor
+        self.root_dir = os.path.dirname(jsonl_path)
+        with open(jsonl_path, "r") as f:
+            for line in f:
+                if line.strip():
+                    self.data.append(json.loads(line))
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, idx):
+        item = self.data[idx]
+        image_path = item.get("image")
+        if not os.path.isabs(image_path):
+            image_path = os.path.join(self.root_dir, image_path)
+        try:
+            image = Image.open(image_path).convert("RGB")
+        except:
+            image = Image.new("RGB", (224, 224)) # Fallback dummy
+
+        question = item.get("question", "Describe this image.")
+        answer = item.get("answer", "")
+        
+        messages = [
+            {"role": "user", "content": [{"type": "image", "image": image_path}, {"type": "text", "text": question}]},
+            {"role": "assistant", "content": [{"type": "text", "text": answer}]}
+        ]
+        text_prompt = self.processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=False)
+        return {"image": image, "text": text_prompt}
+
+
+@hydra.main(version_base=None, config_path="configs", config_name="config")
+def main(cfg: DictConfig):
+    logger.info(f"Configuration:\n{OmegaConf.to_yaml(cfg)}")
+    # Hydra はデフォルトで実行ディレクトリを outputs/... に変更するため、
+    # 相対パスは to_absolute_path で元のcwd基準に解決して扱う。
+    data_path = hydra.utils.to_absolute_path(cfg.data.path)
+    output_dir = hydra.utils.to_absolute_path(cfg.training.output_dir)
+    
+    # 0. Load processor (Lightweight, needed for dataset)
+    logger.info(f"Loading Processor: {cfg.model.model_id}")
+    processor = AutoProcessor.from_pretrained(cfg.model.model_id, trust_remote_code=True)
+    dataset_cls = PRTDataset
+
+    # 1. Load dataset (Fail fast)
+    logger.info(f"Loading Dataset from {data_path}")
+    train_dataset = dataset_cls(data_path, processor)
+    collator = DataCollatorForPRT(processor)
+    
+    # 2. Load Models (Heavy)
+    logger.info(f"Loading Models: {cfg.model.model_id}")
+    
+    # Reference Model (Frozen)
+    ref_model = Qwen2VLForConditionalGeneration.from_pretrained(
+        cfg.model.model_id,
+        torch_dtype=torch.bfloat16 if cfg.model.bf16 else torch.float16,
+        device_map=None, 
+        trust_remote_code=True,
+    )
+    
+    # Reward Model (Trainable Base)
+    reward_model = Qwen2VLForConditionalGeneration.from_pretrained(
+        cfg.model.model_id,
+        torch_dtype=torch.bfloat16 if cfg.model.bf16 else torch.float16,
+        device_map=None,
+        trust_remote_code=True,
+    )
+
+    # Configure LoRA
+    if cfg.model.use_lora:
+        logger.info("Applying LoRA to Reward Model...")
+        lora_config = LoraConfig(
+            r=cfg.lora.rank,
+            lora_alpha=cfg.lora.alpha,
+            target_modules=list(cfg.lora.target_modules),
+            bias="none",
+            task_type="CAUSAL_LM",
+        )
+        reward_model = get_peft_model(reward_model, lora_config)
+        reward_model.print_trainable_parameters()
+    else:
+        logger.info("Full Fine-Tuning Mode")
+        reward_model.gradient_checkpointing_enable()
+
+    # Define training arguments
+    training_args = PRTTrainingArguments(
+        output_dir=output_dir,
+        per_device_train_batch_size=cfg.training.batch_size,
+        gradient_accumulation_steps=cfg.training.gradient_accumulation_steps,
+        learning_rate=cfg.training.learning_rate,
+        num_train_epochs=cfg.training.epochs,
+        save_strategy="steps",
+        save_steps=cfg.training.save_steps,
+        logging_steps=10,
+        bf16=cfg.model.bf16,
+        fp16=not cfg.model.bf16,
+        report_to="none",
+        remove_unused_columns=False,
+        ddp_find_unused_parameters=False,
+        prt_lambda=cfg.training.prt_lambda,
+    )
+
+    # Prepare optimizer + scheduler
+    # Trainerのデフォルトに任せることもできるが、明示的な管理のためにここで構築する
+    # ※ Full FTとLoRAでパラメータが異なるため、filtered_paramsを使用
+    optimizer = torch.optim.AdamW(
+        filter(lambda p: p.requires_grad, reward_model.parameters()),
+        lr=cfg.training.learning_rate
+    )
+    
+    # スケジューラ計算のためにステップ数が必要
+    num_update_steps_per_epoch = max(
+        1,
+        len(train_dataset) // (cfg.training.batch_size * cfg.training.gradient_accumulation_steps),
+    )
+    max_train_steps = max(1, cfg.training.epochs * num_update_steps_per_epoch)
+    
+    lr_scheduler = get_scheduler(
+        name="linear",
+        optimizer=optimizer,
+        num_warmup_steps=0, # 必要に応じてConfig化
+        num_training_steps=max_train_steps,
+    )
+
+    # Initialize PRT Trainer
+    logger.info("Initializing PRTTrainer")
+    trainer = PRTTrainer(
+        model=reward_model,
+        ref_model=ref_model,
+        args=training_args,
+        train_dataset=train_dataset,
+        data_collator=collator,
+        optimizers=(optimizer, lr_scheduler), # 明示的に渡す
+    )
+
+    # Train
+    logger.info("Starting PRT14 Training...")
+    trainer.train()
+    
+    # 8. Save fine-tuned model and processor
+    trainer.save_model()
+    # processorはtrainer.save_modelでは保存されない場合があるため明示的に保存推奨だが、
+    # PeftModelの場合はsave_pretrainedが呼ばれる。念のためプロセッサも保存。
+    processor.save_pretrained(output_dir)
+    logger.info(f"Saved model and processor to {output_dir}")
+
+if __name__ == "__main__":
+    main()