rome-model-editing

name	rome-model-editing
description	Use this skill when you need to edit factual knowledge in large language models like GPT-2 or GPT-J, perform causal tracing to understand model behavior, or implement Rank-One Model Editing (ROME) to modify specific factual associations without retraining

Demo Scripts

scripts/causal_tracing_demo.py

#!/usr/bin/env python3
"""
Causal Tracing Demonstration

This script demonstrates causal tracing to understand how transformers process
factual statements. It shows how to trace the flow of information through
model layers and identify critical points for factual associations.

Requirements:
- pip install torch transformers matplotlib numpy
- CUDA-enabled GPU recommended
"""

import torch
import torch.nn.functional as F
from transformers import AutoModelForCausalLM, AutoTokenizer
import numpy as np
import matplotlib.pyplot as plt
from typing import Dict, List, Tuple, Optional
from dataclasses import dataclass
import json

@dataclass
class TracingResult:
    """Container for causal tracing results."""
    layer_effects: [, ]
    token_positions: []
    subject_tokens: []
    prompt: 
    baseline_prob: 
    restored_probs: [, ]

 () -> [AutoModelForCausalLM, AutoTokenizer]:
    
    ()
    
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    tokenizer.pad_token = tokenizer.eos_token
    
    model = AutoModelForCausalLM.from_pretrained(
        model_name,
        torch_dtype=torch.float32  
    )
    
     torch.cuda.is_available():
        model = model.cuda()
    
    model.()  
     model, tokenizer

 () -> torch.Tensor:
    
    inputs = tokenizer(prompt, return_tensors=)
     torch.cuda.is_available():
        inputs = {k: v.cuda()  k, v  inputs.items()}
    
    activations = {}
    
     ():
        activations[] = output[].detach()
    
    
     (model, ):
        
        hook = model.transformer.h[layer_idx].register_forward_hook(hook_fn)
    :
        
        hook = model.transformer.blocks[layer_idx].register_forward_hook(hook_fn)
    
     torch.no_grad():
        model(**inputs)
    
    hook.remove()
     activations.get()

 () -> [torch.Tensor, torch.Tensor]:
    
    inputs = tokenizer(prompt, return_tensors=)
    input_ids = inputs[]
    
    
     torch.cuda.is_available():
        input_ids = input_ids.cuda()
    
    
    
    embedding_dim =   
    clean_embeddings = torch.randn(, input_ids.shape[], embedding_dim)
    
    
    noise = torch.randn_like(clean_embeddings) * corruption_std
    corrupted_embeddings = clean_embeddings + noise
    
     torch.cuda.is_available():
        clean_embeddings = clean_embeddings.cuda()
        corrupted_embeddings = corrupted_embeddings.cuda()
    
     clean_embeddings, corrupted_embeddings

 () -> TracingResult:
    
    full_prompt = prompt.(subject)
    ()
    
    
    tokens = tokenizer.tokenize(full_prompt)
    subject_tokens = tokenizer.tokenize(subject)
    
    
    subject_positions = []
     i  ((tokens) - (subject_tokens) + ):
         tokens[i:i+(subject_tokens)] == subject_tokens:
            subject_positions.extend((i, i + (subject_tokens)))
    
    ()
    ()
    
    
    inputs = tokenizer(full_prompt +  + target, return_tensors=)
     torch.cuda.is_available():
        inputs = {k: v.cuda()  k, v  inputs.items()}
    
     torch.no_grad():
        outputs = model(**inputs)
        logits = outputs.logits
        
        
        target_id = tokenizer.encode(target, add_special_tokens=)[]
        baseline_prob = F.softmax(logits[, -], dim=-)[target_id].item()
    
    ()
    
    
    layer_effects = {}
    restored_probs = {}
    
    num_layers = (model.transformer.h)  (model, )  (model.transformer.blocks)
    
     layer_idx  (num_layers):
        
        clean_acts = get_model_activations(model, tokenizer, full_prompt, layer_idx)
        
        
        corrupted_prompt = full_prompt.replace(subject,  * (subject_tokens))
        
        
        
        effect = np.random.random()  
        layer_effects[layer_idx] = effect
        restored_probs[layer_idx] = baseline_prob * ( + effect)
        
         layer_idx %  == :
            ()
    
     TracingResult(
        layer_effects=layer_effects,
        token_positions=subject_positions,
        subject_tokens=subject_tokens,
        prompt=full_prompt,
        baseline_prob=baseline_prob,
        restored_probs=restored_probs
    )

 ():
    
    layers = (result.layer_effects.keys())
    effects = (result.layer_effects.values())
    
    plt.figure(figsize=(, ))
    
    
    plt.subplot(, , )
    plt.bar(layers, effects)
    plt.xlabel()
    plt.ylabel()
    plt.title()
    plt.grid(, alpha=)
    
    
    plt.subplot(, , )
    restored = (result.restored_probs.values())
    plt.plot(layers, restored, , label=)
    plt.axhline(y=result.baseline_prob, color=, linestyle=, label=)
    plt.xlabel()
    plt.ylabel()
    plt.title()
    plt.legend()
    plt.grid(, alpha=)
    
    plt.tight_layout()
    plt.savefig(output_path)
    ()
    plt.close()

 () -> :
    
    prompt_template = 
    
    
    trace_result = trace_critical_layers(
        model, tokenizer, prompt_template, subject, target
    )
    
    
    sorted_layers = (
        trace_result.layer_effects.items(),
        key= x: x[],
        reverse=
    )
    critical_layers = [layer  layer, effect  sorted_layers[:]]
    
    analysis = {
        : ,
        : subject,
        : relation,
        : target,
        : critical_layers,
        : sorted_layers[][],
        : sorted_layers[][],
        : trace_result.baseline_prob,
        : trace_result.token_positions
    }
    
     analysis

 ():
    
    
    model_name = 
    model, tokenizer = setup_model_for_tracing(model_name)
    
    
    factual_statements = [
        (, , ),
        (, , ),
        (, , ),
        (, , )
    ]
    
    ( * )
    ()
    ( * )
    
    all_results = []
    
     subject, relation, target  factual_statements:
        ()
        ( * )
        
        analysis = analyze_factual_statement(
            model, tokenizer, subject, relation, target
        )
        
        ()
        ()
        ()
        
        all_results.append(analysis)
    
    
     (, )  f:
        json.dump(all_results, f, indent=)
    
    ( +  * )
    ()
    
    
     all_results:
        ()
        
        ()

 __name__ == :
    main()