Felipe97/llama-cpp-compiled

1from __future__ import annotations2 3from typing import Iterable, TYPE_CHECKING4 5import torch6 7if TYPE_CHECKING:8    from torch import Tensor9 10from .base import ModelBase, TextModel, gguf11 12 13@ModelBase.register("LLaDAModelLM")14@ModelBase.example("GSAI-ML/LLaDA-8B-Instruct")15class LLaDAModel(TextModel):16    model_arch = gguf.MODEL_ARCH.LLADA17    undo_permute = True18 19    def get_vocab_base(self) -> tuple[list[str], list[int], str]:20        tokens: list[str] = []21        toktypes: list[int] = []22 23        from transformers import AutoTokenizer24        tokenizer = AutoTokenizer.from_pretrained(self.dir_model, trust_remote_code=True)25 26        vocab_dict = tokenizer.get_vocab()  # ty: ignore[unresolved-attribute]27        vocab_size = self.hparams.get("vocab_size", len(vocab_dict))28        assert max(vocab_dict.values()) < vocab_size29 30        tokpre = self.get_vocab_base_pre(tokenizer)31 32        reverse_vocab = {id_: encoded_tok for encoded_tok, id_ in vocab_dict.items()}33        added_vocab = tokenizer.get_added_vocab()  # ty: ignore[unresolved-attribute]34 35        for i in range(vocab_size):36            if i not in reverse_vocab:37                tokens.append(f"[PAD{i}]")38                toktypes.append(gguf.TokenType.UNUSED)39            elif reverse_vocab[i] in added_vocab:40                tokens.append(reverse_vocab[i])41                # Check if it's a special token - treat special tokens as CONTROL tokens42                if hasattr(tokenizer, 'added_tokens_decoder') and i in tokenizer.added_tokens_decoder:43                    if tokenizer.added_tokens_decoder[i].special:44                        toktypes.append(gguf.TokenType.CONTROL)45                    else:46                        toktypes.append(gguf.TokenType.USER_DEFINED)47                else:48                    # Fallback: treat all added vocab as control tokens for special tokens like <|im_start|>49                    toktypes.append(gguf.TokenType.CONTROL)50            else:51                tokens.append(reverse_vocab[i])52                toktypes.append(gguf.TokenType.NORMAL)53 54        return tokens, toktypes, tokpre55 56    def set_vocab(self):57        self._set_vocab_gpt2()58 59        # LLaDA specific parameters60        self.gguf_writer.add_add_bos_token(True)61 62    def set_gguf_parameters(self):63        super().set_gguf_parameters()64        self._try_set_pooling_type()65 66        # Add parameters similar to LlamaModel67        hparams = self.hparams68        self.gguf_writer.add_vocab_size(hparams["vocab_size"])69 70        if (rope_dim := hparams.get("head_dim")) is None:71            n_heads = hparams.get("num_attention_heads", hparams.get("n_heads"))72            assert n_heads is not None73            rope_dim = hparams.get("hidden_size", hparams.get("d_model")) // n_heads74        self.gguf_writer.add_rope_dimension_count(rope_dim)75 76        # Set context length for LLaDA77        context_length = self.hparams.get("max_sequence_length", 4096)78        self.gguf_writer.add_context_length(context_length)79 80        # Set embedding length (dimension size)81        embedding_length = self.hparams.get("d_model", 4096)82        self.gguf_writer.add_embedding_length(embedding_length)83 84        # Set feed forward length (MLP hidden size)85        feed_forward_length = self.hparams.get("mlp_hidden_size", 12288)86        self.gguf_writer.add_feed_forward_length(feed_forward_length)87 88        # LLaDA models use non-causal attention for diffusion, similar to Dream89        self.gguf_writer.add_causal_attention(False)90 91        # LLaDA models don't shift their logits92        self.gguf_writer.add_diffusion_shift_logits(False)93 94    @staticmethod95    def permute(weights: Tensor, n_head: int, n_head_kv: int | None):96        if n_head_kv is not None and n_head != n_head_kv:97            n_head = n_head_kv98        return (weights.reshape(n_head, 2, weights.shape[0] // n_head // 2, *weights.shape[1:])99                .swapaxes(1, 2)100                .reshape(weights.shape))101 102    def modify_tensors(self, data_torch: Tensor, name: str, bid: int | None) -> Iterable[tuple[str, Tensor]]:103        n_head = self.hparams.get("num_attention_heads", self.hparams.get("n_heads"))104        assert n_head is not None105        n_kv_head = self.hparams.get("num_key_value_heads", self.hparams.get("n_kv_heads"))106 107        if self.undo_permute:108            if name.endswith(("q_proj.weight", "q_proj.bias")):109                data_torch = LLaDAModel.permute(data_torch, n_head, n_head)110            if name.endswith(("k_proj.weight", "k_proj.bias")):111                data_torch = LLaDAModel.permute(data_torch, n_head, n_kv_head)112 113        # LLaDA model tensors should be mapped directly since it's the base model114        yield from super().modify_tensors(data_torch, name, bid)115 116 117@ModelBase.register("LLaDAMoEModel", "LLaDAMoEModelLM")118@ModelBase.example("inclusionAI/LLaDA-MoE-7B-A1B-Instruct")119class LLaDAMoEModel(TextModel):120    model_arch = gguf.MODEL_ARCH.LLADA_MOE121 122    def set_gguf_parameters(self):123        super().set_gguf_parameters()124        if (expert_intermediate_size := self.hparams.get("expert_intermediate_size")) is not None:125            self.gguf_writer.add_expert_feed_forward_length(expert_intermediate_size)126 127        self.gguf_writer.add_mask_token_id(156895)128        self.gguf_writer.add_causal_attention(False)129        self.gguf_writer.add_diffusion_shift_logits(False)130 131    _experts: list[dict[str, Tensor]] | None = None132 133    # Copied from: Qwen2MoeModel134    def modify_tensors(self, data_torch: Tensor, name: str, bid: int | None) -> Iterable[tuple[str, Tensor]]:135        # process the experts separately136        if name.find("experts") != -1:137            n_experts = self.find_hparam(["num_local_experts", "num_experts"])138            assert bid is not None139 140            if self._experts is None:141                self._experts = [{} for _ in range(self.block_count)]142 143            self._experts[bid][name] = data_torch144 145            if len(self._experts[bid]) >= n_experts * 3:146                # merge the experts into a single 3d tensor147                for w_name in ["down_proj", "gate_proj", "up_proj"]:148                    datas: list[Tensor] = []149 150                    for xid in range(n_experts):151                        ename = f"model.layers.{bid}.mlp.experts.{xid}.{w_name}.weight"152                        datas.append(self._experts[bid][ename])153                        del self._experts[bid][ename]154 155                    data_torch = torch.stack(datas, dim=0)156 157                    merged_name = f"model.layers.{bid}.mlp.experts.{w_name}.weight"158 159                    yield from super().modify_tensors(data_torch, merged_name, bid)160                return161            else:162                return163 164        yield from super().modify_tensors(data_torch, name, bid)165 166    # Copied from: Qwen2MoeModel167    def prepare_tensors(self):168        super().prepare_tensors()169 170        if self._experts is not None:171            # flatten `list[dict[str, Tensor]]` into `list[str]`172            experts = [k for d in self._experts for k in d.keys()]173            if len(experts) > 0:174                raise ValueError(f"Unprocessed experts: {experts}")175