機能追加: モデルラインナップ拡張とGradio UI移行

- 新モデル11種追加（GPT-OSS, Pythia, OLMo, BLOOM, Llama, Qwen, Mistral）
- Gradio UIへ移行（ZeroGPU対応で無料GPU利用可能）
- Streamlit UIをバックアップとして src/ui/streamlit/ に保持
- 全62テストパス

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

app.py

@@ -1,32 +1,19 @@
 """
-WILL - Pure Computational Will
+WILL - Pure Computational Will (Gradio版)
 
 言語モデルにランダムノイズを入力し、
 人間の問いかけなしにモデルの構造だけが
 出力するものを観測する
-"""
-import streamlit as st
 
-from src.ui.styles import CUSTOM_CSS
-from src.ui.pages import render_generate_page, render_concept_page
+ZeroGPU対応 - Hugging Face Spacesで無料GPU利用可能
+"""
+from src.ui.gradio import create_app
 
 
 def main():
     """アプリケーションのエントリーポイント"""
-    # ページ設定
-    st.set_page_config(page_title="will", page_icon="", layout="centered")
-
-    # カスタムCSS適用
-    st.markdown(CUSTOM_CSS, unsafe_allow_html=True)
-
-    # タブ構成
-    tab1, tab2 = st.tabs(["GENERATE", "CONCEPT"])
-
-    with tab1:
-        render_generate_page()
-
-    with tab2:
-        render_concept_page()
+    app = create_app()
+    app.launch()
 
 
 if __name__ == "__main__":

app_streamlit.py

@@ -0,0 +1,33 @@
+"""
+WILL - Pure Computational Will (Streamlit版)
+
+言語モデルにランダムノイズを入力し、
+人間の問いかけなしにモデルの構造だけが
+出力するものを観測する
+"""
+import streamlit as st
+
+from src.ui.streamlit.styles import CUSTOM_CSS
+from src.ui.streamlit.pages import render_generate_page, render_concept_page
+
+
+def main():
+    """アプリケーションのエントリーポイント"""
+    # ページ設定
+    st.set_page_config(page_title="will", page_icon="", layout="centered")
+
+    # カスタムCSS適用
+    st.markdown(CUSTOM_CSS, unsafe_allow_html=True)
+
+    # タブ構成
+    tab1, tab2 = st.tabs(["GENERATE", "CONCEPT"])
+
+    with tab1:
+        render_generate_page()
+
+    with tab2:
+        render_concept_page()
+
+
+if __name__ == "__main__":
+    main()

pytest.ini

@@ -0,0 +1,3 @@
+[pytest]
+markers =
+    slow: marks tests as slow (deselect with '-m "not slow"')

src/models/bloom.py

@@ -0,0 +1,80 @@
+"""
+BLOOM モデル実装
+
+BigScienceによる完全オープンソースモデル
+多言語対応、ALiBi位置埋め込みを採用
+"""
+from typing import List, Tuple
+
+import torch
+from transformers import BloomForCausalLM, AutoTokenizer
+
+from .base import BaseLanguageModel, ModelConfig
+
+
+# BLOOM 560M設定
+BLOOM_560M_CONFIG = ModelConfig(
+    name="BLOOM 560M",
+    model_id="bigscience/bloom-560m",
+    embedding_dim=1024,
+    vocab_size=250880,
+)
+
+
+class BLOOMModel(BaseLanguageModel):
+    """
+    BLOOMモデルの実装
+
+    BigScienceが公開した完全オープンソースモデル。
+    多言語対応、ALiBi位置埋め込みを採用。
+    """
+
+    # 出力ノイズの倍率（学習バイアス破壊用）
+    LOGITS_NOISE_SCALE = 10.0
+
+    def load(self) -> None:
+        """モデルとトークナイザーをロード"""
+        if self._is_loaded:
+            return
+
+        try:
+            self._model = BloomForCausalLM.from_pretrained(self._config.model_id)
+            self._tokenizer = AutoTokenizer.from_pretrained(self._config.model_id)
+            self._model.eval()
+            self._is_loaded = True
+        except Exception as e:
+            raise RuntimeError(f"Failed to load model {self._config.model_id}: {e}")
+
+    def forward_with_noise(
+        self, noise: torch.Tensor
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        """
+        ノイズを入力として順伝播を実行し、出力にもノイズを加算
+
+        Args:
+            noise: 入力ノイズテンソル [batch, seq_len, embedding_dim]
+
+        Returns:
+            Tuple[logits, corrupted_logits]
+        """
+        if not self._is_loaded:
+            raise RuntimeError("Model not loaded. Call load() first.")
+
+        with torch.no_grad():
+            outputs = self._model(inputs_embeds=noise)
+            logits = outputs.logits
+
+            # 出力logitsにノイズを加算して学習バイアスを破壊
+            logits_noise = (
+                torch.randn_like(logits) * logits.std() * self.LOGITS_NOISE_SCALE
+            )
+            corrupted_logits = logits + logits_noise
+
+        return logits, corrupted_logits
+
+    def decode_indices(self, indices: List[int]) -> List[str]:
+        """トークンインデックスをデコード"""
+        if not self._is_loaded:
+            raise RuntimeError("Model not loaded. Call load() first.")
+
+        return [self._tokenizer.decode([i]) for i in indices]

src/models/gpt_oss.py

@@ -0,0 +1,84 @@
+"""
+GPT-OSS モデル実装
+
+OpenAIの完全オープンソースモデル（Apache 2.0）
+MoEアーキテクチャで21Bパラメータ、active 3.6B
+"""
+from typing import List, Tuple
+
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+from .base import BaseLanguageModel, ModelConfig
+
+
+# GPT-OSS 20B設定（MoEモデル）
+GPT_OSS_20B_CONFIG = ModelConfig(
+    name="GPT-OSS 20B (MoE)",
+    model_id="openai/gpt-oss-20b",
+    embedding_dim=4096,
+    vocab_size=128000,
+)
+
+
+class GPTOSSModel(BaseLanguageModel):
+    """
+    GPT-OSS MoEモデルの実装
+
+    OpenAIがApache 2.0でリリースした完全オープンソースモデル。
+    21Bパラメータ（active 3.6B）のMoEアーキテクチャ。
+    """
+
+    # 出力ノイズの倍率（学習バイアス破壊用）
+    LOGITS_NOISE_SCALE = 10.0
+
+    def load(self) -> None:
+        """モデルとトークナイザーをロード"""
+        if self._is_loaded:
+            return
+
+        try:
+            self._model = AutoModelForCausalLM.from_pretrained(
+                self._config.model_id,
+                torch_dtype="auto",
+                device_map="auto",
+            )
+            self._tokenizer = AutoTokenizer.from_pretrained(self._config.model_id)
+            self._model.eval()
+            self._is_loaded = True
+        except Exception as e:
+            raise RuntimeError(f"Failed to load model {self._config.model_id}: {e}")
+
+    def forward_with_noise(
+        self, noise: torch.Tensor
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        """
+        ノイズを入力として順伝播を実行し、出力にもノイズを加算
+
+        Args:
+            noise: 入力ノイズテンソル [batch, seq_len, embedding_dim]
+
+        Returns:
+            Tuple[logits, corrupted_logits]
+        """
+        if not self._is_loaded:
+            raise RuntimeError("Model not loaded. Call load() first.")
+
+        with torch.no_grad():
+            outputs = self._model(inputs_embeds=noise)
+            logits = outputs.logits
+
+            # 出力logitsにノイズを加算して学習バイアスを破壊
+            logits_noise = (
+                torch.randn_like(logits) * logits.std() * self.LOGITS_NOISE_SCALE
+            )
+            corrupted_logits = logits + logits_noise
+
+        return logits, corrupted_logits
+
+    def decode_indices(self, indices: List[int]) -> List[str]:
+        """トークンインデックスをデコード"""
+        if not self._is_loaded:
+            raise RuntimeError("Model not loaded. Call load() first.")
+
+        return [self._tokenizer.decode([i]) for i in indices]

src/models/llama.py

@@ -0,0 +1,96 @@
+"""
+Llama モデル実装
+
+Meta社の最新Llamaモデル
+GQA/RoPE/SwiGLUなど最新アーキテクチャを採用
+HuggingFace認証が必要
+"""
+from typing import List, Tuple
+
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+from .base import BaseLanguageModel, ModelConfig
+
+
+# Llama 3.2 1B設定
+LLAMA_3_2_1B_CONFIG = ModelConfig(
+    name="Llama 3.2 1B",
+    model_id="meta-llama/Llama-3.2-1B",
+    embedding_dim=2048,
+    vocab_size=128256,
+)
+
+# Llama 3.2 3B設定
+LLAMA_3_2_3B_CONFIG = ModelConfig(
+    name="Llama 3.2 3B",
+    model_id="meta-llama/Llama-3.2-3B",
+    embedding_dim=3072,
+    vocab_size=128256,
+)
+
+
+class LlamaModel(BaseLanguageModel):
+    """
+    Llamaモデルの実装
+
+    Meta社の最新Llama 3.2シリーズ。
+    GQA/RoPE/SwiGLU採用。HuggingFace認証が必要。
+    """
+
+    # 出力ノイズの倍率（学習バイアス破壊用）
+    LOGITS_NOISE_SCALE = 10.0
+
+    def load(self) -> None:
+        """モデルとトークナイザーをロード"""
+        if self._is_loaded:
+            return
+
+        try:
+            self._model = AutoModelForCausalLM.from_pretrained(
+                self._config.model_id,
+                torch_dtype="auto",
+            )
+            self._tokenizer = AutoTokenizer.from_pretrained(self._config.model_id)
+            self._model.eval()
+            self._is_loaded = True
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to load model {self._config.model_id}: {e}. "
+                "Note: Llama models require HuggingFace authentication. "
+                "Run 'huggingface-cli login' first."
+            )
+
+    def forward_with_noise(
+        self, noise: torch.Tensor
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        """
+        ノイズを入力として順伝播を実行し、出力にもノイズを加算
+
+        Args:
+            noise: 入力ノイズテンソル [batch, seq_len, embedding_dim]
+
+        Returns:
+            Tuple[logits, corrupted_logits]
+        """
+        if not self._is_loaded:
+            raise RuntimeError("Model not loaded. Call load() first.")
+
+        with torch.no_grad():
+            outputs = self._model(inputs_embeds=noise)
+            logits = outputs.logits
+
+            # 出力logitsにノイズを加算して学習バイアスを破壊
+            logits_noise = (
+                torch.randn_like(logits) * logits.std() * self.LOGITS_NOISE_SCALE
+            )
+            corrupted_logits = logits + logits_noise
+
+        return logits, corrupted_logits
+
+    def decode_indices(self, indices: List[int]) -> List[str]:
+        """トークンインデックスをデコード"""
+        if not self._is_loaded:
+            raise RuntimeError("Model not loaded. Call load() first.")
+
+        return [self._tokenizer.decode([i]) for i in indices]

src/models/mistral.py

@@ -0,0 +1,83 @@
+"""
+Mistral モデル実装
+
+Mistral AI社のモデル
+Sliding Window Attention、GQA採用
+"""
+from typing import List, Tuple
+
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+from .base import BaseLanguageModel, ModelConfig
+
+
+# Mistral 7B設定
+MISTRAL_7B_CONFIG = ModelConfig(
+    name="Mistral 7B v0.3",
+    model_id="mistralai/Mistral-7B-v0.3",
+    embedding_dim=4096,
+    vocab_size=32768,
+)
+
+
+class MistralModel(BaseLanguageModel):
+    """
+    Mistralモデルの実装
+
+    Mistral AI社のMistral 7Bシリーズ。
+    Sliding Window Attention、GQA採用。
+    """
+
+    # 出力ノイズの倍率（学習バイアス破壊用）
+    LOGITS_NOISE_SCALE = 10.0
+
+    def load(self) -> None:
+        """モデルとトークナイザーをロード"""
+        if self._is_loaded:
+            return
+
+        try:
+            self._model = AutoModelForCausalLM.from_pretrained(
+                self._config.model_id,
+                torch_dtype="auto",
+            )
+            self._tokenizer = AutoTokenizer.from_pretrained(self._config.model_id)
+            self._model.eval()
+            self._is_loaded = True
+        except Exception as e:
+            raise RuntimeError(f"Failed to load model {self._config.model_id}: {e}")
+
+    def forward_with_noise(
+        self, noise: torch.Tensor
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        """
+        ノイズを入力として順伝播を実行し、出力にもノイズを加算
+
+        Args:
+            noise: 入力ノイズテンソル [batch, seq_len, embedding_dim]
+
+        Returns:
+            Tuple[logits, corrupted_logits]
+        """
+        if not self._is_loaded:
+            raise RuntimeError("Model not loaded. Call load() first.")
+
+        with torch.no_grad():
+            outputs = self._model(inputs_embeds=noise)
+            logits = outputs.logits
+
+            # 出力logitsにノイズを加算して学習バイアスを破壊
+            logits_noise = (
+                torch.randn_like(logits) * logits.std() * self.LOGITS_NOISE_SCALE
+            )
+            corrupted_logits = logits + logits_noise
+
+        return logits, corrupted_logits
+
+    def decode_indices(self, indices: List[int]) -> List[str]:
+        """トークンインデックスをデコード"""
+        if not self._is_loaded:
+            raise RuntimeError("Model not loaded. Call load() first.")
+
+        return [self._tokenizer.decode([i]) for i in indices]

src/models/olmo.py

@@ -0,0 +1,95 @@
+"""
+OLMo モデル実装
+
+Allen AIによる完全オープンソースモデル
+学習データ（Dolma）とアーキテクチャが完全公開
+SwiGLU/RoPEなど最新アーキテクチャを採用
+"""
+from typing import List, Tuple
+
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+from .base import BaseLanguageModel, ModelConfig
+
+
+# OLMo 1B設定
+OLMO_1B_CONFIG = ModelConfig(
+    name="OLMo 1B",
+    model_id="allenai/OLMo-1B-hf",
+    embedding_dim=2048,
+    vocab_size=50304,
+)
+
+# OLMo 7B設定
+OLMO_7B_CONFIG = ModelConfig(
+    name="OLMo 7B",
+    model_id="allenai/OLMo-7B-hf",
+    embedding_dim=4096,
+    vocab_size=50304,
+)
+
+
+class OLMoModel(BaseLanguageModel):
+    """
+    OLMoモデルの実装
+
+    Allen AIが公開した完全オープンソースモデル。
+    学習データ（Dolma）も公開。SwiGLU/RoPE採用。
+    """
+
+    # 出力ノイズの倍率（学習バイアス破壊用）
+    LOGITS_NOISE_SCALE = 10.0
+
+    def load(self) -> None:
+        """モデルとトークナイザーをロード"""
+        if self._is_loaded:
+            return
+
+        try:
+            self._model = AutoModelForCausalLM.from_pretrained(
+                self._config.model_id,
+                trust_remote_code=True,
+            )
+            self._tokenizer = AutoTokenizer.from_pretrained(
+                self._config.model_id,
+                trust_remote_code=True,
+            )
+            self._model.eval()
+            self._is_loaded = True
+        except Exception as e:
+            raise RuntimeError(f"Failed to load model {self._config.model_id}: {e}")
+
+    def forward_with_noise(
+        self, noise: torch.Tensor
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        """
+        ノイズを入力として順伝播を実行し、出力にもノイズを加算
+
+        Args:
+            noise: 入力ノイズテンソル [batch, seq_len, embedding_dim]
+
+        Returns:
+            Tuple[logits, corrupted_logits]
+        """
+        if not self._is_loaded:
+            raise RuntimeError("Model not loaded. Call load() first.")
+
+        with torch.no_grad():
+            outputs = self._model(inputs_embeds=noise)
+            logits = outputs.logits
+
+            # 出力logitsにノイズを加算して学習バイアスを破壊
+            logits_noise = (
+                torch.randn_like(logits) * logits.std() * self.LOGITS_NOISE_SCALE
+            )
+            corrupted_logits = logits + logits_noise
+
+        return logits, corrupted_logits
+
+    def decode_indices(self, indices: List[int]) -> List[str]:
+        """トークンインデックスをデコード"""
+        if not self._is_loaded:
+            raise RuntimeError("Model not loaded. Call load() first.")
+
+        return [self._tokenizer.decode([i]) for i in indices]

src/models/pythia.py

@@ -0,0 +1,88 @@
+"""
+Pythia モデル実装
+
+EleutherAIによる完全オープンソースモデル
+学習データ（The Pile）とアーキテクチャが完全公開
+"""
+from typing import List, Tuple
+
+import torch
+from transformers import GPTNeoXForCausalLM, AutoTokenizer
+
+from .base import BaseLanguageModel, ModelConfig
+
+
+# Pythia 410M設定
+PYTHIA_410M_CONFIG = ModelConfig(
+    name="Pythia 410M",
+    model_id="EleutherAI/pythia-410m",
+    embedding_dim=1024,
+    vocab_size=50304,
+)
+
+# Pythia 1B設定
+PYTHIA_1B_CONFIG = ModelConfig(
+    name="Pythia 1B",
+    model_id="EleutherAI/pythia-1b",
+    embedding_dim=2048,
+    vocab_size=50304,
+)
+
+
+class PythiaModel(BaseLanguageModel):
+    """
+    Pythiaモデルの実装（GPT-NeoXベース）
+
+    EleutherAIが公開した完全オープンソースモデル。
+    学習データ（The Pile）も公開されている。
+    """
+
+    # 出力ノイズの倍率（学習バイアス破壊用）
+    LOGITS_NOISE_SCALE = 10.0
+
+    def load(self) -> None:
+        """モデルとトークナイザーをロード"""
+        if self._is_loaded:
+            return
+
+        try:
+            self._model = GPTNeoXForCausalLM.from_pretrained(self._config.model_id)
+            self._tokenizer = AutoTokenizer.from_pretrained(self._config.model_id)
+            self._model.eval()
+            self._is_loaded = True
+        except Exception as e:
+            raise RuntimeError(f"Failed to load model {self._config.model_id}: {e}")
+
+    def forward_with_noise(
+        self, noise: torch.Tensor
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        """
+        ノイズを入力として順伝播を実行し、出力にもノイズを加算
+
+        Args:
+            noise: 入力ノイズテンソル [batch, seq_len, embedding_dim]
+
+        Returns:
+            Tuple[logits, corrupted_logits]
+        """
+        if not self._is_loaded:
+            raise RuntimeError("Model not loaded. Call load() first.")
+
+        with torch.no_grad():
+            outputs = self._model(inputs_embeds=noise)
+            logits = outputs.logits
+
+            # 出力logitsにノイズを加算して学習バイアスを破壊
+            logits_noise = (
+                torch.randn_like(logits) * logits.std() * self.LOGITS_NOISE_SCALE
+            )
+            corrupted_logits = logits + logits_noise
+
+        return logits, corrupted_logits
+
+    def decode_indices(self, indices: List[int]) -> List[str]:
+        """トークンインデックスをデコード"""
+        if not self._is_loaded:
+            raise RuntimeError("Model not loaded. Call load() first.")
+
+        return [self._tokenizer.decode([i]) for i in indices]

src/models/qwen.py

@@ -0,0 +1,91 @@
+"""
+Qwen モデル実装
+
+Alibaba社のQwen2.5シリーズ
+Apache 2.0ライセンス、最新アーキテクチャ採用
+"""
+from typing import List, Tuple
+
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+from .base import BaseLanguageModel, ModelConfig
+
+
+# Qwen2.5 0.5B設定
+QWEN_2_5_0_5B_CONFIG = ModelConfig(
+    name="Qwen2.5 0.5B",
+    model_id="Qwen/Qwen2.5-0.5B",
+    embedding_dim=896,
+    vocab_size=151936,
+)
+
+# Qwen2.5 1.5B設定
+QWEN_2_5_1_5B_CONFIG = ModelConfig(
+    name="Qwen2.5 1.5B",
+    model_id="Qwen/Qwen2.5-1.5B",
+    embedding_dim=1536,
+    vocab_size=151936,
+)
+
+
+class QwenModel(BaseLanguageModel):
+    """
+    Qwenモデルの実装
+
+    Alibaba社のQwen2.5シリーズ。
+    Apache 2.0ライセンス、最新アーキテクチャ採用。
+    """
+
+    # 出力ノイズの倍率（学習バイアス破壊用）
+    LOGITS_NOISE_SCALE = 10.0
+
+    def load(self) -> None:
+        """モデルとトークナイザーをロード"""
+        if self._is_loaded:
+            return
+
+        try:
+            self._model = AutoModelForCausalLM.from_pretrained(
+                self._config.model_id,
+                torch_dtype="auto",
+            )
+            self._tokenizer = AutoTokenizer.from_pretrained(self._config.model_id)
+            self._model.eval()
+            self._is_loaded = True
+        except Exception as e:
+            raise RuntimeError(f"Failed to load model {self._config.model_id}: {e}")
+
+    def forward_with_noise(
+        self, noise: torch.Tensor
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        """
+        ノイズを入力として順伝播を実行し、出力にもノイズを加算
+
+        Args:
+            noise: 入力ノイズテンソル [batch, seq_len, embedding_dim]
+
+        Returns:
+            Tuple[logits, corrupted_logits]
+        """
+        if not self._is_loaded:
+            raise RuntimeError("Model not loaded. Call load() first.")
+
+        with torch.no_grad():
+            outputs = self._model(inputs_embeds=noise)
+            logits = outputs.logits
+
+            # 出力logitsにノイズを加算して学習バイアスを破壊
+            logits_noise = (
+                torch.randn_like(logits) * logits.std() * self.LOGITS_NOISE_SCALE
+            )
+            corrupted_logits = logits + logits_noise
+
+        return logits, corrupted_logits
+
+    def decode_indices(self, indices: List[int]) -> List[str]:
+        """トークンインデックスをデコード"""
+        if not self._is_loaded:
+            raise RuntimeError("Model not loaded. Call load() first.")
+
+        return [self._tokenizer.decode([i]) for i in indices]

src/models/registry.py

@@ -11,6 +11,17 @@ from .gpt2 import GPT2Model, GPT2_SMALL_CONFIG, GPT2_MEDIUM_CONFIG
 from .gpt_neo import GPTNeoModel, GPT_NEO_125M_CONFIG
 from .opt import OPTModel, OPT_125M_CONFIG
 
+# Phase 1: GPT-OSS and Fully Open Source Models
+from .gpt_oss import GPTOSSModel, GPT_OSS_20B_CONFIG
+from .pythia import PythiaModel, PYTHIA_410M_CONFIG, PYTHIA_1B_CONFIG
+from .olmo import OLMoModel, OLMO_1B_CONFIG, OLMO_7B_CONFIG
+from .bloom import BLOOMModel, BLOOM_560M_CONFIG
+
+# Phase 2: Latest Architecture Models
+from .llama import LlamaModel, LLAMA_3_2_1B_CONFIG, LLAMA_3_2_3B_CONFIG
+from .qwen import QwenModel, QWEN_2_5_0_5B_CONFIG, QWEN_2_5_1_5B_CONFIG
+from .mistral import MistralModel, MISTRAL_7B_CONFIG
+
 
 class ModelRegistry:
     """
@@ -84,5 +95,20 @@ ModelRegistry.register("gpt2-medium", GPT2Model, GPT2_MEDIUM_CONFIG)
 ModelRegistry.register("gpt-neo-125m", GPTNeoModel, GPT_NEO_125M_CONFIG)
 ModelRegistry.register("opt-125m", OPTModel, OPT_125M_CONFIG)
 
+# Phase 1: GPT-OSS and Fully Open Source Models
+ModelRegistry.register("gpt-oss-20b", GPTOSSModel, GPT_OSS_20B_CONFIG)
+ModelRegistry.register("pythia-410m", PythiaModel, PYTHIA_410M_CONFIG)
+ModelRegistry.register("pythia-1b", PythiaModel, PYTHIA_1B_CONFIG)
+ModelRegistry.register("olmo-1b", OLMoModel, OLMO_1B_CONFIG)
+ModelRegistry.register("olmo-7b", OLMoModel, OLMO_7B_CONFIG)
+ModelRegistry.register("bloom-560m", BLOOMModel, BLOOM_560M_CONFIG)
+
+# Phase 2: Latest Architecture Models
+ModelRegistry.register("llama-3.2-1b", LlamaModel, LLAMA_3_2_1B_CONFIG)
+ModelRegistry.register("llama-3.2-3b", LlamaModel, LLAMA_3_2_3B_CONFIG)
+ModelRegistry.register("qwen2.5-0.5b", QwenModel, QWEN_2_5_0_5B_CONFIG)
+ModelRegistry.register("qwen2.5-1.5b", QwenModel, QWEN_2_5_1_5B_CONFIG)
+ModelRegistry.register("mistral-7b", MistralModel, MISTRAL_7B_CONFIG)
+
 # デフォルトモデルキー
 DEFAULT_MODEL_KEY = "gpt2"

src/ui/__init__.py

@@ -1,5 +1,13 @@
-"""UI components for WILL."""
-from .styles import CUSTOM_CSS
-from .components import render_model_selector
+"""UI components for WILL.
 
-__all__ = ["CUSTOM_CSS", "render_model_selector"]
+Supports both Streamlit and Gradio interfaces.
+
+Usage:
+    # Streamlit
+    from src.ui.streamlit import CUSTOM_CSS, render_generate_page
+
+    # Gradio
+    from src.ui.gradio import create_app
+"""
+
+__all__ = ["streamlit", "gradio"]

src/ui/gradio/__init__.py

@@ -0,0 +1,4 @@
+"""Gradio UI for WILL."""
+from .app import create_app, generate_debris, get_model_choices
+
+__all__ = ["create_app", "generate_debris", "get_model_choices"]

src/ui/gradio/app.py

@@ -0,0 +1,270 @@
+"""
+WILL - Gradio UI
+
+ZeroGPU対応のGradioインターフェース
+"""
+from typing import List, Tuple, Optional
+import base64
+from io import BytesIO
+
+import gradio as gr
+
+from ...models.registry import ModelRegistry, DEFAULT_MODEL_KEY
+from ...generators.debris_generator import DebrisGenerator
+from ...visualizers.signal_visualizer import SignalVisualizer
+
+
+# モデルキャッシュ
+_model_cache = {}
+
+
+def get_model_choices() -> List[Tuple[str, str]]:
+    """
+    モデル選択肢を取得
+
+    Returns:
+        (表示名, キー) のタプルリスト
+    """
+    model_keys = ModelRegistry.list_models()
+    configs = ModelRegistry.get_all_configs()
+
+    return [(configs[key].name, key) for key in model_keys]
+
+
+def _get_model(model_key: str):
+    """モデルをキャッシュして取得"""
+    if model_key not in _model_cache:
+        model = ModelRegistry.get(model_key)
+        model.load()
+        _model_cache[model_key] = model
+    return _model_cache[model_key]
+
+
+def generate_debris(model_key: str) -> Tuple[str, str, str]:
+    """
+    デブリを生成
+
+    Args:
+        model_key: モデルキー
+
+    Returns:
+        (signal_image_base64, debris_text, seed_text)
+    """
+    # モデルとジェネレータの取得
+    model = _get_model(model_key)
+    generator = DebrisGenerator(model)
+    visualizer = SignalVisualizer()
+
+    # デブリ生成
+    result = generator.generate()
+
+    # シグナル画像を生成
+    signal_img_base64 = visualizer.generate_image(
+        result.noise, result.corrupted_logits
+    )
+
+    # Base64からPIL Imageに変換（Gradio用）
+    import PIL.Image
+    img_data = base64.b64decode(signal_img_base64)
+    img = PIL.Image.open(BytesIO(img_data))
+
+    # デブリテキスト
+    debris_text = " ".join(result.debris)
+
+    # シード情報
+    seed_text = str(result.seed)
+
+    return img, debris_text, seed_text
+
+
+def create_app() -> gr.Blocks:
+    """
+    Gradioアプリを作成
+
+    Returns:
+        gr.Blocks インスタンス
+    """
+    # カスタムCSS
+    custom_css = """
+    .title {
+        font-size: 3rem;
+        font-weight: 100;
+        letter-spacing: 0.5em;
+        text-align: center;
+        color: #333;
+        margin-bottom: 0.5rem;
+    }
+    .subtitle {
+        font-size: 0.7rem;
+        letter-spacing: 0.3em;
+        text-align: center;
+        color: #666;
+        margin-bottom: 2rem;
+    }
+    .debris-text {
+        font-family: monospace;
+        font-size: 0.9rem;
+        line-height: 1.8;
+        color: #333;
+        text-align: center;
+        padding: 1rem;
+        background: #fafafa;
+        border-radius: 4px;
+    }
+    .seed-text {
+        font-family: monospace;
+        font-size: 0.6rem;
+        color: #999;
+        text-align: center;
+        margin-top: 0.5rem;
+    }
+    .model-info {
+        font-size: 0.7rem;
+        color: #888;
+        text-align: center;
+    }
+    """
+
+    with gr.Blocks(title="WILL") as app:
+        # カスタムCSSを適用
+        gr.HTML(f"<style>{custom_css}</style>")
+
+        # タイトル
+        gr.HTML('<p class="title">WILL</p>')
+        gr.HTML('<p class="subtitle">PURE COMPUTATIONAL WILL</p>')
+
+        with gr.Tabs():
+            # GENERATE タブ
+            with gr.TabItem("GENERATE"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        pass
+                    with gr.Column(scale=2):
+                        # モデル選択
+                        model_dropdown = gr.Dropdown(
+                            choices=get_model_choices(),
+                            value=DEFAULT_MODEL_KEY,
+                            label="MODEL",
+                            interactive=True,
+                        )
+
+                        # モデル情報表示
+                        model_info = gr.HTML(elem_classes=["model-info"])
+
+                        def update_model_info(model_key):
+                            config = ModelRegistry.get_config(model_key)
+                            return f'<p class="model-info">{config.embedding_dim} dim / {config.vocab_size:,} tokens</p>'
+
+                        model_dropdown.change(
+                            fn=update_model_info,
+                            inputs=[model_dropdown],
+                            outputs=[model_info],
+                        )
+
+                    with gr.Column(scale=1):
+                        pass
+
+                # LISTENボタン
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        pass
+                    with gr.Column(scale=1):
+                        listen_btn = gr.Button("LISTEN", variant="primary")
+                    with gr.Column(scale=1):
+                        pass
+
+                # 結果表示
+                with gr.Row():
+                    signal_image = gr.Image(
+                        label="Signal",
+                        type="pil",
+                        show_label=False,
+                    )
+
+                debris_output = gr.HTML(elem_classes=["debris-text"])
+                seed_output = gr.HTML(elem_classes=["seed-text"])
+
+                def on_listen(model_key):
+                    img, debris, seed = generate_debris(model_key)
+                    debris_html = f'<div class="debris-text">{debris}</div>'
+                    seed_html = f'<p class="seed-text">{seed}</p>'
+                    return img, debris_html, seed_html
+
+                listen_btn.click(
+                    fn=on_listen,
+                    inputs=[model_dropdown],
+                    outputs=[signal_image, debris_output, seed_output],
+                )
+
+            # CONCEPT タブ
+            with gr.TabItem("CONCEPT"):
+                gr.HTML('<p class="title">CONCEPT</p>')
+                gr.HTML('<p class="subtitle">DOCUMENTATION</p>')
+
+                gr.Markdown("""
+## CONCEPT
+
+GPT-2は人間が書いたテキストで訓練され、その重みに言語パターンを保持している。
+
+通常はプロンプトに対して応答を生成するが、入力をランダムノイズに置き換え、
+出力にもノイズを加えることで、学習済みの統計的偏りを破壊する。
+
+**人間の問いかけなしに、モデルの構造だけが出力するものを観測する。**
+
+---
+
+## PROCESS
+
+### 01 — ENTROPY SEED
+```python
+seed = time.time_ns()
+torch.manual_seed(seed)
+```
+実行瞬間のナノ秒を乱数シードとして採取
+
+### 02 — INPUT NOISE
+```python
+noise = torch.randn(1, 32, embedding_dim)
+outputs = model(inputs_embeds=noise)
+```
+ランダムノイズをEmbedding層に直接注入
+
+### 03 — OUTPUT NOISE
+```python
+logits_noise = torch.randn_like(logits) * logits.std() * 10
+corrupted_logits = logits + logits_noise
+```
+出力Logitsにノイズを加算し学習バイアスを破壊
+
+### 04 — RAW DECODE
+```python
+indices = corrupted_logits.argmax(dim=-1)
+debris = [tokenizer.decode([i]) for i in indices]
+```
+Softmax・Temperature なしで生トークンを抽出
+
+---
+
+## SPECIFICATION
+
+| Item | Value |
+|------|-------|
+| Models | GPT-2 / GPT-Neo / OPT / Pythia / OLMo / BLOOM / Llama / Qwen / Mistral / GPT-OSS |
+| Parameters | 125M - 21B |
+| Sequence | 32 tokens |
+| Input Noise | N(0, 1) |
+| Logits Noise | N(0, σ×10) |
+| Decoding | argmax |
+                """)
+
+    return app
+
+
+# ZeroGPU対応（Hugging Face Spaces用）
+try:
+    import spaces
+    # ZeroGPU環境の場合、generate_debrisをGPU対応にする
+    generate_debris = spaces.GPU(generate_debris)
+except ImportError:
+    # ローカル環境では通常実行
+    pass

src/ui/streamlit/__init__.py

@@ -0,0 +1,5 @@
+"""Streamlit UI for WILL."""
+from .styles import CUSTOM_CSS
+from .pages import render_generate_page, render_concept_page
+
+__all__ = ["CUSTOM_CSS", "render_generate_page", "render_concept_page"]

src/ui/{components.py → streamlit/components.py}

@@ -7,7 +7,7 @@ from typing import Optional
 
 import streamlit as st
 
-from ..models.registry import ModelRegistry, DEFAULT_MODEL_KEY
+from ...models.registry import ModelRegistry, DEFAULT_MODEL_KEY
 
 
 def render_model_selector() -> str:

src/ui/{pages → streamlit/pages}/concept.py

@@ -5,7 +5,7 @@ WILLプロジェクトの概念説明を提供する
 """
 import streamlit as st
 
-from ...models.registry import ModelRegistry
+from ....models.registry import ModelRegistry
 
 
 def render_concept_page() -> None:

src/ui/{pages → streamlit/pages}/generate.py

@@ -5,9 +5,9 @@
 """
 import streamlit as st
 
-from ...models.registry import ModelRegistry
-from ...generators.debris_generator import DebrisGenerator
-from ...visualizers.signal_visualizer import SignalVisualizer
+from ....models.registry import ModelRegistry
+from ....generators.debris_generator import DebrisGenerator
+from ....visualizers.signal_visualizer import SignalVisualizer
 from ..components import render_model_selector
 
 

tests/test_models.py

@@ -8,6 +8,17 @@ from src.models.base import ModelConfig, BaseLanguageModel
 from src.models.registry import ModelRegistry, DEFAULT_MODEL_KEY
 from src.models.gpt2 import GPT2Model, GPT2_SMALL_CONFIG
 
+# Phase 1: GPT-OSS and Fully Open Source Models
+from src.models.gpt_oss import GPTOSSModel, GPT_OSS_20B_CONFIG
+from src.models.pythia import PythiaModel, PYTHIA_410M_CONFIG, PYTHIA_1B_CONFIG
+from src.models.olmo import OLMoModel, OLMO_1B_CONFIG, OLMO_7B_CONFIG
+from src.models.bloom import BLOOMModel, BLOOM_560M_CONFIG
+
+# Phase 2: Latest Architecture Models
+from src.models.llama import LlamaModel, LLAMA_3_2_1B_CONFIG, LLAMA_3_2_3B_CONFIG
+from src.models.qwen import QwenModel, QWEN_2_5_0_5B_CONFIG, QWEN_2_5_1_5B_CONFIG
+from src.models.mistral import MistralModel, MISTRAL_7B_CONFIG
+
 
 class TestModelConfig:
     """ModelConfigのテスト"""
@@ -122,3 +133,329 @@ class TestGPT2ModelIntegration:
 
         assert len(decoded) == 3
         assert all(isinstance(s, str) for s in decoded)
+
+
+# =============================================================================
+# Phase 1: GPT-OSS and Fully Open Source Models
+# =============================================================================
+
+
+class TestGPTOSSModel:
+    """GPTOSSModelのテスト"""
+
+    def test_config(self):
+        """設定が正しいことを確認"""
+        model = GPTOSSModel(GPT_OSS_20B_CONFIG)
+        assert model.config == GPT_OSS_20B_CONFIG
+        assert model.config.embedding_dim == 4096
+        assert model.config.vocab_size == 128000
+
+    def test_is_loaded_initial(self):
+        """初期状態ではロードされていないことを確認"""
+        model = GPTOSSModel(GPT_OSS_20B_CONFIG)
+        assert not model.is_loaded
+
+    def test_generate_noise(self):
+        """ノイズ生成が正しい形状であることを確認"""
+        model = GPTOSSModel(GPT_OSS_20B_CONFIG)
+        noise = model.generate_noise(seq_len=16, batch_size=2)
+        assert noise.shape == (2, 16, 4096)
+
+
+class TestPythiaModel:
+    """PythiaModelのテスト"""
+
+    def test_config_410m(self):
+        """Pythia 410M設定が正しいことを確認"""
+        model = PythiaModel(PYTHIA_410M_CONFIG)
+        assert model.config == PYTHIA_410M_CONFIG
+        assert model.config.embedding_dim == 1024
+        assert model.config.vocab_size == 50304
+
+    def test_config_1b(self):
+        """Pythia 1B設定が正しいことを確認"""
+        model = PythiaModel(PYTHIA_1B_CONFIG)
+        assert model.config == PYTHIA_1B_CONFIG
+        assert model.config.embedding_dim == 2048
+        assert model.config.vocab_size == 50304
+
+    def test_is_loaded_initial(self):
+        """初期状態ではロードされていないことを確認"""
+        model = PythiaModel(PYTHIA_410M_CONFIG)
+        assert not model.is_loaded
+
+    def test_generate_noise(self):
+        """ノイズ生成が正しい形状であることを確認"""
+        model = PythiaModel(PYTHIA_410M_CONFIG)
+        noise = model.generate_noise(seq_len=16, batch_size=2)
+        assert noise.shape == (2, 16, 1024)
+
+
+class TestOLMoModel:
+    """OLMoModelのテスト"""
+
+    def test_config_1b(self):
+        """OLMo 1B設定が正しいことを確認"""
+        model = OLMoModel(OLMO_1B_CONFIG)
+        assert model.config == OLMO_1B_CONFIG
+        assert model.config.embedding_dim == 2048
+        assert model.config.vocab_size == 50304
+
+    def test_config_7b(self):
+        """OLMo 7B設定が正しいことを確認"""
+        model = OLMoModel(OLMO_7B_CONFIG)
+        assert model.config == OLMO_7B_CONFIG
+        assert model.config.embedding_dim == 4096
+        assert model.config.vocab_size == 50304
+
+    def test_is_loaded_initial(self):
+        """初期状態ではロードされていないことを確認"""
+        model = OLMoModel(OLMO_1B_CONFIG)
+        assert not model.is_loaded
+
+    def test_generate_noise(self):
+        """ノイズ生成が正しい形状であることを確認"""
+        model = OLMoModel(OLMO_1B_CONFIG)
+        noise = model.generate_noise(seq_len=16, batch_size=2)
+        assert noise.shape == (2, 16, 2048)
+
+
+class TestBLOOMModel:
+    """BLOOMModelのテスト"""
+
+    def test_config(self):
+        """BLOOM 560M設定が正しいことを確認"""
+        model = BLOOMModel(BLOOM_560M_CONFIG)
+        assert model.config == BLOOM_560M_CONFIG
+        assert model.config.embedding_dim == 1024
+        assert model.config.vocab_size == 250880
+
+    def test_is_loaded_initial(self):
+        """初期状態ではロードされていないことを確認"""
+        model = BLOOMModel(BLOOM_560M_CONFIG)
+        assert not model.is_loaded
+
+    def test_generate_noise(self):
+        """ノイズ生成が正しい形状であることを確認"""
+        model = BLOOMModel(BLOOM_560M_CONFIG)
+        noise = model.generate_noise(seq_len=16, batch_size=2)
+        assert noise.shape == (2, 16, 1024)
+
+
+# =============================================================================
+# Phase 2: Latest Architecture Models
+# =============================================================================
+
+
+class TestLlamaModel:
+    """LlamaModelのテスト"""
+
+    def test_config_1b(self):
+        """Llama 3.2 1B設定が正しいことを確認"""
+        model = LlamaModel(LLAMA_3_2_1B_CONFIG)
+        assert model.config == LLAMA_3_2_1B_CONFIG
+        assert model.config.embedding_dim == 2048
+        assert model.config.vocab_size == 128256
+
+    def test_config_3b(self):
+        """Llama 3.2 3B設定が正しいことを確認"""
+        model = LlamaModel(LLAMA_3_2_3B_CONFIG)
+        assert model.config == LLAMA_3_2_3B_CONFIG
+        assert model.config.embedding_dim == 3072
+        assert model.config.vocab_size == 128256
+
+    def test_is_loaded_initial(self):
+        """初期状態ではロードされていないことを確認"""
+        model = LlamaModel(LLAMA_3_2_1B_CONFIG)
+        assert not model.is_loaded
+
+    def test_generate_noise(self):
+        """ノイズ生成が正しい形状であることを確認"""
+        model = LlamaModel(LLAMA_3_2_1B_CONFIG)
+        noise = model.generate_noise(seq_len=16, batch_size=2)
+        assert noise.shape == (2, 16, 2048)
+
+
+class TestQwenModel:
+    """QwenModelのテスト"""
+
+    def test_config_0_5b(self):
+        """Qwen2.5 0.5B設定が正しいことを確認"""
+        model = QwenModel(QWEN_2_5_0_5B_CONFIG)
+        assert model.config == QWEN_2_5_0_5B_CONFIG
+        assert model.config.embedding_dim == 896
+        assert model.config.vocab_size == 151936
+
+    def test_config_1_5b(self):
+        """Qwen2.5 1.5B設定が正しいことを確認"""
+        model = QwenModel(QWEN_2_5_1_5B_CONFIG)
+        assert model.config == QWEN_2_5_1_5B_CONFIG
+        assert model.config.embedding_dim == 1536
+        assert model.config.vocab_size == 151936
+
+    def test_is_loaded_initial(self):
+        """初期状態ではロードされていないことを確認"""
+        model = QwenModel(QWEN_2_5_0_5B_CONFIG)
+        assert not model.is_loaded
+
+    def test_generate_noise(self):
+        """ノイズ生成が正しい形状であることを確認"""
+        model = QwenModel(QWEN_2_5_0_5B_CONFIG)
+        noise = model.generate_noise(seq_len=16, batch_size=2)
+        assert noise.shape == (2, 16, 896)
+
+
+class TestMistralModel:
+    """MistralModelのテスト"""
+
+    def test_config(self):
+        """Mistral 7B設定が正しいことを確認"""
+        model = MistralModel(MISTRAL_7B_CONFIG)
+        assert model.config == MISTRAL_7B_CONFIG
+        assert model.config.embedding_dim == 4096
+        assert model.config.vocab_size == 32768
+
+    def test_is_loaded_initial(self):
+        """初期状態ではロードされていないことを確認"""
+        model = MistralModel(MISTRAL_7B_CONFIG)
+        assert not model.is_loaded
+
+    def test_generate_noise(self):
+        """ノイズ生成が正しい形状であることを確認"""
+        model = MistralModel(MISTRAL_7B_CONFIG)
+        noise = model.generate_noise(seq_len=16, batch_size=2)
+        assert noise.shape == (2, 16, 4096)
+
+
+# =============================================================================
+# Registry Tests for New Models
+# =============================================================================
+
+
+class TestModelRegistryNewModels:
+    """新規追加モデルのレジストリテスト"""
+
+    @pytest.mark.parametrize("model_key", [
+        "gpt-oss-20b",
+        "pythia-410m",
+        "pythia-1b",
+        "olmo-1b",
+        "olmo-7b",
+        "bloom-560m",
+        "llama-3.2-1b",
+        "llama-3.2-3b",
+        "qwen2.5-0.5b",
+        "qwen2.5-1.5b",
+        "mistral-7b",
+    ])
+    def test_model_registered(self, model_key):
+        """新モデルがレジストリに登録されていることを確認"""
+        models = ModelRegistry.list_models()
+        assert model_key in models
+
+    @pytest.mark.parametrize("model_key", [
+        "gpt-oss-20b",
+        "pythia-410m",
+        "pythia-1b",
+        "olmo-1b",
+        "olmo-7b",
+        "bloom-560m",
+        "llama-3.2-1b",
+        "llama-3.2-3b",
+        "qwen2.5-0.5b",
+        "qwen2.5-1.5b",
+        "mistral-7b",
+    ])
+    def test_model_instance_creation(self, model_key):
+        """新モデルのインスタンスが作成できることを確認"""
+        model = ModelRegistry.get(model_key)
+        assert isinstance(model, BaseLanguageModel)
+        assert not model.is_loaded
+
+
+# =============================================================================
+# Integration Tests (require model download)
+# =============================================================================
+
+
+@pytest.mark.slow
+class TestPythiaModelIntegration:
+    """Pythiaモデルの統合テスト（小さいモデルで代表テスト）"""
+
+    @pytest.fixture
+    def loaded_model(self):
+        """ロード済みモデルを提供"""
+        model = PythiaModel(PYTHIA_410M_CONFIG)
+        model.load()
+        return model
+
+    def test_load(self, loaded_model):
+        """モデルがロードできることを確認"""
+        assert loaded_model.is_loaded
+
+    def test_forward_with_noise(self, loaded_model):
+        """順伝播が正しい形状を返すことを確認"""
+        noise = loaded_model.generate_noise(seq_len=8)
+        logits, corrupted_logits = loaded_model.forward_with_noise(noise)
+
+        assert logits.shape[0] == 1
+        assert logits.shape[1] == 8
+        assert logits.shape[2] == loaded_model.config.vocab_size
+
+    def test_decode_indices(self, loaded_model):
+        """デコードが文字列リストを返すことを確認"""
+        indices = [100, 200, 300]
+        decoded = loaded_model.decode_indices(indices)
+
+        assert len(decoded) == 3
+        assert all(isinstance(s, str) for s in decoded)
+
+
+@pytest.mark.slow
+class TestBLOOMModelIntegration:
+    """BLOOMモデルの統合テスト"""
+
+    @pytest.fixture
+    def loaded_model(self):
+        """ロード済みモデルを提供"""
+        model = BLOOMModel(BLOOM_560M_CONFIG)
+        model.load()
+        return model
+
+    def test_load(self, loaded_model):
+        """モデルがロードできることを確認"""
+        assert loaded_model.is_loaded
+
+    def test_forward_with_noise(self, loaded_model):
+        """順伝播が正しい形状を返すことを確認"""
+        noise = loaded_model.generate_noise(seq_len=8)
+        logits, corrupted_logits = loaded_model.forward_with_noise(noise)
+
+        assert logits.shape[0] == 1
+        assert logits.shape[1] == 8
+        assert logits.shape[2] == loaded_model.config.vocab_size
+
+
+@pytest.mark.slow
+class TestQwenModelIntegration:
+    """Qwenモデルの統合テスト（小さいモデルで代表テスト）"""
+
+    @pytest.fixture
+    def loaded_model(self):
+        """ロード済みモデルを提供"""
+        model = QwenModel(QWEN_2_5_0_5B_CONFIG)
+        model.load()
+        return model
+
+    def test_load(self, loaded_model):
+        """モデルがロードできることを確認"""
+        assert loaded_model.is_loaded
+
+    def test_forward_with_noise(self, loaded_model):
+        """順伝播が正しい形状を返すことを確認"""
+        noise = loaded_model.generate_noise(seq_len=8)
+        logits, corrupted_logits = loaded_model.forward_with_noise(noise)
+
+        assert logits.shape[0] == 1
+        assert logits.shape[1] == 8
+        assert logits.shape[2] == loaded_model.config.vocab_size

tests/test_ui_gradio.py

@@ -0,0 +1,62 @@
+"""
+Gradio UI関連のテスト
+"""
+import pytest
+
+
+class TestGradioApp:
+    """Gradio UIのテスト"""
+
+    def test_import_gradio_app(self):
+        """Gradioアプリがインポートできることを確認"""
+        from src.ui.gradio.app import create_app
+        assert create_app is not None
+
+    def test_create_app_returns_blocks(self):
+        """create_appがGradio Blocksを返すことを確認"""
+        import gradio as gr
+        from src.ui.gradio.app import create_app
+
+        app = create_app()
+        assert isinstance(app, gr.Blocks)
+
+    def test_generate_debris_function_exists(self):
+        """generate_debris関数が存在することを確認"""
+        from src.ui.gradio.app import generate_debris
+        assert callable(generate_debris)
+
+    def test_generate_debris_returns_tuple(self):
+        """generate_debris関数がタプルを返すことを確認"""
+        from src.ui.gradio.app import generate_debris
+
+        # GPT-2 Small（最小モデル）でテスト
+        result = generate_debris("gpt2")
+
+        # (image, debris_text, seed_text) の3要素タプル
+        assert isinstance(result, tuple)
+        assert len(result) == 3
+
+
+class TestGradioAppModelSelection:
+    """モデル選択のテスト"""
+
+    def test_get_model_choices(self):
+        """モデル選択肢が取得できることを確認"""
+        from src.ui.gradio.app import get_model_choices
+
+        choices = get_model_choices()
+        assert len(choices) > 0
+        # (表示名, キー) のタプルリスト
+        assert all(isinstance(c, tuple) and len(c) == 2 for c in choices)
+
+    def test_model_choices_include_new_models(self):
+        """新モデルが選択肢に含まれることを確認"""
+        from src.ui.gradio.app import get_model_choices
+
+        choices = get_model_choices()
+        keys = [c[1] for c in choices]
+
+        # 新モデルが含まれることを確認
+        assert "gpt-oss-20b" in keys
+        assert "pythia-410m" in keys
+        assert "qwen2.5-0.5b" in keys