modeling_pollock.py

"""Transformers implementation used to package Pollock SwiGLU checkpoints."""

import torch.nn as nn
import torch.nn.functional as F
from transformers import GPT2Config, GPT2LMHeadModel
from transformers.pytorch_utils import Conv1D


class PollockConfig(GPT2Config):
    model_type = "pollock"

    def __init__(self, mlp_variant="swiglu", **kwargs):
        super().__init__(**kwargs)
        self.mlp_variant = mlp_variant


class PollockSwiGLU(nn.Module):
    def __init__(self, config):
        super().__init__()
        n_inner = config.n_inner or 4 * config.hidden_size
        self.c_fc = Conv1D(2 * n_inner, config.hidden_size)
        self.c_proj = Conv1D(config.hidden_size, n_inner)
        self.dropout = nn.Dropout(config.resid_pdrop)

    def forward(self, hidden_states):
        gate, value = self.c_fc(hidden_states).chunk(2, dim=-1)
        hidden_states = F.silu(gate) * value
        return self.dropout(self.c_proj(hidden_states))


class PollockForCausalLM(GPT2LMHeadModel):
    config_class = PollockConfig

    def __init__(self, config):
        if config.mlp_variant != "swiglu":
            raise ValueError(
                f"PollockForCausalLM requires SwiGLU, got {config.mlp_variant!r}"
            )
        super().__init__(config)
        for block in self.transformer.h:
            block.mlp = PollockSwiGLU(config)
            block.mlp.apply(self._init_weights)