# 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, )