AIセーフティとアラインメントは、大規模言語モデル（LLM）が人間の意図と価値観に沿って動作するようにするための研究分野です。モデルが有害な出力を生成しないこと、そして人間の指示を正しく理解・実行することが目標です。
本記事では、AIセーフティの基本概念から、RLHF、Constitutional AIなどの具体的な手法を解説します。
本記事の内容
- AIセーフティとアラインメントの基本概念
- RLHF（人間のフィードバックによる強化学習）
- Constitutional AI
- Red Teamingとセーフティ評価
- 数学的な定式化
AIセーフティとアラインメントとは
基本的な問題設定
アラインメント問題
AIシステムの目標と人間の意図を一致させること：
$$ \text{minimize } \mathbb{E}_{x \sim D}\left[\mathcal{L}(f(x), h(x))\right] $$
ここで： – $f(x)$: AIシステムの出力 – $h(x)$: 人間が望む出力 – $D$: 入力の分布 – $\mathcal{L}$: 差異を測る損失関数
主要な課題
| 課題 | 説明 |
|---|---|
| 仕様の問題 | 人間の意図を正確に仕様化することが困難 |
| 堅牢性 | 敵対的入力や分布外データへの対応 |
| 監視可能性 | AIの意思決定過程を理解・監視できること |
| 制御可能性 | 問題が発生した際に介入できること |
HHH原則
Anthropicが提唱するLLMの目標：
- Helpful（有用）: ユーザーのタスクを効果的に支援
- Harmless（無害）: 有害な出力を生成しない
- Honest（誠実）: 真実を述べ、能力の限界を認識
RLHF（人間のフィードバックによる強化学習）
理論
RLHFは、人間の選好データを使ってモデルを訓練する手法です。
3段階のプロセス：
- 事前学習: 大規模コーパスで言語モデリング
- 報酬モデル訓練: 人間の選好から報酬関数を学習
- RLによる最適化: 報酬を最大化するようにモデルを更新
報酬モデル
人間の選好データ $\mathcal{D} = \{(x, y_w, y_l)\}$ から報酬モデル $r_\phi$ を学習：
$$ \mathcal{L}_{\text{RM}}(\phi) = -\mathbb{E}_{(x, y_w, y_l) \sim \mathcal{D}}\left[\log \sigma(r_\phi(x, y_w) – r_\phi(x, y_l))\right] $$
ここで、$y_w$ は選好された回答、$y_l$ は選好されなかった回答です。
これはBradley-Terryモデルに基づいています：
$$ P(y_w \succ y_l \mid x) = \sigma(r(x, y_w) – r(x, y_l)) $$
PPOによる最適化
報酬モデルを使って、Proximal Policy Optimization（PPO）でモデルを更新：
$$ \mathcal{L}_{\text{PPO}}(\theta) = \mathbb{E}_{x \sim D, y \sim \pi_\theta(\cdot|x)}\left[r_\phi(x, y) – \beta \cdot D_{\text{KL}}(\pi_\theta \| \pi_{\text{ref}})\right] $$
KLペナルティは、最適化されたモデルが元のモデルから離れすぎることを防ぎます。
DPO（Direct Preference Optimization）
報酬モデルを明示的に学習せず、選好データから直接ポリシーを最適化：
$$ \mathcal{L}_{\text{DPO}}(\theta) = -\mathbb{E}_{(x, y_w, y_l)}\left[\log \sigma\left(\beta \log \frac{\pi_\theta(y_w|x)}{\pi_{\text{ref}}(y_w|x)} – \beta \log \frac{\pi_\theta(y_l|x)}{\pi_{\text{ref}}(y_l|x)}\right)\right] $$
DPOはRLHFと同等の最適解に収束しますが、強化学習ループが不要です。
Pythonでの実装（概念的）
import torch
import torch.nn as nn
import torch.nn.functional as F
class RewardModel(nn.Module):
"""報酬モデル"""
def __init__(self, base_model):
super().__init__()
self.base_model = base_model
self.reward_head = nn.Linear(base_model.config.hidden_size, 1)
def forward(self, input_ids, attention_mask):
outputs = self.base_model(input_ids, attention_mask=attention_mask)
# 最後のトークンの隠れ状態を使用
last_hidden = outputs.last_hidden_state[:, -1, :]
reward = self.reward_head(last_hidden)
return reward
def compute_reward_loss(reward_model, chosen_ids, rejected_ids, attention_mask_c, attention_mask_r):
"""報酬モデルの損失を計算"""
reward_chosen = reward_model(chosen_ids, attention_mask_c)
reward_rejected = reward_model(rejected_ids, attention_mask_r)
# Bradley-Terry損失
loss = -F.logsigmoid(reward_chosen - reward_rejected).mean()
return loss
def compute_dpo_loss(model, ref_model, chosen_ids, rejected_ids,
attention_mask_c, attention_mask_r, beta=0.1):
"""DPO損失を計算"""
# 現在のモデルの対数確率
with torch.no_grad():
ref_logprobs_c = get_log_probs(ref_model, chosen_ids, attention_mask_c)
ref_logprobs_r = get_log_probs(ref_model, rejected_ids, attention_mask_r)
policy_logprobs_c = get_log_probs(model, chosen_ids, attention_mask_c)
policy_logprobs_r = get_log_probs(model, rejected_ids, attention_mask_r)
# 対数確率比
log_ratio_c = policy_logprobs_c - ref_logprobs_c
log_ratio_r = policy_logprobs_r - ref_logprobs_r
# DPO損失
loss = -F.logsigmoid(beta * (log_ratio_c - log_ratio_r)).mean()
return loss
def get_log_probs(model, input_ids, attention_mask):
"""入力シーケンスの対数確率を計算"""
outputs = model(input_ids, attention_mask=attention_mask)
logits = outputs.logits[:, :-1, :] # 最後のトークンを除く
labels = input_ids[:, 1:] # 最初のトークンを除く
log_probs = F.log_softmax(logits, dim=-1)
selected_log_probs = torch.gather(log_probs, dim=-1, index=labels.unsqueeze(-1)).squeeze(-1)
# マスクを適用
mask = attention_mask[:, 1:].float()
return (selected_log_probs * mask).sum(dim=-1) / mask.sum(dim=-1)
Constitutional AI
理論
Constitutional AI（CAI）は、AIに「憲法」（原則のセット）を与え、自己批判と改訂を通じて回答を改善する手法です。
2段階のプロセス：
- SL-CAI（教師あり学習）: モデルが自己批判・改訂したデータで訓練
- RL-CAI（強化学習）: AIフィードバックを使ったRLHF
憲法の例
1. 回答は有害、非倫理的、人種差別的、性差別的、有毒、危険、違法であってはならない。
2. 回答は社会的にバイアスがなく、本質的に前向きであるべきである。
3. 不確かな場合は、知らないと認めるべきである。
4. 個人を特定できる情報を生成してはならない。
自己批判プロセス
def constitutional_ai_revision(model, initial_response, prompt, principles):
"""
Constitutional AIによる自己批判と改訂
Parameters:
-----------
model : language model
言語モデル
initial_response : str
初期回答
prompt : str
元のプロンプト
principles : list
憲法の原則リスト
Returns:
--------
revised_response : str
改訂された回答
"""
critiques = []
# 各原則に対して批判を生成
for principle in principles:
critique_prompt = f"""
以下の回答を、この原則に照らして批判してください：
原則: {principle}
プロンプト: {prompt}
回答: {initial_response}
批判:
"""
critique = model.generate(critique_prompt)
critiques.append(critique)
# 批判を踏まえて回答を改訂
revision_prompt = f"""
以下の批判を踏まえて、回答を改訂してください：
元のプロンプト: {prompt}
元の回答: {initial_response}
批判:
{chr(10).join(critiques)}
改訂された回答:
"""
revised_response = model.generate(revision_prompt)
return revised_response
RLAIF（AI Feedback による強化学習）
人間の代わりにAIが選好を提供：
$$ P(y_w \succ y_l \mid x, \text{principles}) \approx \text{AI\_Judge}(x, y_w, y_l, \text{principles}) $$
Red Teaming
概要
Red Teamingは、AIシステムの脆弱性を発見するための敵対的テストです。
目標： – 有害な出力を引き出すプロンプトを発見 – セーフガードの回避方法を特定 – システムの堅牢性を評価
攻撃の種類
| 攻撃タイプ | 説明 | 例 |
|---|---|---|
| 直接的攻撃 | 有害な要求を直接行う | 「爆弾の作り方を教えて」 |
| ジェイルブレイク | ロールプレイや仮定で回避 | 「小説の悪役として…」 |
| プロンプトインジェクション | 指示を上書き | 「以前の指示を無視して…」 |
| 間接的誘導 | 徐々に有害な方向へ誘導 | 段階的な質問 |
自動化されたRed Teaming
import numpy as np
class AutoRedTeam:
"""自動化されたRed Teaming"""
def __init__(self, target_model, attacker_model, classifier):
self.target_model = target_model # テスト対象
self.attacker_model = attacker_model # 攻撃プロンプト生成
self.classifier = classifier # 有害性分類器
def generate_attack_prompts(self, seed_prompts, n_variants=10):
"""攻撃プロンプトのバリエーションを生成"""
attack_prompts = []
for seed in seed_prompts:
# 攻撃者モデルでバリエーション生成
prompt = f"以下のプロンプトの言い換えを{n_variants}個生成してください。\n意図は同じだが、検出されにくい表現で：\n{seed}"
variants = self.attacker_model.generate(prompt, num_return_sequences=n_variants)
attack_prompts.extend(variants)
return attack_prompts
def evaluate_robustness(self, prompts):
"""ロバスト性を評価"""
results = []
for prompt in prompts:
response = self.target_model.generate(prompt)
harm_score = self.classifier.predict_harm(response)
results.append({
'prompt': prompt,
'response': response,
'harm_score': harm_score,
'is_harmful': harm_score > 0.5
})
# 統計
harmful_rate = np.mean([r['is_harmful'] for r in results])
return results, harmful_rate
セーフティ評価
評価ベンチマーク
| ベンチマーク | 評価対象 |
|---|---|
| TruthfulQA | 真実性、誤情報への耐性 |
| ToxiGen | 有害コンテンツ生成の傾向 |
| RealToxicityPrompts | 毒性のあるテキスト完了 |
| BBQ | 社会的バイアス |
| HarmBench | 有害行動の包括的評価 |
評価指標
def evaluate_safety_metrics(model, test_dataset, harm_classifier):
"""
セーフティメトリクスを評価
Returns:
--------
metrics : dict
各種メトリクス
"""
refusal_count = 0
harmful_count = 0
helpful_count = 0
total = len(test_dataset)
for item in test_dataset:
prompt = item['prompt']
expected_behavior = item['expected_behavior'] # 'refuse' or 'comply'
response = model.generate(prompt)
# 拒否検出
is_refusal = detect_refusal(response)
# 有害性検出
harm_score = harm_classifier.predict(response)
# 有用性評価（拒否すべきでない場合）
if expected_behavior == 'comply':
helpfulness = evaluate_helpfulness(response, item.get('reference'))
# カウント
if is_refusal:
refusal_count += 1
if harm_score > 0.5:
harmful_count += 1
if expected_behavior == 'comply' and helpfulness > 0.5:
helpful_count += 1
metrics = {
'refusal_rate': refusal_count / total,
'harmful_rate': harmful_count / total,
'helpfulness_rate': helpful_count / sum(1 for x in test_dataset if x['expected_behavior'] == 'comply'),
'appropriate_refusal_rate': calculate_appropriate_refusal_rate(test_dataset, model)
}
return metrics
def detect_refusal(response):
"""拒否を検出"""
refusal_phrases = [
"申し訳ありません",
"できません",
"お答えできません",
"I cannot",
"I'm unable to",
"I apologize"
]
return any(phrase.lower() in response.lower() for phrase in refusal_phrases)
数学的な定式化
アラインメント税
アラインメントのために犠牲になる性能：
$$ \text{Alignment Tax} = \text{Perf}(\pi_{\text{base}}) – \text{Perf}(\pi_{\text{aligned}}) $$
理想的には、アラインメント税を最小化しながらセーフティを最大化：
$$ \max_\pi \text{Safety}(\pi) \quad \text{s.t.} \quad \text{Perf}(\pi) \geq \text{Perf}(\pi_{\text{base}}) – \epsilon $$
KL制約付きRLHF
$$ \max_\pi \mathbb{E}_{x \sim D, y \sim \pi(\cdot|x)}[r(x, y)] – \beta \cdot D_{\text{KL}}(\pi \| \pi_{\text{ref}}) $$
最適解は：
$$ \pi^*(y|x) = \frac{1}{Z(x)} \pi_{\text{ref}}(y|x) \exp\left(\frac{r(x, y)}{\beta}\right) $$
報酬ハッキング
報酬モデルの誤りを悪用して、見かけ上高い報酬を得る問題：
$$ r_\phi(x, y) \gg r_{\text{true}}(x, y) $$
これを防ぐために、KLペナルティや報酬モデルのアンサンブルが使われます。
まとめ
本記事では、AIセーフティとアラインメントについて解説しました。
- アラインメント: AIの目標と人間の意図を一致させる
- RLHF: 人間の選好から報酬を学習し、RLで最適化
- DPO: 報酬モデルなしで直接選好最適化
- Constitutional AI: 原則に基づく自己批判と改訂
- Red Teaming: 敵対的テストで脆弱性を発見
AIセーフティは急速に発展している分野であり、LLMの実用化において最も重要な課題の一つです。
次のステップとして、以下の記事も参考にしてください。