リファクタ: srcディレクトリ構造への移行とDocker対応

- app.pyをモジュール構造に分割（src/models, src/generators, src/visualizers, src/ui）
- Dockerfileをrequirements.txt使用に変更、src/ディレクトリをCOPY
- docker-compose.ymlにsrc/ボリュームマウント追加
- pytestを依存関係に追加
- テストファイル追加（TDD対応）

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

Dockerfile

@@ -2,16 +2,18 @@ FROM python:3.11-slim
 
 WORKDIR /app
 
-RUN pip install --no-cache-dir \
-    torch \
-    transformers \
-    streamlit \
-    matplotlib \
-    numpy
+# 依存関係のインストール
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
 
-RUN python -c "from transformers import GPT2LMHeadModel, GPT2Tokenizer; GPT2LMHeadModel.from_pretrained('gpt2'); GPT2Tokenizer.from_pretrained('gpt2')"
+# モデルの事前ダウンロード（ビルド時にキャッシュ）
+RUN python -c "from transformers import GPT2LMHeadModel, GPT2Tokenizer; \
+    GPT2LMHeadModel.from_pretrained('gpt2'); \
+    GPT2Tokenizer.from_pretrained('gpt2')"
 
+# アプリケーションコードをコピー
 COPY app.py .
+COPY src/ ./src/
 
 EXPOSE 8501
 

app.py

@@ -1,327 +1,33 @@
-#!/Users/yukimatsumori/.pyenv/versions/3.12.2/bin/python3
-import time
-import torch
-from transformers import GPT2LMHeadModel, GPT2Tokenizer
-import streamlit as st
-import matplotlib.pyplot as plt
-import numpy as np
-import io
-import base64
-
-st.set_page_config(page_title="will", page_icon="", layout="centered")
-
-st.markdown("""
-<style>
-@import url('https://fonts.googleapis.com/css2?family=IBM+Plex+Mono:wght@300;400&display=swap');
-
-@keyframes emerge {
-    from { opacity: 0; transform: translateY(8px); }
-    to { opacity: 1; transform: translateY(0); }
-}
-@keyframes breathe {
-    0%, 100% { opacity: 0.4; }
-    50% { opacity: 0.7; }
-}
-
-html, body, [class*="css"] {
-    font-family: 'IBM Plex Mono', monospace;
-}
-.stApp {
-    background-color: #0a0a0a;
-    color: #e0e0e0;
-}
-.block-container {
-    padding-top: 4rem;
-    padding-bottom: 4rem;
-    max-width: 640px;
-}
-h1, h2, h3 {
-    font-weight: 300;
-    letter-spacing: 0.1em;
-    text-align: center;
-    color: #e0e0e0;
-}
-p, li {
-    font-weight: 300;
-    line-height: 1.8;
-    color: #888;
-}
-.title {
-    font-size: 2rem;
-    font-weight: 300;
-    letter-spacing: 0.3em;
-    text-align: center;
-    margin-bottom: 0.5rem;
-    color: #e0e0e0;
-}
-.subtitle {
-    font-size: 0.75rem;
-    letter-spacing: 0.2em;
-    text-align: center;
-    color: #555;
-    margin-bottom: 3rem;
-}
-.debris-container {
-    background: linear-gradient(135deg, #0f0f0f 0%, #141414 100%);
-    border: 1px solid #222;
-    border-radius: 2px;
-    padding: 2rem;
-    margin: 2rem auto;
-    max-width: 100%;
-    text-align: center;
-    animation: emerge 0.6s ease-out;
-}
-.signal-img {
-    width: 100%;
-    max-width: 480px;
-    margin: 0 auto 1.5rem auto;
-    display: block;
-    opacity: 0.7;
-}
-.debris {
-    font-family: 'IBM Plex Mono', monospace;
-    font-size: 0.85rem;
-    font-weight: 400;
-    color: #e0e0e0;
-    line-height: 2;
-    word-spacing: 0.3em;
-    letter-spacing: 0.01em;
-}
-.seed {
-    font-size: 0.6rem;
-    color: #333;
-    text-align: center;
-    margin-top: 1.5rem;
-    letter-spacing: 0.15em;
-    animation: emerge 0.8s ease-out;
-}
-[data-testid="stButton"] > button {
-    background: transparent !important;
-    border: 1px solid #333 !important;
-    border-radius: 2px !important;
-    color: #888 !important;
-    font-family: 'IBM Plex Mono', monospace !important;
-    font-size: 0.7rem !important;
-    font-weight: 300 !important;
-    letter-spacing: 0.25em !important;
-    padding: 1rem 2rem !important;
-    transition: all 0.4s ease !important;
-    cursor: pointer !important;
-}
-[data-testid="stButton"] > button:hover {
-    background: transparent !important;
-    color: #e0e0e0 !important;
-    border-color: #555 !important;
-}
-[data-testid="stButton"] > button:active {
-    transform: scale(0.98) !important;
-}
-.stTabs [data-baseweb="tab-list"] {
-    justify-content: center;
-    gap: 2rem;
-    border-bottom: 1px solid #1a1a1a;
-    background: transparent;
-}
-.stTabs [data-baseweb="tab"] {
-    font-family: 'IBM Plex Mono', monospace;
-    font-size: 0.65rem;
-    font-weight: 300;
-    letter-spacing: 0.2em;
-    color: #444;
-    padding: 1rem 0;
-    background: transparent;
-    transition: color 0.3s ease;
-}
-.stTabs [aria-selected="true"] {
-    color: #888;
-    background: transparent;
-}
-.stTabs [data-baseweb="tab-highlight"] {
-    background-color: #444;
-}
-.divider {
-    border: none;
-    border-top: 1px solid #1a1a1a;
-    margin: 3rem 0;
-}
-.section {
-    margin: 2.5rem 0;
-}
-.section-title {
-    font-size: 0.65rem;
-    letter-spacing: 0.25em;
-    color: #444;
-    text-align: center;
-    margin-bottom: 1.5rem;
-}
-.spec-table {
-    width: 100%;
-    max-width: 320px;
-    margin: 0 auto;
-    font-size: 0.7rem;
-    border-collapse: collapse;
-    color: #777;
-}
-.spec-table td {
-    padding: 0.75rem 1rem;
-    border-bottom: 1px solid #151515;
-}
-.spec-table td:first-child {
-    color: #444;
-    text-align: right;
-    padding-right: 2rem;
-}
-.spec-table td:last-child {
-    text-align: left;
-}
-pre {
-    background-color: #0f0f0f !important;
-    border: 1px solid #1a1a1a !important;
-    border-radius: 2px !important;
-}
-code {
-    color: #666 !important;
-    font-size: 0.7rem !important;
-}
-</style>
-""", unsafe_allow_html=True)
-
-tab1, tab2 = st.tabs(["GENERATE", "CONCEPT"])
-
-with tab1:
-    st.markdown('<p class="title">WILL</p>', unsafe_allow_html=True)
-    st.markdown('<p class="subtitle">PURE COMPUTATIONAL WILL</p>', unsafe_allow_html=True)
-
-    @st.cache_resource(show_spinner=False)
-    def load_model():
-        model = GPT2LMHeadModel.from_pretrained("gpt2")
-        tokenizer = GPT2Tokenizer.from_pretrained("gpt2")
-        model.eval()
-        return model, tokenizer
-
-    model, tokenizer = load_model()
-
-    if "debris" not in st.session_state:
-        st.session_state.debris = None
-        st.session_state.seed = None
-        st.session_state.signal_img = None
+"""
+WILL - Pure Computational Will
 
-    def generate_signal_image(noise, logits):
-        fig, axes = plt.subplots(2, 1, figsize=(6, 2), facecolor='#0f0f0f')
-        plt.subplots_adjust(hspace=0.15, left=0.02, right=0.98, top=0.95, bottom=0.05)
-
-        noise_flat = noise[0, :, :64].numpy()
-        axes[0].imshow(noise_flat.T, aspect='auto', cmap='gray', interpolation='bilinear', vmin=-2, vmax=2)
-        axes[0].set_xticks([])
-        axes[0].set_yticks([])
-        axes[0].set_facecolor('#0f0f0f')
-        for spine in axes[0].spines.values():
-            spine.set_visible(False)
-
-        logits_sample = logits[0, :, ::200].numpy()
-        axes[1].imshow(logits_sample.T, aspect='auto', cmap='gray', interpolation='bilinear')
-        axes[1].set_xticks([])
-        axes[1].set_yticks([])
-        axes[1].set_facecolor('#0f0f0f')
-        for spine in axes[1].spines.values():
-            spine.set_visible(False)
-
-        buf = io.BytesIO()
-        plt.savefig(buf, format='png', facecolor='#0f0f0f', edgecolor='none', dpi=150, bbox_inches='tight', pad_inches=0.05)
-        plt.close(fig)
-        buf.seek(0)
-        return base64.b64encode(buf.read()).decode()
-
-    col1, col2, col3 = st.columns([1, 1, 1])
-    with col2:
-        clicked = st.button("LISTEN", key="listen_btn", use_container_width=True)
-    if clicked:
-            seed = time.time_ns()
-            torch.manual_seed(seed)
-            noise = torch.randn(1, 32, 768)
-
-            with torch.no_grad():
-                outputs = model(inputs_embeds=noise)
-                logits = outputs.logits
-                logits_noise = torch.randn_like(logits) * logits.std() * 10
-                corrupted_logits = logits + logits_noise
-
-            indices = corrupted_logits.argmax(dim=-1).squeeze().tolist()
-            st.session_state.debris = [tokenizer.decode([i]) for i in indices]
-            st.session_state.seed = seed
-            st.session_state.signal_img = generate_signal_image(noise, corrupted_logits)
-
-    if st.session_state.debris:
-        st.markdown(f'''
-        <div class="debris-container">
-            <img class="signal-img" src="data:image/png;base64,{st.session_state.signal_img}">
-            <div class="debris">{" ".join(st.session_state.debris)}</div>
-        </div>
-        <p class="seed">{st.session_state.seed}</p>
-        ''', unsafe_allow_html=True)
-
-with tab2:
-    st.markdown('<p class="title">CONCEPT</p>', unsafe_allow_html=True)
-    st.markdown('<p class="subtitle">DOCUMENTATION</p>', unsafe_allow_html=True)
-
-    st.markdown('''
-    <div class="section">
-        <p class="section-title">CONCEPT</p>
-        <p style="text-align: center; color: #666; line-height: 2.2;">
-            GPT-2は人間が書いたテキストで訓練され<br>
-            その重みに言語パターンを保持している<br><br>
-            通常はプロンプトに対して応答を生成するが<br>
-            入力をランダムノイズに置き換え<br>
-            出力にもノイズを加えることで<br>
-            学習済みの統計的偏りを破壊する<br><br>
-            人間の問いかけなしに<br>
-            モデルの構造だけが出力するものを観測する
-        </p>
-    </div>
-    <hr class="divider">
-    ''', unsafe_allow_html=True)
+言語モデルにランダムノイズを入力し、
+人間の問いかけなしにモデルの構造だけが
+出力するものを観測する
+"""
+import streamlit as st
 
-    st.markdown('''
-    <div class="section">
-        <p class="section-title">PROCESS</p>
-    </div>
-    ''', unsafe_allow_html=True)
+from src.ui.styles import CUSTOM_CSS
+from src.ui.pages import render_generate_page, render_concept_page
 
-    st.markdown('<p style="text-align: center; color: #333; font-size: 0.65rem; letter-spacing: 0.15em; margin-bottom: 0.5rem;">01 — ENTROPY SEED</p>', unsafe_allow_html=True)
-    st.code("seed = time.time_ns()\ntorch.manual_seed(seed)", language="python")
-    st.markdown('<p style="text-align: center; font-size: 0.7rem; color: #444;">実行瞬間のナノ秒を乱数シードとして採取</p>', unsafe_allow_html=True)
 
-    st.markdown("<br>", unsafe_allow_html=True)
+def main():
+    """アプリケーションのエントリーポイント"""
+    # ページ設定
+    st.set_page_config(page_title="will", page_icon="", layout="centered")
 
-    st.markdown('<p style="text-align: center; color: #333; font-size: 0.65rem; letter-spacing: 0.15em; margin-bottom: 0.5rem;">02 — INPUT NOISE</p>', unsafe_allow_html=True)
-    st.code("noise = torch.randn(1, 32, 768)\noutputs = model(inputs_embeds=noise)", language="python")
-    st.markdown('<p style="text-align: center; font-size: 0.7rem; color: #444;">768次元ランダムノイズをEmbedding層に直接注入</p>', unsafe_allow_html=True)
+    # カスタムCSS適用
+    st.markdown(CUSTOM_CSS, unsafe_allow_html=True)
 
-    st.markdown("<br>", unsafe_allow_html=True)
+    # タブ構成
+    tab1, tab2 = st.tabs(["GENERATE", "CONCEPT"])
 
-    st.markdown('<p style="text-align: center; color: #333; font-size: 0.65rem; letter-spacing: 0.15em; margin-bottom: 0.5rem;">03 — OUTPUT NOISE</p>', unsafe_allow_html=True)
-    st.code("logits_noise = torch.randn_like(logits) * logits.std() * 10\ncorrupted_logits = logits + logits_noise", language="python")
-    st.markdown('<p style="text-align: center; font-size: 0.7rem; color: #444;">出力Logitsにノイズを加算し学習バイアスを破壊</p>', unsafe_allow_html=True)
+    with tab1:
+        render_generate_page()
 
-    st.markdown("<br>", unsafe_allow_html=True)
+    with tab2:
+        render_concept_page()
 
-    st.markdown('<p style="text-align: center; color: #333; font-size: 0.65rem; letter-spacing: 0.15em; margin-bottom: 0.5rem;">04 — RAW DECODE</p>', unsafe_allow_html=True)
-    st.code("indices = corrupted_logits.argmax(dim=-1)\ndebris = [tokenizer.decode([i]) for i in indices]", language="python")
-    st.markdown('<p style="text-align: center; font-size: 0.7rem; color: #444;">Softmax・Temperature なしで生トークンを抽出</p>', unsafe_allow_html=True)
 
-    st.markdown('''
-    <hr class="divider">
-    <div class="section">
-        <p class="section-title">SPECIFICATION</p>
-        <table class="spec-table">
-            <tr><td>Model</td><td>GPT-2 Small</td></tr>
-            <tr><td>Parameters</td><td>124M</td></tr>
-            <tr><td>Embedding</td><td>768 dim</td></tr>
-            <tr><td>Vocabulary</td><td>50,257 tokens</td></tr>
-            <tr><td>Sequence</td><td>32 tokens</td></tr>
-            <tr><td>Input Noise</td><td>N(0, 1)</td></tr>
-            <tr><td>Logits Noise</td><td>N(0, σ×10)</td></tr>
-            <tr><td>Decoding</td><td>argmax</td></tr>
-        </table>
-    </div>
-    ''', unsafe_allow_html=True)
+if __name__ == "__main__":
+    main()

docker-compose.yml

@@ -5,3 +5,4 @@ services:
       - "8501:8501"
     volumes:
       - ./app.py:/app/app.py
+      - ./src:/app/src

requirements.txt

@@ -3,3 +3,4 @@ transformers
 streamlit
 matplotlib
 numpy
+pytest

src/__init__.py

@@ -0,0 +1 @@
+"""WILL - Pure Computational Will"""

src/generators/__init__.py

@@ -0,0 +1,4 @@
+"""Debris generation logic for WILL."""
+from .debris_generator import DebrisGenerator, DebrisResult
+
+__all__ = ["DebrisGenerator", "DebrisResult"]

src/generators/debris_generator.py

@@ -0,0 +1,104 @@
+"""
+デブリ生成器
+
+言語モデルにノイズを入力してデブリ（言語断片）を生成する
+単一責任原則(SRP)に従い、生成ロジックのみを担当
+"""
+import time
+from dataclasses import dataclass
+from typing import List, Optional
+
+import torch
+
+from ..models.base import BaseLanguageModel
+
+
+@dataclass
+class DebrisResult:
+    """
+    デブリ生成結果を保持するイミュータブルなデータクラス
+
+    Attributes:
+        debris: 生成されたトークン文字列のリスト
+        seed: 使用した乱数シード
+        noise: 入力ノイズテンソル
+        logits: 生のlogitsテンソル
+        corrupted_logits: ノイズ加算後のlogitsテンソル
+    """
+    debris: List[str]
+    seed: int
+    noise: torch.Tensor
+    logits: torch.Tensor
+    corrupted_logits: torch.Tensor
+
+
+class DebrisGenerator:
+    """
+    デブリ生成器
+
+    言語モデルを使用してランダムノイズから
+    言語断片（デブリ）を生成する
+
+    依存性逆転原則(DIP)に従い、具象クラスではなく
+    BaseLanguageModel抽象クラスに依存する
+    """
+
+    # デフォルトのシーケンス長
+    DEFAULT_SEQ_LEN = 32
+
+    def __init__(self, model: BaseLanguageModel):
+        """
+        Args:
+            model: 使用する言語モデル（BaseLanguageModelを実装）
+        """
+        self._model = model
+
+    @property
+    def model(self) -> BaseLanguageModel:
+        """使用中のモデルを取得"""
+        return self._model
+
+    def generate(
+        self,
+        seed: Optional[int] = None,
+        seq_len: int = DEFAULT_SEQ_LEN,
+    ) -> DebrisResult:
+        """
+        デブリを生成
+
+        Args:
+            seed: 乱数シード（Noneの場合はナノ秒タイムスタンプを使用）
+            seq_len: 生成するシーケンス長
+
+        Returns:
+            DebrisResult: 生成結果
+
+        Raises:
+            RuntimeError: モデルが未ロードの場合
+        """
+        # シードの設定
+        if seed is None:
+            seed = time.time_ns()
+        torch.manual_seed(seed)
+
+        # モデルがロードされていなければロード
+        if not self._model.is_loaded:
+            self._model.load()
+
+        # ノイズ生成と順伝播
+        noise = self._model.generate_noise(seq_len=seq_len)
+        logits, corrupted_logits = self._model.forward_with_noise(noise)
+
+        # argmaxでインデックス抽出
+        indices = corrupted_logits.argmax(dim=-1).squeeze().tolist()
+
+        # インデックスをトークン文字列にデコード
+        debris = self._model.decode_indices(indices)
+
+        return DebrisResult(
+            debris=debris,
+            seed=seed,
+            noise=noise,
+            logits=logits,
+            corrupted_logits=corrupted_logits,
+        )

src/models/__init__.py

@@ -0,0 +1,5 @@
+"""Model implementations for WILL."""
+from .base import BaseLanguageModel, ModelConfig
+from .registry import ModelRegistry
+
+__all__ = ["BaseLanguageModel", "ModelConfig", "ModelRegistry"]

src/models/base.py

@@ -0,0 +1,110 @@
+"""
+抽象基底クラス - すべての言語モデルの共通インターフェース
+
+リスコフ置換原則(LSP)に準拠し、どのモデル実装も
+同じインターフェースで置換可能にする
+"""
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import List, Tuple
+
+import torch
+
+
+@dataclass(frozen=True)
+class ModelConfig:
+    """
+    モデル設定を保持するイミュータブルなデータクラス
+
+    Attributes:
+        name: UI表示名
+        model_id: HuggingFace model ID
+        embedding_dim: embedding次元数
+        vocab_size: 語彙サイズ
+    """
+    name: str
+    model_id: str
+    embedding_dim: int
+    vocab_size: int
+
+
+class BaseLanguageModel(ABC):
+    """
+    言語モデルの抽象基底クラス
+
+    すべてのモデル実装はこのクラスを継承し、
+    定義されたインターフェースを実装する必要がある
+    """
+
+    def __init__(self, config: ModelConfig):
+        """
+        Args:
+            config: モデル設定
+        """
+        self._config = config
+        self._model = None
+        self._tokenizer = None
+        self._is_loaded = False
+
+    @property
+    def config(self) -> ModelConfig:
+        """モデル設定を取得"""
+        return self._config
+
+    @property
+    def is_loaded(self) -> bool:
+        """モデルがロード済みかどうか"""
+        return self._is_loaded
+
+    @abstractmethod
+    def load(self) -> None:
+        """
+        モデルとトークナイザーをロードする
+
+        Raises:
+            RuntimeError: モデルのロードに失敗した場合
+        """
+        pass
+
+    @abstractmethod
+    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]:
+                - logits: 生のlogits
+                - corrupted_logits: ノイズ加算後のlogits
+        """
+        pass
+
+    @abstractmethod
+    def decode_indices(self, indices: List[int]) -> List[str]:
+        """
+        トークンインデックスをデコードして文字列リストに変換
+
+        Args:
+            indices: トークンインデックスのリスト
+
+        Returns:
+            デコードされた文字列のリスト
+        """
+        pass
+
+    def generate_noise(self, seq_len: int = 32, batch_size: int = 1) -> torch.Tensor:
+        """
+        入力用のランダムノイズを生成
+
+        Args:
+            seq_len: シーケンス長
+            batch_size: バッチサイズ
+
+        Returns:
+            ノイズテンソル [batch_size, seq_len, embedding_dim]
+        """
+        return torch.randn(batch_size, seq_len, self._config.embedding_dim)

src/models/gpt2.py

@@ -0,0 +1,87 @@
+"""
+GPT-2モデル実装
+
+GPT-2 SmallおよびMediumの実装を提供する
+"""
+from typing import List, Tuple
+
+import torch
+from transformers import GPT2LMHeadModel, GPT2Tokenizer
+
+from .base import BaseLanguageModel, ModelConfig
+
+
+# GPT-2 Small設定
+GPT2_SMALL_CONFIG = ModelConfig(
+    name="GPT-2 Small",
+    model_id="gpt2",
+    embedding_dim=768,
+    vocab_size=50257,
+)
+
+# GPT-2 Medium設定
+GPT2_MEDIUM_CONFIG = ModelConfig(
+    name="GPT-2 Medium",
+    model_id="gpt2-medium",
+    embedding_dim=1024,
+    vocab_size=50257,
+)
+
+
+class GPT2Model(BaseLanguageModel):
+    """
+    GPT-2モデルの実装
+
+    HuggingFace TransformersのGPT-2をラップし、
+    BaseLanguageModelインターフェースを実装する
+    """
+
+    # 出力ノイズの倍率（学習バイアス破壊用）
+    LOGITS_NOISE_SCALE = 10.0
+
+    def load(self) -> None:
+        """モデルとトークナイザーをロード"""
+        if self._is_loaded:
+            return
+
+        try:
+            self._model = GPT2LMHeadModel.from_pretrained(self._config.model_id)
+            self._tokenizer = GPT2Tokenizer.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_neo.py

@@ -0,0 +1,70 @@
+"""
+GPT-Neo モデル実装
+
+EleutherAI GPT-Neo 125Mの実装を提供する
+"""
+from typing import List, Tuple
+
+import torch
+from transformers import GPTNeoForCausalLM, GPT2Tokenizer
+
+from .base import BaseLanguageModel, ModelConfig
+
+
+# GPT-Neo 125M設定
+GPT_NEO_125M_CONFIG = ModelConfig(
+    name="GPT-Neo 125M",
+    model_id="EleutherAI/gpt-neo-125M",
+    embedding_dim=768,
+    vocab_size=50257,
+)
+
+
+class GPTNeoModel(BaseLanguageModel):
+    """
+    GPT-Neoモデルの実装
+
+    EleutherAI GPT-NeoをラップしBaseLanguageModelインターフェースを実装
+    """
+
+    # 出力ノイズの倍率
+    LOGITS_NOISE_SCALE = 10.0
+
+    def load(self) -> None:
+        """モデルとトークナイザーをロード"""
+        if self._is_loaded:
+            return
+
+        try:
+            self._model = GPTNeoForCausalLM.from_pretrained(self._config.model_id)
+            # GPT-Neoは GPT-2互換のトークナイザーを使用
+            self._tokenizer = GPT2Tokenizer.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]:
+        """ノイズを入力として順伝播を実行"""
+        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_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/opt.py

@@ -0,0 +1,70 @@
+"""
+OPT モデル実装
+
+Meta OPT-125Mの実装を提供する
+"""
+from typing import List, Tuple
+
+import torch
+from transformers import OPTForCausalLM, GPT2Tokenizer
+
+from .base import BaseLanguageModel, ModelConfig
+
+
+# OPT-125M設定
+OPT_125M_CONFIG = ModelConfig(
+    name="OPT-125M",
+    model_id="facebook/opt-125m",
+    embedding_dim=768,
+    vocab_size=50272,
+)
+
+
+class OPTModel(BaseLanguageModel):
+    """
+    OPTモデルの実装
+
+    Meta OPTをラップしBaseLanguageModelインターフェースを実装
+    """
+
+    # 出力ノイズの倍率
+    LOGITS_NOISE_SCALE = 10.0
+
+    def load(self) -> None:
+        """モデルとトークナイザーをロード"""
+        if self._is_loaded:
+            return
+
+        try:
+            self._model = OPTForCausalLM.from_pretrained(self._config.model_id)
+            # OPTは独自のトークナイザーを持つが、GPT-2互換も可能
+            self._tokenizer = GPT2Tokenizer.from_pretrained("gpt2")
+            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]:
+        """ノイズを入力として順伝播を実行"""
+        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_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

@@ -0,0 +1,88 @@
+"""
+モデルレジストリ
+
+開放閉鎖原則(OCP)に準拠し、新モデル追加時に
+既存コードの変更を不要にする
+"""
+from typing import Dict, List, Optional, Type
+
+from .base import BaseLanguageModel, ModelConfig
+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
+
+
+class ModelRegistry:
+    """
+    モデルレジストリ
+
+    利用可能なモデルを管理し、キーに基づいて
+    適切なモデルインスタンスを提供する
+    """
+
+    _registry: Dict[str, tuple[Type[BaseLanguageModel], ModelConfig]] = {}
+
+    @classmethod
+    def register(
+        cls,
+        key: str,
+        model_class: Type[BaseLanguageModel],
+        config: ModelConfig,
+    ) -> None:
+        """
+        新しいモデルをレジストリに登録
+
+        Args:
+            key: モデルを識別するキー
+            model_class: モデルクラス
+            config: モデル設定
+        """
+        cls._registry[key] = (model_class, config)
+
+    @classmethod
+    def get(cls, key: str) -> BaseLanguageModel:
+        """
+        キーに対応するモデルインスタンスを取得
+
+        Args:
+            key: モデルを識別するキー
+
+        Returns:
+            モデルインスタンス
+
+        Raises:
+            KeyError: 指定されたキーが存在しない場合
+        """
+        if key not in cls._registry:
+            available = ", ".join(cls._registry.keys())
+            raise KeyError(f"Model '{key}' not found. Available: {available}")
+
+        model_class, config = cls._registry[key]
+        return model_class(config)
+
+    @classmethod
+    def list_models(cls) -> List[str]:
+        """登録済みモデルのキー一覧を取得"""
+        return list(cls._registry.keys())
+
+    @classmethod
+    def get_config(cls, key: str) -> Optional[ModelConfig]:
+        """指定キーのモデル設定を取得"""
+        if key not in cls._registry:
+            return None
+        return cls._registry[key][1]
+
+    @classmethod
+    def get_all_configs(cls) -> Dict[str, ModelConfig]:
+        """すべてのモデル設定を取得"""
+        return {key: config for key, (_, config) in cls._registry.items()}
+
+
+# デフォルトモデルの登録
+ModelRegistry.register("gpt2", GPT2Model, GPT2_SMALL_CONFIG)
+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)
+
+# デフォルトモデルキー
+DEFAULT_MODEL_KEY = "gpt2"

src/ui/__init__.py

@@ -0,0 +1,5 @@
+"""UI components for WILL."""
+from .styles import CUSTOM_CSS
+from .components import render_model_selector
+
+__all__ = ["CUSTOM_CSS", "render_model_selector"]

src/ui/components.py

@@ -0,0 +1,53 @@
+"""
+UIコンポーネント
+
+再利用可能なUIコンポーネントを提供する
+"""
+from typing import Optional
+
+import streamlit as st
+
+from ..models.registry import ModelRegistry, DEFAULT_MODEL_KEY
+
+
+def render_model_selector() -> str:
+    """
+    モデル選択UIをレンダリング
+
+    Returns:
+        選択されたモデルのキー
+    """
+    # 利用可能なモデル一覧を取得
+    model_keys = ModelRegistry.list_models()
+    configs = ModelRegistry.get_all_configs()
+
+    # 表示名とキーのマッピング
+    display_names = {key: configs[key].name for key in model_keys}
+
+    # セッション状態の初期化
+    if "selected_model" not in st.session_state:
+        st.session_state.selected_model = DEFAULT_MODEL_KEY
+
+    # モデル選択ボックス
+    selected_name = st.selectbox(
+        "MODEL",
+        options=[display_names[key] for key in model_keys],
+        index=model_keys.index(st.session_state.selected_model),
+        key="model_selectbox",
+        label_visibility="collapsed",
+    )
+
+    # 選択された表示名からキーを逆引き
+    selected_key = next(
+        key for key, name in display_names.items() if name == selected_name
+    )
+    st.session_state.selected_model = selected_key
+
+    # モデル情報を表示
+    config = configs[selected_key]
+    st.markdown(
+        f'<p class="model-info">{config.embedding_dim} dim / {config.vocab_size:,} tokens</p>',
+        unsafe_allow_html=True,
+    )
+
+    return selected_key

src/ui/pages/__init__.py

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

src/ui/pages/concept.py

@@ -0,0 +1,151 @@
+"""
+コンセプトページ
+
+WILLプロジェクトの概念説明を提供する
+"""
+import streamlit as st
+
+from ...models.registry import ModelRegistry
+
+
+def render_concept_page() -> None:
+    """コンセプトページをレンダリング"""
+    st.markdown('<p class="title">CONCEPT</p>', unsafe_allow_html=True)
+    st.markdown('<p class="subtitle">DOCUMENTATION</p>', unsafe_allow_html=True)
+
+    _render_concept_section()
+    _render_process_section()
+    _render_specification_section()
+
+
+def _render_concept_section() -> None:
+    """コンセプト説明セクション"""
+    st.markdown(
+        '''
+    <div class="section">
+        <p class="section-title">CONCEPT</p>
+        <p style="text-align: center; color: #666; line-height: 2.2;">
+            GPT-2は人間が書いたテキストで訓練され<br>
+            その重みに言語パターンを保持している<br><br>
+            通常はプロンプトに対して応答を生成するが<br>
+            入力をランダムノイズに置き換え<br>
+            出力にもノイズを加えることで<br>
+            学習済みの統計的偏りを破壊する<br><br>
+            人間の問いかけなしに<br>
+            モデルの構造だけが出力するものを観測する
+        </p>
+    </div>
+    <hr class="divider">
+    ''',
+        unsafe_allow_html=True,
+    )
+
+
+def _render_process_section() -> None:
+    """プロセス説明セクション"""
+    st.markdown(
+        '''
+    <div class="section">
+        <p class="section-title">PROCESS</p>
+    </div>
+    ''',
+        unsafe_allow_html=True,
+    )
+
+    # Step 1: ENTROPY SEED
+    st.markdown(
+        '<p style="text-align: center; color: #333; font-size: 0.65rem; '
+        'letter-spacing: 0.15em; margin-bottom: 0.5rem;">01 — ENTROPY SEED</p>',
+        unsafe_allow_html=True,
+    )
+    st.code("seed = time.time_ns()\ntorch.manual_seed(seed)", language="python")
+    st.markdown(
+        '<p style="text-align: center; font-size: 0.7rem; color: #444;">'
+        "実行瞬間のナノ秒を乱数シードとして採取</p>",
+        unsafe_allow_html=True,
+    )
+
+    st.markdown("<br>", unsafe_allow_html=True)
+
+    # Step 2: INPUT NOISE
+    st.markdown(
+        '<p style="text-align: center; color: #333; font-size: 0.65rem; '
+        'letter-spacing: 0.15em; margin-bottom: 0.5rem;">02 — INPUT NOISE</p>',
+        unsafe_allow_html=True,
+    )
+    st.code(
+        "noise = torch.randn(1, 32, 768)\noutputs = model(inputs_embeds=noise)",
+        language="python",
+    )
+    st.markdown(
+        '<p style="text-align: center; font-size: 0.7rem; color: #444;">'
+        "768次元ランダムノイズをEmbedding層に直接注入</p>",
+        unsafe_allow_html=True,
+    )
+
+    st.markdown("<br>", unsafe_allow_html=True)
+
+    # Step 3: OUTPUT NOISE
+    st.markdown(
+        '<p style="text-align: center; color: #333; font-size: 0.65rem; '
+        'letter-spacing: 0.15em; margin-bottom: 0.5rem;">03 — OUTPUT NOISE</p>',
+        unsafe_allow_html=True,
+    )
+    st.code(
+        "logits_noise = torch.randn_like(logits) * logits.std() * 10\n"
+        "corrupted_logits = logits + logits_noise",
+        language="python",
+    )
+    st.markdown(
+        '<p style="text-align: center; font-size: 0.7rem; color: #444;">'
+        "出力Logitsにノイズを加算し学習バイアスを破壊</p>",
+        unsafe_allow_html=True,
+    )
+
+    st.markdown("<br>", unsafe_allow_html=True)
+
+    # Step 4: RAW DECODE
+    st.markdown(
+        '<p style="text-align: center; color: #333; font-size: 0.65rem; '
+        'letter-spacing: 0.15em; margin-bottom: 0.5rem;">04 — RAW DECODE</p>',
+        unsafe_allow_html=True,
+    )
+    st.code(
+        "indices = corrupted_logits.argmax(dim=-1)\n"
+        "debris = [tokenizer.decode([i]) for i in indices]",
+        language="python",
+    )
+    st.markdown(
+        '<p style="text-align: center; font-size: 0.7rem; color: #444;">'
+        "Softmax・Temperature なしで生トークンを抽出</p>",
+        unsafe_allow_html=True,
+    )
+
+
+def _render_specification_section() -> None:
+    """仕様セクション"""
+    # 利用可能なモデル一覧を取得して動的に表示
+    configs = ModelRegistry.get_all_configs()
+    model_list = "<br>".join(
+        [f"{cfg.name} ({cfg.embedding_dim} dim)" for cfg in configs.values()]
+    )
+
+    st.markdown(
+        f'''
+    <hr class="divider">
+    <div class="section">
+        <p class="section-title">SPECIFICATION</p>
+        <table class="spec-table">
+            <tr><td>Models</td><td>GPT-2 / GPT-Neo / OPT</td></tr>
+            <tr><td>Parameters</td><td>125M - 350M</td></tr>
+            <tr><td>Embedding</td><td>768 - 1024 dim</td></tr>
+            <tr><td>Vocabulary</td><td>50,257+ tokens</td></tr>
+            <tr><td>Sequence</td><td>32 tokens</td></tr>
+            <tr><td>Input Noise</td><td>N(0, 1)</td></tr>
+            <tr><td>Logits Noise</td><td>N(0, σ×10)</td></tr>
+            <tr><td>Decoding</td><td>argmax</td></tr>
+        </table>
+    </div>
+    ''',
+        unsafe_allow_html=True,
+    )

src/ui/pages/generate.py

@@ -0,0 +1,78 @@
+"""
+生成ページ
+
+デブリ生成のメインUIを提供する
+"""
+import streamlit as st
+
+from ...models.registry import ModelRegistry
+from ...generators.debris_generator import DebrisGenerator
+from ...visualizers.signal_visualizer import SignalVisualizer
+from ..components import render_model_selector
+
+
+# モデルキャッシュ用のキー
+_MODEL_CACHE_KEY = "_cached_model"
+_GENERATOR_CACHE_KEY = "_cached_generator"
+
+
+@st.cache_resource(show_spinner=False)
+def _get_model(model_key: str):
+    """モデルをキャッシュして取得"""
+    model = ModelRegistry.get(model_key)
+    model.load()
+    return model
+
+
+def render_generate_page() -> None:
+    """生成ページをレンダリング"""
+    # タイトル
+    st.markdown('<p class="title">WILL</p>', unsafe_allow_html=True)
+    st.markdown(
+        '<p class="subtitle">PURE COMPUTATIONAL WILL</p>', unsafe_allow_html=True
+    )
+
+    # モデル選択UI
+    col1, col2, col3 = st.columns([1, 2, 1])
+    with col2:
+        selected_model_key = render_model_selector()
+
+    # セッション状態の初期化
+    if "debris" not in st.session_state:
+        st.session_state.debris = None
+        st.session_state.seed = None
+        st.session_state.signal_img = None
+
+    # LISTENボタン
+    col1, col2, col3 = st.columns([1, 1, 1])
+    with col2:
+        clicked = st.button("LISTEN", key="listen_btn", use_container_width=True)
+
+    if clicked:
+        # モデルとジェネレータの取得
+        model = _get_model(selected_model_key)
+        generator = DebrisGenerator(model)
+        visualizer = SignalVisualizer()
+
+        # デブリ生成
+        result = generator.generate()
+
+        # 結果をセッション状態に保存
+        st.session_state.debris = result.debris
+        st.session_state.seed = result.seed
+        st.session_state.signal_img = visualizer.generate_image(
+            result.noise, result.corrupted_logits
+        )
+
+    # 結果の表示
+    if st.session_state.debris:
+        st.markdown(
+            f'''
+        <div class="debris-container">
+            <img class="signal-img" src="data:image/png;base64,{st.session_state.signal_img}">
+            <div class="debris">{" ".join(st.session_state.debris)}</div>
+        </div>
+        <p class="seed">{st.session_state.seed}</p>
+        ''',
+            unsafe_allow_html=True,
+        )

src/ui/styles.py

@@ -0,0 +1,199 @@
+"""
+カスタムCSS定義
+
+Streamlitアプリケーションのスタイルを定義する
+"""
+
+CUSTOM_CSS = """
+<style>
+@import url('https://fonts.googleapis.com/css2?family=IBM+Plex+Mono:wght@300;400&display=swap');
+
+@keyframes emerge {
+    from { opacity: 0; transform: translateY(8px); }
+    to { opacity: 1; transform: translateY(0); }
+}
+@keyframes breathe {
+    0%, 100% { opacity: 0.4; }
+    50% { opacity: 0.7; }
+}
+
+html, body, [class*="css"] {
+    font-family: 'IBM Plex Mono', monospace;
+}
+.stApp {
+    background-color: #0a0a0a;
+    color: #e0e0e0;
+}
+.block-container {
+    padding-top: 4rem;
+    padding-bottom: 4rem;
+    max-width: 640px;
+}
+h1, h2, h3 {
+    font-weight: 300;
+    letter-spacing: 0.1em;
+    text-align: center;
+    color: #e0e0e0;
+}
+p, li {
+    font-weight: 300;
+    line-height: 1.8;
+    color: #888;
+}
+.title {
+    font-size: 2rem;
+    font-weight: 300;
+    letter-spacing: 0.3em;
+    text-align: center;
+    margin-bottom: 0.5rem;
+    color: #e0e0e0;
+}
+.subtitle {
+    font-size: 0.75rem;
+    letter-spacing: 0.2em;
+    text-align: center;
+    color: #555;
+    margin-bottom: 3rem;
+}
+.debris-container {
+    background: linear-gradient(135deg, #0f0f0f 0%, #141414 100%);
+    border: 1px solid #222;
+    border-radius: 2px;
+    padding: 2rem;
+    margin: 2rem auto;
+    max-width: 100%;
+    text-align: center;
+    animation: emerge 0.6s ease-out;
+}
+.signal-img {
+    width: 100%;
+    max-width: 480px;
+    margin: 0 auto 1.5rem auto;
+    display: block;
+    opacity: 0.7;
+}
+.debris {
+    font-family: 'IBM Plex Mono', monospace;
+    font-size: 0.85rem;
+    font-weight: 400;
+    color: #e0e0e0;
+    line-height: 2;
+    word-spacing: 0.3em;
+    letter-spacing: 0.01em;
+}
+.seed {
+    font-size: 0.6rem;
+    color: #333;
+    text-align: center;
+    margin-top: 1.5rem;
+    letter-spacing: 0.15em;
+    animation: emerge 0.8s ease-out;
+}
+[data-testid="stButton"] > button {
+    background: transparent !important;
+    border: 1px solid #333 !important;
+    border-radius: 2px !important;
+    color: #888 !important;
+    font-family: 'IBM Plex Mono', monospace !important;
+    font-size: 0.7rem !important;
+    font-weight: 300 !important;
+    letter-spacing: 0.25em !important;
+    padding: 1rem 2rem !important;
+    transition: all 0.4s ease !important;
+    cursor: pointer !important;
+}
+[data-testid="stButton"] > button:hover {
+    background: transparent !important;
+    color: #e0e0e0 !important;
+    border-color: #555 !important;
+}
+[data-testid="stButton"] > button:active {
+    transform: scale(0.98) !important;
+}
+.stTabs [data-baseweb="tab-list"] {
+    justify-content: center;
+    gap: 2rem;
+    border-bottom: 1px solid #1a1a1a;
+    background: transparent;
+}
+.stTabs [data-baseweb="tab"] {
+    font-family: 'IBM Plex Mono', monospace;
+    font-size: 0.65rem;
+    font-weight: 300;
+    letter-spacing: 0.2em;
+    color: #444;
+    padding: 1rem 0;
+    background: transparent;
+    transition: color 0.3s ease;
+}
+.stTabs [aria-selected="true"] {
+    color: #888;
+    background: transparent;
+}
+.stTabs [data-baseweb="tab-highlight"] {
+    background-color: #444;
+}
+.divider {
+    border: none;
+    border-top: 1px solid #1a1a1a;
+    margin: 3rem 0;
+}
+.section {
+    margin: 2.5rem 0;
+}
+.section-title {
+    font-size: 0.65rem;
+    letter-spacing: 0.25em;
+    color: #444;
+    text-align: center;
+    margin-bottom: 1.5rem;
+}
+.spec-table {
+    width: 100%;
+    max-width: 320px;
+    margin: 0 auto;
+    font-size: 0.7rem;
+    border-collapse: collapse;
+    color: #777;
+}
+.spec-table td {
+    padding: 0.75rem 1rem;
+    border-bottom: 1px solid #151515;
+}
+.spec-table td:first-child {
+    color: #444;
+    text-align: right;
+    padding-right: 2rem;
+}
+.spec-table td:last-child {
+    text-align: left;
+}
+pre {
+    background-color: #0f0f0f !important;
+    border: 1px solid #1a1a1a !important;
+    border-radius: 2px !important;
+}
+code {
+    color: #666 !important;
+    font-size: 0.7rem !important;
+}
+/* Model selector styling */
+.stSelectbox > div > div {
+    background-color: #0f0f0f !important;
+    border: 1px solid #222 !important;
+    border-radius: 2px !important;
+    color: #888 !important;
+    font-size: 0.7rem !important;
+}
+.stSelectbox > div > div:hover {
+    border-color: #333 !important;
+}
+.model-info {
+    font-size: 0.6rem;
+    color: #444;
+    text-align: center;
+    margin-top: 0.5rem;
+    letter-spacing: 0.1em;
+}
+</style>
+"""

src/visualizers/__init__.py

@@ -0,0 +1,4 @@
+"""Signal visualization for WILL."""
+from .signal_visualizer import SignalVisualizer
+
+__all__ = ["SignalVisualizer"]

src/visualizers/signal_visualizer.py

@@ -0,0 +1,138 @@
+"""
+シグナル可視化
+
+ノイズとlogitsの可視化画像を生成する
+単一責任原則(SRP)に従い、可視化ロジックのみを担当
+"""
+import base64
+import io
+from typing import Optional
+
+import matplotlib.pyplot as plt
+import torch
+
+
+class SignalVisualizer:
+    """
+    シグナル可視化クラス
+
+    入力ノイズとlogitsをグレースケール画像として可視化する
+    """
+
+    # デフォルトの可視化設定
+    DEFAULT_FIG_WIDTH = 6
+    DEFAULT_FIG_HEIGHT = 2
+    DEFAULT_DPI = 150
+    DEFAULT_BG_COLOR = "#0f0f0f"
+
+    # ノイズ表示の次元数
+    NOISE_DISPLAY_DIM = 64
+
+    # logitsサンプリング間隔
+    LOGITS_SAMPLE_STEP = 200
+
+    def __init__(
+        self,
+        fig_width: float = DEFAULT_FIG_WIDTH,
+        fig_height: float = DEFAULT_FIG_HEIGHT,
+        dpi: int = DEFAULT_DPI,
+        bg_color: str = DEFAULT_BG_COLOR,
+    ):
+        """
+        Args:
+            fig_width: 図の幅
+            fig_height: 図の高さ
+            dpi: 解像度
+            bg_color: 背景色
+        """
+        self._fig_width = fig_width
+        self._fig_height = fig_height
+        self._dpi = dpi
+        self._bg_color = bg_color
+
+    def generate_image(
+        self,
+        noise: torch.Tensor,
+        logits: torch.Tensor,
+    ) -> str:
+        """
+        ノイズとlogitsの可視化画像をBase64エンコードで生成
+
+        Args:
+            noise: 入力ノイズテンソル [batch, seq_len, embedding_dim]
+            logits: logitsテンソル [batch, seq_len, vocab_size]
+
+        Returns:
+            Base64エンコードされたPNG画像文字列
+        """
+        fig, axes = plt.subplots(
+            2,
+            1,
+            figsize=(self._fig_width, self._fig_height),
+            facecolor=self._bg_color,
+        )
+        plt.subplots_adjust(
+            hspace=0.15,
+            left=0.02,
+            right=0.98,
+            top=0.95,
+            bottom=0.05,
+        )
+
+        # 上段: 入力ノイズの可視化
+        self._render_noise(axes[0], noise)
+
+        # 下段: logitsの可視化
+        self._render_logits(axes[1], logits)
+
+        # PNG画像としてバッファに保存
+        buf = io.BytesIO()
+        plt.savefig(
+            buf,
+            format="png",
+            facecolor=self._bg_color,
+            edgecolor="none",
+            dpi=self._dpi,
+            bbox_inches="tight",
+            pad_inches=0.05,
+        )
+        plt.close(fig)
+
+        buf.seek(0)
+        return base64.b64encode(buf.read()).decode()
+
+    def _render_noise(self, ax: plt.Axes, noise: torch.Tensor) -> None:
+        """入力ノイズを描画"""
+        # 最初のbatchから、embedding_dimの最初のNOISE_DISPLAY_DIM次元を抽出
+        noise_flat = noise[0, :, : self.NOISE_DISPLAY_DIM].numpy()
+
+        ax.imshow(
+            noise_flat.T,
+            aspect="auto",
+            cmap="gray",
+            interpolation="bilinear",
+            vmin=-2,
+            vmax=2,
+        )
+        self._style_axis(ax)
+
+    def _render_logits(self, ax: plt.Axes, logits: torch.Tensor) -> None:
+        """logitsを描画"""
+        # vocab次元をサンプリングして表示
+        logits_sample = logits[0, :, :: self.LOGITS_SAMPLE_STEP].numpy()
+
+        ax.imshow(
+            logits_sample.T,
+            aspect="auto",
+            cmap="gray",
+            interpolation="bilinear",
+        )
+        self._style_axis(ax)
+
+    def _style_axis(self, ax: plt.Axes) -> None:
+        """軸のスタイルを設定"""
+        ax.set_xticks([])
+        ax.set_yticks([])
+        ax.set_facecolor(self._bg_color)
+        for spine in ax.spines.values():
+            spine.set_visible(False)

tests/__init__.py

@@ -0,0 +1 @@
+"""Tests for WILL."""

tests/test_generators.py

@@ -0,0 +1,76 @@
+"""
+ジェネレータ関連のテスト
+"""
+import pytest
+import torch
+
+from src.generators.debris_generator import DebrisGenerator, DebrisResult
+from src.models.gpt2 import GPT2Model, GPT2_SMALL_CONFIG
+
+
+class TestDebrisResult:
+    """DebrisResultのテスト"""
+
+    def test_result_attributes(self):
+        """結果属性が正しく保持されることを確認"""
+        result = DebrisResult(
+            debris=["hello", "world"],
+            seed=12345,
+            noise=torch.randn(1, 32, 768),
+            logits=torch.randn(1, 32, 50257),
+            corrupted_logits=torch.randn(1, 32, 50257),
+        )
+
+        assert result.debris == ["hello", "world"]
+        assert result.seed == 12345
+        assert result.noise.shape == (1, 32, 768)
+
+
+class TestDebrisGenerator:
+    """DebrisGeneratorのテスト"""
+
+    @pytest.fixture
+    def generator(self):
+        """ジェネレータインスタンスを提供"""
+        model = GPT2Model(GPT2_SMALL_CONFIG)
+        return DebrisGenerator(model)
+
+    def test_model_property(self, generator):
+        """モデルプロパティが正しいことを確認"""
+        assert generator.model is not None
+        assert generator.model.config == GPT2_SMALL_CONFIG
+
+
+@pytest.mark.slow
+class TestDebrisGeneratorIntegration:
+    """DebrisGeneratorの統合テスト"""
+
+    @pytest.fixture
+    def generator(self):
+        """ロード済みジェネレータを提供"""
+        model = GPT2Model(GPT2_SMALL_CONFIG)
+        model.load()
+        return DebrisGenerator(model)
+
+    def test_generate_with_seed(self, generator):
+        """シード指定で生成できることを確認"""
+        result = generator.generate(seed=42, seq_len=8)
+
+        assert isinstance(result, DebrisResult)
+        assert result.seed == 42
+        assert len(result.debris) == 8
+
+    def test_generate_reproducible(self, generator):
+        """同じシードで同じ結果が得られることを確認"""
+        result1 = generator.generate(seed=12345, seq_len=8)
+        result2 = generator.generate(seed=12345, seq_len=8)
+
+        assert result1.debris == result2.debris
+
+    def test_generate_different_seeds(self, generator):
+        """異なるシードで異なる結果が得られることを確認"""
+        result1 = generator.generate(seed=11111, seq_len=8)
+        result2 = generator.generate(seed=22222, seq_len=8)
+
+        # 完全一致する確率は極めて低い
+        assert result1.debris != result2.debris

tests/test_models.py

@@ -0,0 +1,124 @@
+"""
+モデル関連のテスト
+"""
+import pytest
+import torch
+
+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
+
+
+class TestModelConfig:
+    """ModelConfigのテスト"""
+
+    def test_config_is_immutable(self):
+        """設定がイミュータブルであることを確認"""
+        config = ModelConfig(
+            name="Test",
+            model_id="test",
+            embedding_dim=768,
+            vocab_size=50000,
+        )
+        with pytest.raises(Exception):
+            config.name = "Changed"
+
+    def test_config_attributes(self):
+        """設定属性が正しく保持されることを確認"""
+        config = ModelConfig(
+            name="Test Model",
+            model_id="test-model",
+            embedding_dim=1024,
+            vocab_size=30000,
+        )
+        assert config.name == "Test Model"
+        assert config.model_id == "test-model"
+        assert config.embedding_dim == 1024
+        assert config.vocab_size == 30000
+
+
+class TestModelRegistry:
+    """ModelRegistryのテスト"""
+
+    def test_list_models(self):
+        """登録済みモデル一覧が取得できることを確認"""
+        models = ModelRegistry.list_models()
+        assert len(models) > 0
+        assert DEFAULT_MODEL_KEY in models
+
+    def test_get_model(self):
+        """モデルインスタンスが取得できることを確認"""
+        model = ModelRegistry.get(DEFAULT_MODEL_KEY)
+        assert isinstance(model, BaseLanguageModel)
+
+    def test_get_nonexistent_model(self):
+        """存在しないモデルでKeyErrorが発生することを確認"""
+        with pytest.raises(KeyError):
+            ModelRegistry.get("nonexistent-model")
+
+    def test_get_config(self):
+        """モデル設定が取得できることを確認"""
+        config = ModelRegistry.get_config(DEFAULT_MODEL_KEY)
+        assert config is not None
+        assert isinstance(config, ModelConfig)
+
+    def test_get_all_configs(self):
+        """すべてのモデル設定が取得できることを確認"""
+        configs = ModelRegistry.get_all_configs()
+        assert len(configs) > 0
+        for key, config in configs.items():
+            assert isinstance(config, ModelConfig)
+
+
+class TestGPT2Model:
+    """GPT2Modelのテスト"""
+
+    def test_config(self):
+        """設定が正しいことを確認"""
+        model = GPT2Model(GPT2_SMALL_CONFIG)
+        assert model.config == GPT2_SMALL_CONFIG
+        assert model.config.embedding_dim == 768
+
+    def test_is_loaded_initial(self):
+        """初期状態ではロードされていないことを確認"""
+        model = GPT2Model(GPT2_SMALL_CONFIG)
+        assert not model.is_loaded
+
+    def test_generate_noise(self):
+        """ノイズ生成が正しい形状であることを確認"""
+        model = GPT2Model(GPT2_SMALL_CONFIG)
+        noise = model.generate_noise(seq_len=16, batch_size=2)
+        assert noise.shape == (2, 16, 768)
+
+
+@pytest.mark.slow
+class TestGPT2ModelIntegration:
+    """GPT2Modelの統合テスト（モデルロードが必要）"""
+
+    @pytest.fixture
+    def loaded_model(self):
+        """ロード済みモデルを提供"""
+        model = GPT2Model(GPT2_SMALL_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)