File size: 7,309 Bytes
e861587 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 | # Standalone modeling file for 150M Geometry checkpoint.
# Saved into checkpoint dir so from_pretrained(..., trust_remote_code=True) loads correctly.
# Contains cosine attention + geometry model; no overlap reg at inference.
from __future__ import annotations
import math
from typing import List, Optional
import torch
import torch.nn.functional as F
from torch import nn
from transformers import GPT2Config
from transformers.models.gpt2.modeling_gpt2 import (
GPT2Attention,
GPT2Block,
GPT2Model,
GPT2PreTrainedModel,
)
from transformers.modeling_outputs import CausalLMOutputWithCrossAttentions
class GPT2GeometryConfig(GPT2Config):
model_type = "gpt2_geometry"
def __init__(self, use_cosine_attention: bool = True, geometry_collapse_layers: Optional[List[int]] = None, **kwargs):
self.use_cosine_attention = kwargs.pop("use_cosine_attention", True)
self.geometry_collapse_layers = kwargs.pop("geometry_collapse_layers", None)
super().__init__(**kwargs)
def cosine_attention_forward(module, query, key, value, attention_mask, **kwargs):
d_k = value.size(-1)
Q_norm = F.normalize(query, p=2, dim=-1)
K_norm = F.normalize(key, p=2, dim=-1)
attn_weights = torch.matmul(Q_norm, K_norm.transpose(-1, -2)) / math.sqrt(d_k)
if module.scale_attn_by_inverse_layer_idx and getattr(module, "layer_idx", None) is not None:
attn_weights = attn_weights / float(module.layer_idx + 1)
if attention_mask is not None:
attn_weights = attn_weights + attention_mask
attn_weights = nn.functional.softmax(attn_weights, dim=-1)
attn_weights = attn_weights.type(value.dtype)
attn_weights = module.attn_dropout(attn_weights)
attn_output = torch.matmul(attn_weights, value)
attn_output = attn_output.transpose(1, 2)
return attn_output, attn_weights
class CosineGPT2Attention(GPT2Attention):
def forward(
self,
hidden_states,
past_key_values=None,
cache_position=None,
attention_mask=None,
encoder_hidden_states=None,
encoder_attention_mask=None,
output_attentions=None,
**kwargs,
):
is_cross_attention = encoder_hidden_states is not None
if is_cross_attention:
query_states = self.q_attn(hidden_states)
attention_mask = encoder_attention_mask
key_states, value_states = self.c_attn(encoder_hidden_states).split(self.split_size, dim=2)
else:
query_states, key_states, value_states = self.c_attn(hidden_states).split(self.split_size, dim=2)
shape_kv = (*key_states.shape[:-1], -1, self.head_dim)
key_states = key_states.view(shape_kv).transpose(1, 2)
value_states = value_states.view(shape_kv).transpose(1, 2)
shape_q = (*query_states.shape[:-1], -1, self.head_dim)
query_states = query_states.view(shape_q).transpose(1, 2)
attn_output, attn_weights = cosine_attention_forward(
self, query_states, key_states, value_states, attention_mask
)
attn_output = attn_output.reshape(*attn_output.shape[:-2], -1).contiguous()
attn_output = self.c_proj(attn_output)
attn_output = self.resid_dropout(attn_output)
return attn_output, attn_weights
def overlap_reg_var(lm_head_weight: torch.Tensor, n_probe: int = 2048) -> torch.Tensor:
"""Compute Var[(w_i·w_j)²] over LM head row pairs (upper triangle). Only used during training."""
W = lm_head_weight
if W.shape[0] < 2:
return torch.tensor(0.0, device=W.device, dtype=W.dtype)
n = min(n_probe, W.shape[0])
W_sub = W[:n]
G = torch.mm(W_sub, W_sub.T)
G2 = G ** 2
triu_idx = torch.triu_indices(n, n, 1, device=G2.device)
vals = G2[triu_idx[0], triu_idx[1]]
return torch.var(vals)
class GPT2BlockGeometry(GPT2Block):
def __init__(self, config, layer_idx=None):
super().__init__(config, layer_idx)
use_cosine_global = getattr(config, "use_cosine_attention", True)
collapse_layers = getattr(config, "geometry_collapse_layers", None)
use_cosine_here = use_cosine_global and (
collapse_layers is None or (layer_idx is not None and layer_idx in collapse_layers)
)
if use_cosine_here:
self.attn = CosineGPT2Attention(config=config, layer_idx=layer_idx)
else:
self.attn = GPT2Attention(config=config, layer_idx=layer_idx)
class GPT2ModelGeometry(GPT2Model):
def __init__(self, config):
super().__init__(config)
self.h = nn.ModuleList([GPT2BlockGeometry(config, layer_idx=i) for i in range(config.num_hidden_layers)])
class GPT2LMHeadModelGeometry(GPT2PreTrainedModel):
config_class = GPT2GeometryConfig
_tied_weights_keys = {"lm_head.weight": "transformer.wte.weight"}
def __init__(self, config, overlap_lambda: float = 0.05, **kwargs):
super().__init__(config, **kwargs)
self.transformer = GPT2ModelGeometry(config)
self.lm_head = nn.Linear(config.n_embd, config.vocab_size, bias=False)
self.overlap_lambda = overlap_lambda
self.post_init()
def get_output_embeddings(self):
return self.lm_head
def set_output_embeddings(self, new_embeddings):
self.lm_head = new_embeddings
def forward(
self,
input_ids=None,
past_key_values=None,
cache_position=None,
attention_mask=None,
token_type_ids=None,
position_ids=None,
inputs_embeds=None,
labels=None,
use_cache=None,
output_attentions=None,
output_hidden_states=None,
return_dict=None,
**kwargs,
):
return_dict = return_dict if return_dict is not None else self.config.use_return_dict
transformer_outputs = self.transformer(
input_ids,
past_key_values=past_key_values,
cache_position=cache_position,
attention_mask=attention_mask,
token_type_ids=token_type_ids,
position_ids=position_ids,
inputs_embeds=inputs_embeds,
use_cache=use_cache,
output_attentions=output_attentions,
output_hidden_states=output_hidden_states,
return_dict=return_dict,
)
hidden_states = transformer_outputs[0]
logits = self.lm_head(hidden_states)
loss = None
if labels is not None:
shift_logits = logits[..., :-1, :].contiguous().view(-1, logits.size(-1))
shift_labels = labels[..., 1:].contiguous().view(-1)
loss_fct = nn.CrossEntropyLoss()
loss = loss_fct(shift_logits, shift_labels)
if self.overlap_lambda != 0:
overlap_var = overlap_reg_var(self.lm_head.weight)
loss = loss + self.overlap_lambda * overlap_var
if not return_dict:
output = (logits,) + transformer_outputs[1:]
return ((loss,) + output) if loss is not None else output
return CausalLMOutputWithCrossAttentions(
loss=loss,
logits=logits,
past_key_values=transformer_outputs.past_key_values,
hidden_states=transformer_outputs.hidden_states,
attentions=transformer_outputs.attentions,
)
|