char-fork/llama.cpp

git clone https://git.t4t.associates/char-fork/llama.cpp

Xuan-Son Nguyenconvert: add @ModelBase.example (#27208)fa88ae936

char/aliceai-t5-moe
brancheschar/aliceai-t5-moeall refs →
7.0 KiB174 linesraw
1from __future__ import annotations
2
3from typing import Iterable, TYPE_CHECKING
4
5import torch
6
7if TYPE_CHECKING:
8    from torch import Tensor
9
10from .base import ModelBase, TextModel, gguf
11
12
13@ModelBase.register("LLaDAModelLM")
14@ModelBase.example("GSAI-ML/LLaDA-8B-Instruct")
15class LLaDAModel(TextModel):
16    model_arch = gguf.MODEL_ARCH.LLADA
17    undo_permute = True
18
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 AutoTokenizer
24        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_size
29
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 tokens
42                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, tokpre
55
56    def set_vocab(self):
57        self._set_vocab_gpt2()
58
59        # LLaDA specific parameters
60        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 LlamaModel
67        hparams = self.hparams
68        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 None
73            rope_dim = hparams.get("hidden_size", hparams.get("d_model")) // n_heads
74        self.gguf_writer.add_rope_dimension_count(rope_dim)
75
76        # Set context length for LLaDA
77        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 Dream
89        self.gguf_writer.add_causal_attention(False)
90
91        # LLaDA models don't shift their logits
92        self.gguf_writer.add_diffusion_shift_logits(False)
93
94    @staticmethod
95    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_kv
98        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 None
105        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 model
114        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_MOE
121
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 = None
132
133    # Copied from: Qwen2MoeModel
134    def modify_tensors(self, data_torch: Tensor, name: str, bid: int | None) -> Iterable[tuple[str, Tensor]]:
135        # process the experts separately
136        if name.find("experts") != -1:
137            n_experts = self.find_hparam(["num_local_experts", "num_experts"])
138            assert bid is not None
139
140            if self._experts is None:
141                self._experts = [{} for _ in range(self.block_count)]
142
143            self._experts[bid][name] = data_torch
144
145            if len(self._experts[bid]) >= n_experts * 3:
146                # merge the experts into a single 3d tensor
147                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                return
161            else:
162                return
163
164        yield from super().modify_tensors(data_torch, name, bid)
165
166    # Copied from: Qwen2MoeModel
167    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}")