高度なデコーディング戦略 — Contrastive Search・Repetition Penaltyなど最新の生成制御手法

import numpy as np
import matplotlib.pyplot as plt
from scipy.special import softmax

np.random.seed(42)

def create_logits(vocab_size=50, spike_idx=None, spike_val=5.0):
    """テスト用のロジットベクトルを生成"""
    logits = np.random.randn(vocab_size)
    if spike_idx is not None:
        logits[spike_idx] = spike_val
    return logits

# 基本的なロジット（語彙サイズ50）
logits = create_logits(vocab_size=50, spike_idx=0, spike_val=5.0)
probs = softmax(logits)

print(f"語彙サイズ: {len(logits)}")
print(f"最大確率トークン: index={np.argmax(probs)}, prob={probs[np.argmax(probs)]:.4f}")
print(f"エントロピー: {-np.sum(probs * np.log2(probs + 1e-12)):.4f} bits")

import numpy as np
from scipy.special import softmax

def apply_repetition_penalty(logits, generated_tokens, theta=1.2):
    """
    Repetition Penalty を適用する

    Parameters:
        logits: ロジットベクトル (numpy array)
        generated_tokens: 生成済みトークンのリスト
        theta: ペナルティパラメータ (> 1 でペナルティ強化)

    Returns:
        ペナルティ適用後のロジット
    """
    logits_penalized = logits.copy()
    for token_id in set(generated_tokens):
        if logits_penalized[token_id] > 0:
            logits_penalized[token_id] /= theta
        else:
            logits_penalized[token_id] *= theta
    return logits_penalized

# テスト: トークン0と3がすでに生成済みとする
logits = create_logits(vocab_size=50, spike_idx=0, spike_val=5.0)
generated = [0, 3, 0, 5, 0]  # トークン0が3回出現

# 異なるペナルティ強度での比較
thetas = [1.0, 1.2, 1.5, 2.0]
fig, axes = plt.subplots(1, len(thetas), figsize=(16, 4))

for ax, theta in zip(axes, thetas):
    penalized = apply_repetition_penalty(logits, generated, theta=theta)
    probs_pen = softmax(penalized)
    top_k = 10
    top_indices = np.argsort(probs_pen)[-top_k:][::-1]

    colors = ['#e74c3c' if idx in set(generated) else '#3498db'
              for idx in top_indices]
    ax.barh(range(top_k), probs_pen[top_indices], color=colors)
    ax.set_yticks(range(top_k))
    ax.set_yticklabels([f'Token {i}' for i in top_indices])
    ax.set_xlabel('Probability')
    ax.set_title(f'θ = {theta}')
    ax.invert_yaxis()

plt.suptitle('Repetition Penalty: Effect of θ', fontsize=14)
plt.tight_layout()
plt.show()

import numpy as np
from scipy.special import softmax

def apply_frequency_presence_penalty(logits, token_counts, alpha_f=0.0, alpha_p=0.0):
    """
    Frequency Penalty と Presence Penalty を適用する

    Parameters:
        logits: ロジットベクトル
        token_counts: 各トークンの出現回数 (dict: token_id -> count)
        alpha_f: Frequency Penalty パラメータ
        alpha_p: Presence Penalty パラメータ

    Returns:
        ペナルティ適用後のロジット
    """
    logits_penalized = logits.copy()
    for token_id, count in token_counts.items():
        logits_penalized[token_id] -= alpha_f * count
        if count > 0:
            logits_penalized[token_id] -= alpha_p
    return logits_penalized

# テスト: トークンの出現回数
logits = create_logits(vocab_size=50, spike_idx=0, spike_val=5.0)
token_counts = {0: 5, 3: 2, 5: 1, 8: 3}

# Frequency vs Presence の比較
fig, axes = plt.subplots(1, 3, figsize=(15, 5))

configs = [
    {'alpha_f': 0.5, 'alpha_p': 0.0, 'title': 'Frequency Only (α_f=0.5)'},
    {'alpha_f': 0.0, 'alpha_p': 1.0, 'title': 'Presence Only (α_p=1.0)'},
    {'alpha_f': 0.3, 'alpha_p': 0.5, 'title': 'Combined (α_f=0.3, α_p=0.5)'},
]

for ax, config in zip(axes, configs):
    penalized = apply_frequency_presence_penalty(
        logits, token_counts,
        alpha_f=config['alpha_f'], alpha_p=config['alpha_p']
    )
    probs_pen = softmax(penalized)

    # 出現済みトークンと未出現トークンの確率を比較
    appeared = list(token_counts.keys())
    appeared_probs = [probs_pen[i] for i in appeared]
    appeared_labels = [f'Token {i}\n(count={token_counts[i]})' for i in appeared]

    colors = plt.cm.Reds(np.linspace(0.3, 0.9, len(appeared)))
    ax.bar(range(len(appeared)), appeared_probs, color=colors)
    ax.set_xticks(range(len(appeared)))
    ax.set_xticklabels(appeared_labels, fontsize=9)
    ax.set_ylabel('Probability')
    ax.set_title(config['title'])

plt.suptitle('Frequency vs Presence Penalty on Previously Generated Tokens', fontsize=13)
plt.tight_layout()
plt.show()

import numpy as np
from scipy.special import softmax

def contrastive_search(logits, hidden_states_candidates, hidden_states_context,
                       alpha=0.6, k=10):
    """
    Contrastive Search のスコアを計算する

    Parameters:
        logits: ロジットベクトル
        hidden_states_candidates: 候補トークンの隠れ状態 (k, d)
        hidden_states_context: 過去の生成トークンの隠れ状態 (t, d)
        alpha: 品質と多様性のバランスパラメータ
        k: 候補トークン数

    Returns:
        選択されたトークンのインデックス, スコア配列
    """
    probs = softmax(logits)
    top_k_indices = np.argsort(probs)[-k:][::-1]
    top_k_probs = probs[top_k_indices]

    # コサイン類似度の計算
    def cosine_sim(a, b):
        return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b) + 1e-8)

    scores = []
    for i, (idx, prob) in enumerate(zip(top_k_indices, top_k_probs)):
        # 各候補と過去の全トークンとの最大コサイン類似度
        max_sim = max(
            cosine_sim(hidden_states_candidates[i], h)
            for h in hidden_states_context
        )
        # Contrastive Score
        score = (1 - alpha) * prob - alpha * max_sim
        scores.append(score)

    scores = np.array(scores)
    best_idx = np.argmax(scores)
    return top_k_indices[best_idx], scores, top_k_indices

# シミュレーション: 合成的な隠れ状態でテスト
np.random.seed(42)
hidden_dim = 64
vocab_size = 50
k = 10

logits = create_logits(vocab_size=vocab_size, spike_idx=0, spike_val=5.0)
probs = softmax(logits)
top_k_indices = np.argsort(probs)[-k:][::-1]

# 候補トークンの隠れ状態
h_candidates = np.random.randn(k, hidden_dim)
# 過去の生成トークンの隠れ状態（Token 0に近いベクトルを含む）
h_context = np.random.randn(5, hidden_dim)
h_context[0] = h_candidates[0] + np.random.randn(hidden_dim) * 0.1  # Token 0に類似

# 異なるαでの比較
alphas = [0.0, 0.3, 0.6, 0.9]
fig, axes = plt.subplots(2, 2, figsize=(12, 10))

for ax, alpha in zip(axes.ravel(), alphas):
    selected, scores, indices = contrastive_search(
        logits, h_candidates, h_context, alpha=alpha, k=k
    )

    colors = ['#e74c3c' if idx == selected else '#3498db' for idx in indices]
    ax.barh(range(k), scores, color=colors)
    ax.set_yticks(range(k))
    ax.set_yticklabels([f'Token {i}' for i in indices])
    ax.set_xlabel('Contrastive Score')
    ax.set_title(f'α = {alpha} (selected: Token {selected})')
    ax.invert_yaxis()
    ax.axvline(x=0, color='gray', linestyle='--', alpha=0.5)

plt.suptitle('Contrastive Search: Effect of α on Token Selection', fontsize=14)
plt.tight_layout()
plt.show()

import numpy as np
from scipy.special import softmax

def typical_decoding(logits, tau=0.95, temperature=1.0):
    """
    Typical Decoding を適用する

    Parameters:
        logits: ロジットベクトル
        tau: 累積確率のしきい値
        temperature: Temperature パラメータ

    Returns:
        サンプリング結果のトークンインデックス, フィルタ後の確率分布
    """
    probs = softmax(logits / temperature)

    # エントロピーの計算
    entropy = -np.sum(probs * np.log2(probs + 1e-12))

    # 各トークンの情報量
    info = -np.log2(probs + 1e-12)

    # エントロピーとの差の絶対値
    delta = np.abs(info - entropy)

    # δが小さい順にソート
    sorted_indices = np.argsort(delta)

    # 累積確率がτを超えるまでトークンを追加
    cumsum = 0.0
    typical_set = []
    for idx in sorted_indices:
        typical_set.append(idx)
        cumsum += probs[idx]
        if cumsum >= tau:
            break

    # 再正規化
    typical_probs = np.zeros_like(probs)
    for idx in typical_set:
        typical_probs[idx] = probs[idx]
    typical_probs /= typical_probs.sum()

    # サンプリング
    sampled = np.random.choice(len(logits), p=typical_probs)
    return sampled, typical_probs, entropy, delta

# Typical Decoding vs Top-p の比較
np.random.seed(42)
logits = create_logits(vocab_size=50, spike_idx=0, spike_val=5.0)
probs_original = softmax(logits)

# Top-p (Nucleus) サンプリング
def top_p_filter(probs, p=0.95):
    sorted_indices = np.argsort(probs)[::-1]
    cumsum = np.cumsum(probs[sorted_indices])
    cutoff = np.searchsorted(cumsum, p) + 1
    selected = sorted_indices[:cutoff]
    filtered = np.zeros_like(probs)
    for idx in selected:
        filtered[idx] = probs[idx]
    filtered /= filtered.sum()
    return filtered

top_p_probs = top_p_filter(probs_original, p=0.95)
_, typical_probs, entropy, delta = typical_decoding(logits, tau=0.95)

fig, axes = plt.subplots(1, 3, figsize=(18, 5))

# 元の分布
top_n = 15
sorted_idx = np.argsort(probs_original)[-top_n:][::-1]

axes[0].bar(range(top_n), probs_original[sorted_idx], color='#3498db')
axes[0].set_xticks(range(top_n))
axes[0].set_xticklabels([f'T{i}' for i in sorted_idx], fontsize=8)
axes[0].set_ylabel('Probability')
axes[0].set_title('Original Distribution')

# Top-p
top_p_sorted = top_p_probs[sorted_idx]
colors_tp = ['#2ecc71' if p > 0 else '#bdc3c7' for p in top_p_sorted]
axes[1].bar(range(top_n), top_p_sorted, color=colors_tp)
axes[1].set_xticks(range(top_n))
axes[1].set_xticklabels([f'T{i}' for i in sorted_idx], fontsize=8)
axes[1].set_ylabel('Probability')
axes[1].set_title(f'Top-p (p=0.95)\n{np.sum(top_p_probs > 0)} tokens selected')

# Typical Decoding
typical_sorted = typical_probs[sorted_idx]
colors_td = ['#e74c3c' if p > 0 else '#bdc3c7' for p in typical_sorted]
axes[2].bar(range(top_n), typical_sorted, color=colors_td)
axes[2].set_xticks(range(top_n))
axes[2].set_xticklabels([f'T{i}' for i in sorted_idx], fontsize=8)
axes[2].set_ylabel('Probability')
axes[2].set_title(f'Typical Decoding (τ=0.95)\n{np.sum(typical_probs > 0)} tokens, H={entropy:.2f} bits')

plt.suptitle('Top-p vs Typical Decoding: Which Tokens Are Selected?', fontsize=14)
plt.tight_layout()
plt.show()

import numpy as np
from scipy.special import softmax

def min_p_sampling(logits, p_base=0.1, temperature=1.0):
    """
    min-p sampling を適用する

    Parameters:
        logits: ロジットベクトル
        p_base: 最大確率に対する比率しきい値
        temperature: Temperature パラメータ

    Returns:
        サンプリング結果, フィルタ後の確率分布
    """
    probs = softmax(logits / temperature)
    p_max = np.max(probs)
    threshold = p_base * p_max

    # しきい値以上のトークンだけ残す
    filtered = np.where(probs >= threshold, probs, 0.0)
    filtered /= filtered.sum()

    sampled = np.random.choice(len(logits), p=filtered)
    return sampled, filtered, threshold

def eta_sampling(logits, epsilon=0.001, temperature=1.0):
    """
    η-sampling を適用する

    Parameters:
        logits: ロジットベクトル
        epsilon: しきい値計算用の定数
        temperature: Temperature パラメータ

    Returns:
        サンプリング結果, フィルタ後の確率分布
    """
    probs = softmax(logits / temperature)
    entropy = -np.sum(probs * np.log2(probs + 1e-12))

    # 動的しきい値の計算
    eta = min(epsilon, np.sqrt(epsilon) * np.exp(-entropy))

    # しきい値以上のトークンだけ残す
    filtered = np.where(probs >= eta, probs, 0.0)
    if filtered.sum() == 0:
        filtered = probs.copy()
    filtered /= filtered.sum()

    sampled = np.random.choice(len(logits), p=filtered)
    return sampled, filtered, eta

# 異なる分布形状での min-p の適応性を確認
np.random.seed(42)
fig, axes = plt.subplots(2, 3, figsize=(18, 10))

# 鋭い分布と平坦な分布を作成
distributions = [
    ("Sharp (spike=8.0)", create_logits(50, spike_idx=0, spike_val=8.0)),
    ("Medium (spike=4.0)", create_logits(50, spike_idx=0, spike_val=4.0)),
    ("Flat (no spike)", np.random.randn(50) * 0.5),
]

for col, (name, logits_test) in enumerate(distributions):
    probs_test = softmax(logits_test)
    _, min_p_probs, thresh = min_p_sampling(logits_test, p_base=0.1)

    top_n = 15
    sorted_idx = np.argsort(probs_test)[-top_n:][::-1]

    # 元の分布
    axes[0][col].bar(range(top_n), probs_test[sorted_idx], color='#3498db', alpha=0.7)
    axes[0][col].set_title(f'{name}\nOriginal')
    axes[0][col].set_xticks(range(top_n))
    axes[0][col].set_xticklabels([f'T{i}' for i in sorted_idx], fontsize=7)

    # min-p 適用後
    min_p_sorted = min_p_probs[sorted_idx]
    colors = ['#2ecc71' if p > 0 else '#bdc3c7' for p in min_p_sorted]
    axes[1][col].bar(range(top_n), min_p_sorted, color=colors, alpha=0.7)
    n_selected = np.sum(min_p_probs > 0)
    axes[1][col].set_title(f'min-p (p_base=0.1)\n{n_selected} tokens, thresh={thresh:.4f}')
    axes[1][col].set_xticks(range(top_n))
    axes[1][col].set_xticklabels([f'T{i}' for i in sorted_idx], fontsize=7)

for ax_row in axes:
    for ax in ax_row:
        ax.set_ylabel('Probability')

plt.suptitle('min-p Sampling: Adaptive Behavior Across Distribution Shapes', fontsize=14)
plt.tight_layout()
plt.show()

import numpy as np
from scipy.special import softmax

def mirostat_v2_step(logits, mu, tau=5.0, eta=0.1):
    """
    Mirostat v2 の1ステップを実行する

    Parameters:
        logits: ロジットベクトル
        mu: 現在のsurprisalしきい値
        tau: 目標Perplexity
        eta: 学習率

    Returns:
        サンプリングされたトークン, 更新後のmu, surprisal
    """
    probs = softmax(logits)

    # 目標surprisal
    target_surprise = np.log2(tau)

    # surprisal がμ以下のトークンを候補にする
    surprisals = -np.log2(probs + 1e-12)
    mask = surprisals <= mu

    if not np.any(mask):
        # 候補がない場合、最高確率トークンだけを候補にする
        mask = np.zeros_like(probs, dtype=bool)
        mask[np.argmax(probs)] = True

    filtered_probs = np.where(mask, probs, 0.0)
    filtered_probs /= filtered_probs.sum()

    # サンプリング
    sampled = np.random.choice(len(logits), p=filtered_probs)
    sampled_surprise = -np.log2(probs[sampled] + 1e-12)

    # μの更新
    mu_new = mu + eta * (target_surprise - sampled_surprise)

    return sampled, mu_new, sampled_surprise

def simulate_mirostat(n_steps=100, tau=5.0, eta=0.1, vocab_size=50):
    """Mirostat v2 の動的サンプリングをシミュレーション"""
    mu = 2 * np.log2(tau)  # 初期しきい値

    surprisals = []
    mus = []
    n_candidates = []

    for step in range(n_steps):
        # 各ステップでランダムなロジットを生成（異なるコンテキストをシミュレート）
        logits = np.random.randn(vocab_size) * (1.5 + 0.5 * np.sin(step / 10))
        # 少しのスパイクを入れる
        spike = np.random.randint(0, vocab_size)
        logits[spike] += np.random.uniform(2.0, 6.0)

        probs = softmax(logits)
        surp = -np.log2(probs + 1e-12)
        n_cand = np.sum(surp <= mu)
        n_candidates.append(n_cand)

        sampled, mu, sampled_surprise = mirostat_v2_step(logits, mu, tau=tau, eta=eta)

        surprisals.append(sampled_surprise)
        mus.append(mu)

    return surprisals, mus, n_candidates

# シミュレーション実行
np.random.seed(42)
taus = [3.0, 5.0, 8.0]
fig, axes = plt.subplots(3, 1, figsize=(14, 12))

for tau in taus:
    surprisals, mus, n_cands = simulate_mirostat(n_steps=200, tau=tau, eta=0.1)
    target = np.log2(tau)

    axes[0].plot(surprisals, alpha=0.6, label=f'τ={tau}')
    axes[0].axhline(y=target, linestyle='--', alpha=0.4)

    axes[1].plot(mus, alpha=0.6, label=f'τ={tau}')

    axes[2].plot(n_cands, alpha=0.6, label=f'τ={tau}')

axes[0].set_ylabel('Surprisal (bits)')
axes[0].set_title('Sampled Token Surprisal Over Time')
axes[0].legend()
axes[0].set_xlabel('Step')

axes[1].set_ylabel('μ (threshold)')
axes[1].set_title('Dynamic Threshold μ Over Time')
axes[1].legend()
axes[1].set_xlabel('Step')

axes[2].set_ylabel('# Candidates')
axes[2].set_title('Number of Candidate Tokens Over Time')
axes[2].legend()
axes[2].set_xlabel('Step')

plt.suptitle('Mirostat v2: Dynamic Sampling Across Target Perplexities', fontsize=14)
plt.tight_layout()
plt.show()

import numpy as np
from scipy.special import softmax
from collections import Counter

np.random.seed(42)

def simulate_generation(method, n_steps=200, vocab_size=50):
    """各手法での生成をシミュレーション"""
    generated_tokens = []
    surprisals = []

    # Mirostat用の状態
    mu = 2 * np.log2(5.0)

    for step in range(n_steps):
        # ステップごとにロジットを変化させる（文脈の変化をシミュレート）
        base_logits = np.random.randn(vocab_size) * 1.5
        # いくつかのトークンにスパイクを与える
        for spike_idx in np.random.choice(vocab_size, size=3, replace=False):
            base_logits[spike_idx] += np.random.uniform(2.0, 5.0)

        probs = softmax(base_logits)

        if method == 'greedy':
            token = np.argmax(probs)

        elif method == 'temperature':
            probs_t = softmax(base_logits / 0.8)
            token = np.random.choice(vocab_size, p=probs_t)

        elif method == 'top_p':
            sorted_idx = np.argsort(probs)[::-1]
            cumsum = np.cumsum(probs[sorted_idx])
            cutoff = np.searchsorted(cumsum, 0.9) + 1
            selected = sorted_idx[:cutoff]
            sel_probs = probs[selected] / probs[selected].sum()
            token = np.random.choice(selected, p=sel_probs)

        elif method == 'rep_penalty':
            pen_logits = apply_repetition_penalty(base_logits, generated_tokens, theta=1.3)
            pen_probs = softmax(pen_logits)
            token = np.random.choice(vocab_size, p=pen_probs)

        elif method == 'typical':
            token, _, _, _ = typical_decoding(base_logits, tau=0.9)

        elif method == 'min_p':
            token, _, _ = min_p_sampling(base_logits, p_base=0.1)

        elif method == 'mirostat':
            token, mu, _ = mirostat_v2_step(base_logits, mu, tau=5.0, eta=0.1)

        generated_tokens.append(token)
        token_surprise = -np.log2(probs[token] + 1e-12)
        surprisals.append(token_surprise)

    return generated_tokens, surprisals

# 全手法のシミュレーション
methods = ['greedy', 'temperature', 'top_p', 'rep_penalty', 'typical', 'min_p', 'mirostat']
method_labels = ['Greedy', 'Temperature\n(T=0.8)', 'Top-p\n(p=0.9)',
                 'Rep. Penalty\n(θ=1.3)', 'Typical\n(τ=0.9)', 'min-p\n(p=0.1)',
                 'Mirostat\n(τ=5)']

results = {}
for method in methods:
    tokens, surprisals = simulate_generation(method, n_steps=200)
    unique_tokens = len(set(tokens))
    avg_surprise = np.mean(surprisals)
    std_surprise = np.std(surprisals)
    results[method] = {
        'tokens': tokens, 'surprisals': surprisals,
        'unique': unique_tokens, 'avg_surprise': avg_surprise,
        'std_surprise': std_surprise
    }

# 可視化
fig, axes = plt.subplots(2, 2, figsize=(16, 12))

# 1. Surprisal分布の箱ひげ図
surprise_data = [results[m]['surprisals'] for m in methods]
bp = axes[0][0].boxplot(surprise_data, labels=method_labels, patch_artist=True)
colors_box = ['#e74c3c', '#f39c12', '#2ecc71', '#3498db', '#9b59b6', '#1abc9c', '#e67e22']
for patch, color in zip(bp['boxes'], colors_box):
    patch.set_facecolor(color)
    patch.set_alpha(0.7)
axes[0][0].set_ylabel('Surprisal (bits)')
axes[0][0].set_title('Surprisal Distribution by Method')
axes[0][0].tick_params(axis='x', labelsize=8)

# 2. ユニークトークン数
unique_counts = [results[m]['unique'] for m in methods]
axes[0][1].bar(range(len(methods)), unique_counts, color=colors_box, alpha=0.7)
axes[0][1].set_xticks(range(len(methods)))
axes[0][1].set_xticklabels(method_labels, fontsize=8)
axes[0][1].set_ylabel('Unique Tokens')
axes[0][1].set_title('Token Diversity (Unique Tokens in 200 Steps)')

# 3. 平均Surprisal vs 標準偏差（品質-多様性プロット）
for i, method in enumerate(methods):
    axes[1][0].scatter(
        results[method]['avg_surprise'],
        results[method]['std_surprise'],
        color=colors_box[i], s=150, zorder=5, edgecolors='black', linewidth=1
    )
    axes[1][0].annotate(
        method_labels[i].replace('\n', ' '),
        (results[method]['avg_surprise'], results[method]['std_surprise']),
        textcoords="offset points", xytext=(10, 5), fontsize=8
    )
axes[1][0].set_xlabel('Mean Surprisal (bits)')
axes[1][0].set_ylabel('Std Surprisal (bits)')
axes[1][0].set_title('Quality-Diversity Trade-off')

# 4. トークン頻度分布（上位20トークン）
for i, method in enumerate(methods):
    counter = Counter(results[method]['tokens'])
    top20 = counter.most_common(20)
    freqs = [c for _, c in top20]
    axes[1][1].plot(range(len(freqs)), freqs, 'o-', color=colors_box[i],
                     alpha=0.7, label=method_labels[i].replace('\n', ' '), markersize=4)
axes[1][1].set_xlabel('Token Rank')
axes[1][1].set_ylabel('Frequency')
axes[1][1].set_title('Token Frequency Distribution (Top 20)')
axes[1][1].legend(fontsize=7, loc='upper right')

plt.suptitle('Comprehensive Comparison of Decoding Strategies', fontsize=14)
plt.tight_layout()
plt.show()

import numpy as np
import matplotlib.pyplot as plt

# 各手法の特性を5段階でスコアリング（主観的評価 + シミュレーション結果）
categories = ['Diversity', 'Quality', 'Adaptivity', 'Simplicity', 'Determinism']
n_cats = len(categories)

method_scores = {
    'Greedy':          [1, 4, 1, 5, 5],
    'Temperature':     [3, 3, 1, 5, 1],
    'Top-p':           [3, 4, 2, 4, 1],
    'Rep. Penalty':    [4, 3, 2, 4, 1],
    'Typical Dec.':    [4, 4, 3, 3, 1],
    'min-p':           [4, 4, 4, 4, 1],
    'Contrastive':     [4, 5, 3, 2, 5],
    'Mirostat':        [4, 4, 5, 3, 1],
}

angles = np.linspace(0, 2 * np.pi, n_cats, endpoint=False).tolist()
angles += angles[:1]

fig, axes = plt.subplots(2, 4, figsize=(20, 10), subplot_kw=dict(polar=True))
colors_radar = ['#e74c3c', '#f39c12', '#2ecc71', '#3498db',
                '#9b59b6', '#1abc9c', '#e67e22', '#c0392b']

for idx, (name, scores) in enumerate(method_scores.items()):
    ax = axes[idx // 4][idx % 4]
    values = scores + scores[:1]
    ax.fill(angles, values, alpha=0.25, color=colors_radar[idx])
    ax.plot(angles, values, 'o-', color=colors_radar[idx], linewidth=2)
    ax.set_xticks(angles[:-1])
    ax.set_xticklabels(categories, fontsize=8)
    ax.set_ylim(0, 5)
    ax.set_title(name, fontsize=11, fontweight='bold', pad=15)
    ax.set_yticks([1, 2, 3, 4, 5])
    ax.set_yticklabels(['1', '2', '3', '4', '5'], fontsize=7)

plt.suptitle('Decoding Strategy Characteristics (Radar Chart)', fontsize=14)
plt.tight_layout()
plt.show()