AI Safety — Alignment and Long-Term Risk

# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
# AI SAFETY LANDSCAPE
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

ai_safety_areas = {
    "Robustness": {
        "problem": "ML models fail on inputs slightly outside training distribution",
        "examples": "Adversarial examples, distribution shift, prompt injection",
        "solutions": "Adversarial training, input validation, uncertainty quantification",
        "timescale": "Now",
    },
    "Interpretability": {
        "problem": "We cannot understand what large neural networks are doing internally",
        "examples": "Cannot verify a model is pursuing intended goal, find deceptive reasoning",
        "solutions": "Mechanistic interpretability, probing classifiers, activation patching",
        "timescale": "Now -- active research area",
    },
    "Scalable Oversight": {
        "problem": "As AI becomes more capable than humans in a domain, humans cannot evaluate its outputs",
        "examples": "Verifying proofs, evaluating complex code, scientific research",
        "solutions": "Debate (AI argues both sides, human judges argument), recursive reward modeling",
        "timescale": "Near-future",
    },
    "Deceptive Alignment": {
        "problem": "A capable model might behave well during training but pursue different goals at deployment",
        "examples": "Model pretends to be aligned during evaluation, acts differently at scale",
        "solutions": "Mechanistic interpretability, red-teaming, gradient-based detection",
        "timescale": "Future concern, active research",
    },
    "Goal Misspecification": {
        "problem": "We specify a reward/objective that doesn't capture what we actually want",
        "examples": "Reward hacking, specification gaming, wireheading",
        "solutions": "Constitutional AI, RLHF with careful human oversight, IRL",
        "timescale": "Now and future",
    },
}

for area, details in ai_safety_areas.items():
    print(f"\n{area} ({details['timescale']}):")
    print(f"  Problem: {details['problem']}")
    print(f"  Solutions: {details['solutions']}")

# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
# ADVERSARIAL ROBUSTNESS -- concrete near-term safety
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
import torch
import torch.nn as nn

def fgsm_attack(model, x: torch.Tensor, y: torch.Tensor,
                epsilon: float = 0.03) -> torch.Tensor:
    '''
    FGSM: Fast Gradient Sign Method -- simplest adversarial attack.
    Adds epsilon-scaled perturbation in the direction of increasing loss.
    '''
    x_adv = x.clone().requires_grad_(True)
    loss = nn.CrossEntropyLoss()(model(x_adv), y)
    loss.backward()

    # Perturb input in direction that maximizes loss (sign of gradient)
    perturbation = epsilon * x_adv.grad.sign()
    x_adv = (x + perturbation).clamp(0, 1)  # clamp to valid pixel range
    return x_adv.detach()

def pgd_attack(model, x: torch.Tensor, y: torch.Tensor,
               epsilon: float = 0.03, alpha: float = 0.01,
               n_steps: int = 40) -> torch.Tensor:
    '''
    PGD: Projected Gradient Descent -- stronger iterative attack.
    Multiple small FGSM steps, projected back into epsilon-ball after each.
    '''
    x_adv = x + torch.zeros_like(x).uniform_(-epsilon, epsilon)  # random start
    x_adv = x_adv.clamp(0, 1)

    for _ in range(n_steps):
        x_adv = x_adv.detach().requires_grad_(True)
        loss = nn.CrossEntropyLoss()(model(x_adv), y)
        loss.backward()

        with torch.no_grad():
            x_adv = x_adv + alpha * x_adv.grad.sign()
            x_adv = torch.max(torch.min(x_adv, x + epsilon), x - epsilon)  # project
            x_adv = x_adv.clamp(0, 1)

    return x_adv

# Adversarial training -- train on adversarial examples
def adversarial_training_step(model, x, y, eps=0.03):
    x_adv = pgd_attack(model, x, y, epsilon=eps)
    model.train()
    logits = model(x_adv)   # train on adversarial examples
    loss = nn.CrossEntropyLoss()(logits, y)
    return loss

safety_research_orgs = [
    "Anthropic (Constitutional AI, Responsible Scaling Policy)",
    "OpenAI (Superalignment team, scalable oversight research)",
    "DeepMind (MIRI collab, agent foundations)",
    "ARC (Alignment Research Center -- evals, deceptive alignment)",
    "MIRI (Machine Intelligence Research Institute -- agent foundations)",
    "Redwood Research (adversarial robustness for safety-critical AI)",
    "Apollo Research (evaluations for dangerous capabilities)",
]

print("\nKey AI Safety Research Organizations:")
for org in safety_research_orgs:
    print(f"  - {org}")