char-fork/llama.cpp

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

Sigbjørn Skjæretci : bump ty to 0.0.78 (#28548)67672dc5b

char/aliceai-t5-moe
brancheschar/aliceai-t5-moeall refs →
12.0 KiB281 linesraw
1from __future__ import annotations
2
3from typing import Iterable, Sequence, TYPE_CHECKING
4
5import torch
6
7if TYPE_CHECKING:
8    from torch import Tensor
9
10from .base import ModelBase, TextModel, MmprojModel, gguf, logger
11
12
13@ModelBase.register("MiniMaxText01ForCausalLM")
14@ModelBase.register("MiniMaxM1ForCausalLM")
15@ModelBase.example("MiniMaxAI/MiniMax-Text-01", "MiniMaxAI/MiniMax-M1-40k")
16class MiniMaxText01Model(TextModel):
17    model_arch = gguf.MODEL_ARCH.MINIMAX01
18
19    def _get_suppress_tokens(self) -> Sequence[int] | None:
20        import json
21        from transformers import AutoTokenizer
22        from .base import LazyTorchTensor
23
24        # check added tokens embeddings in embeddings tensor for zero-valued embeddings
25        # they get in the way of the token sampling process and must be suppressed
26
27        tokenizer = AutoTokenizer.from_pretrained(self.dir_model, trust_remote_code=True)
28        tokenizer_vocab_size = tokenizer.vocab_size  # ty: ignore[unresolved-attribute]
29
30        with open(self.dir_model / "model.safetensors.index.json", "r", encoding="utf-8") as f:
31            weight_map = json.load(f)["weight_map"]
32
33        embeddings_tensor_name = "model.embed_tokens.weight"
34        embeddings_shard_name = weight_map[embeddings_tensor_name]
35        with gguf.utility.SafetensorsLocal(self.dir_model / embeddings_shard_name) as model_shard:
36            embeddings_data = model_shard[embeddings_tensor_name]
37
38        embeddings_weights_dtype = LazyTorchTensor._dtype_str_map[embeddings_data.dtype]
39        embeddings_weights = torch.from_numpy(embeddings_data.mmap_bytes()).view(embeddings_weights_dtype).reshape(embeddings_data.shape)
40        embeddings_vocab_size = embeddings_weights.shape[0]
41
42        embeddings_added_tokens = embeddings_weights[tokenizer_vocab_size:embeddings_vocab_size]
43        embeddings_zero_rows = torch.all(embeddings_added_tokens == 0, dim=1)
44        tokens_zero_embeddings_ids = (torch.nonzero(embeddings_zero_rows, as_tuple=False).flatten() + tokenizer_vocab_size).tolist()
45
46        return tokens_zero_embeddings_ids
47
48    def set_vocab(self) -> None:
49        from pathlib import Path
50
51        self._set_vocab_gpt2()
52
53        for tmpl_file in [
54            self.dir_model / "chat_template.jinja",
55            Path(__file__).parent.parent / "models" / "templates" / "MiniMax-M1.jinja"
56        ]:
57            if tmpl_file.is_file():
58                self.gguf_writer.add_chat_template(tmpl_file.read_text(encoding="utf-8"))
59                logger.info(f"Chat template overridden with {tmpl_file}.")
60                break
61
62    def set_gguf_parameters(self):
63        super().set_gguf_parameters()
64
65        suppress_tokens = self._get_suppress_tokens()
66        if suppress_tokens:
67            logger.info(f"Suppressing tokens with zero embeddings {suppress_tokens}")
68            self.gguf_writer.add_suppress_tokens(suppress_tokens)
69
70        layernorm_full_attention_alpha = self.hparams["layernorm_full_attention_alpha"]
71        layernorm_full_attention_beta = self.hparams["layernorm_full_attention_beta"]
72        layernorm_linear_attention_alpha = self.hparams["layernorm_linear_attention_alpha"]
73        layernorm_linear_attention_beta = self.hparams["layernorm_linear_attention_beta"]
74        layernorm_mlp_alpha = self.hparams["layernorm_mlp_alpha"]
75        layernorm_mlp_beta = self.hparams["layernorm_mlp_beta"]
76        assert layernorm_full_attention_alpha == layernorm_linear_attention_alpha == layernorm_mlp_alpha
77        assert layernorm_full_attention_beta == layernorm_linear_attention_beta == layernorm_mlp_beta == 1.0
78        # we do not store the layernorm betas as they are all 1.0
79        # layernorm alphas are stored as single residual_scale hparam
80        self.gguf_writer.add_residual_scale(layernorm_full_attention_alpha)
81
82        self.gguf_writer.add_rope_dimension_count(self.hparams["rotary_dim"])
83
84    _experts: list[dict[str, Tensor]] | None = None
85
86    def modify_tensors(self, data_torch: Tensor, name: str, bid: int | None) -> Iterable[tuple[str, Tensor]]:
87        # process the experts separately
88        if name.find("block_sparse_moe.experts") != -1:
89            n_experts = self.hparams["num_local_experts"]
90
91            assert bid is not None
92
93            if self._experts is None:
94                self._experts = [{} for _ in range(self.block_count)]
95
96            self._experts[bid][name] = data_torch
97
98            if len(self._experts[bid]) >= n_experts * 3:
99                # merge the experts into a single 3d tensor
100                for wid in ["w1", "w2", "w3"]:
101                    datas: list[Tensor] = []
102
103                    for xid in range(n_experts):
104                        ename = f"model.layers.{bid}.block_sparse_moe.experts.{xid}.{wid}.weight"
105                        datas.append(self._experts[bid][ename])
106                        del self._experts[bid][ename]
107
108                    data_torch = torch.stack(datas, dim=0)
109
110                    merged_name = f"layers.{bid}.feed_forward.experts.{wid}.weight"
111
112                    new_name = self.map_tensor_name(merged_name)
113
114                    yield from super().modify_tensors(data_torch, new_name, bid)
115                return
116            else:
117                return
118
119        yield from super().modify_tensors(data_torch, name, bid)
120
121
122@ModelBase.register("MiniMaxM2ForCausalLM")
123@ModelBase.example("MiniMaxAI/MiniMax-M2")
124class MiniMaxM2Model(TextModel):
125    model_arch = gguf.MODEL_ARCH.MINIMAXM2
126    _experts_cache: dict[int, dict[str, Tensor]] = {}
127
128    def set_gguf_parameters(self):
129        super().set_gguf_parameters()
130
131        self.gguf_writer.add_expert_feed_forward_length(self.find_hparam(["intermediate_size"]))
132        self.gguf_writer.add_rope_dimension_count(self.find_hparam(["rotary_dim"]))
133
134    def modify_tensors(self, data_torch: Tensor, name: str, bid: int | None):
135        # merge expert weights
136        if "block_sparse_moe.experts." in name:
137            n_experts = self.find_hparam(["num_local_experts", "num_experts"])
138            assert bid is not None
139
140            expert_cache = self._experts_cache.setdefault(bid, {})
141            expert_cache[name] = data_torch
142            expert_weights = ["w1", "w2", "w3"]
143
144            # not enough expert weights to merge
145            if len(expert_cache) < n_experts * len(expert_weights):
146                return
147
148            for w_name in expert_weights:
149                datas: list[Tensor] = []
150
151                for xid in range(n_experts):
152                    ename = f"model.layers.{bid}.block_sparse_moe.experts.{xid}.{w_name}.weight"
153                    datas.append(expert_cache[ename])
154                    del expert_cache[ename]
155
156                data_torch = torch.stack(datas, dim=0)
157                merged_name = f"model.layers.{bid}.block_sparse_moe.experts.{w_name}.weight"
158                new_name = self.map_tensor_name(merged_name)
159                yield from super().modify_tensors(data_torch, new_name, bid)
160
161            del self._experts_cache[bid]
162            return
163
164        yield from super().modify_tensors(data_torch, name, bid)
165
166
167@ModelBase.register("MiniMaxM3SparseForCausalLM", "MiniMaxM3SparseForConditionalGeneration")
168@ModelBase.example("MiniMaxAI/MiniMax-M3")
169class MiniMaxM3Model(MiniMaxM2Model):
170    model_arch = gguf.MODEL_ARCH.MINIMAXM3
171
172    def tensor_force_quant(self, name, new_name, bid, n_dims):
173        if ".indexer." in new_name:
174            return gguf.GGMLQuantizationType.F32
175        return super().tensor_force_quant(name, new_name, bid, n_dims)
176
177    def set_gguf_parameters(self):
178        super().set_gguf_parameters()
179
180        self.gguf_writer.add_expert_shared_count(self.find_hparam(["n_shared_experts"]))
181        self.gguf_writer.add_expert_weights_scale(self.find_hparam(["routed_scaling_factor"]))
182        self.gguf_writer.add_expert_weights_norm(True)
183
184        sac = self.find_hparam(["sparse_attention_config"])
185        self.gguf_writer.add_indexer_head_count(sac["sparse_num_index_heads"])
186        self.gguf_writer.add_indexer_key_length(sac["sparse_index_dim"])
187        self.gguf_writer.add_indexer_top_k(sac["sparse_topk_blocks"])
188        self.gguf_writer.add_indexer_block_size(sac["sparse_block_size"])
189        self.gguf_writer.add_indexer_local_blocks(sac["sparse_local_block"])
190
191        moe_layer_freq = self.find_hparam(["moe_layer_freq"])
192        n_dense = 0
193        for v in moe_layer_freq:
194            if v == 0:
195                n_dense += 1
196            else:
197                break
198        self.gguf_writer.add_leading_dense_block_count(n_dense)
199
200    def modify_tensors(self, data_torch: Tensor, name: str, bid: int | None):
201        # Gemma-style (1 + w) RMSNorm: bake the +1 in so llama.cpp can use plain RMSNorm
202        if name.endswith("norm.weight"):
203            data_torch = data_torch + 1.0
204
205        yield from super().modify_tensors(data_torch, name, bid)
206
207
208@ModelBase.register("MiniMaxM3SparseForConditionalGeneration", "MiniMaxM3VLForConditionalGeneration")
209@ModelBase.example("MiniMaxAI/MiniMax-M3")
210class MiniMaxM3VisionModel(MmprojModel):
211    @classmethod
212    def filter_tensors(cls, item):
213        name, gen = item
214        # keep only the vision-side tensors; text / mtp / sparse-index are dropped
215        if not name.startswith(("vision_tower.", "multi_modal_projector.", "patch_merge_mlp.")):
216            return None
217        return super().filter_tensors((name, gen))
218
219    def set_gguf_parameters(self):
220        super().set_gguf_parameters()
221        assert self.hparams_vision is not None
222
223        self.gguf_writer.add_clip_projector_type(gguf.VisionProjectorType.MINIMAXM3)
224        self.gguf_writer.add_vision_use_gelu(True)
225
226        # the ViT carries its own LayerNorm eps (text tower uses a different one)
227        self.gguf_writer.add_vision_attention_layernorm_eps(
228            self.hparams_vision.get("layer_norm_eps", 1e-5)
229        )
230
231        comp = self.hparams_vision.get("img_token_compression_config", {})
232        merge_size = comp.get("spatial_merge_size", 2)
233        self.gguf_writer.add_vision_spatial_merge_size(int(merge_size))
234
235    def modify_tensors(self, data_torch, name, bid):
236        assert self.hparams_vision is not None
237
238        # Conv3d patch embed -> Conv2d slices
239        if name == "vision_tower.vision_model.embeddings.patch_embedding.weight":
240            if data_torch.ndim != 5:
241                raise ValueError(f"unexpected patch_embedding rank {data_torch.ndim} for {name}")
242            kt = data_torch.shape[2]
243            base = gguf.TENSOR_NAMES[gguf.MODEL_TENSOR.V_ENC_EMBD_PATCH]
244            for t in range(kt):
245                suffix = ".weight" if t == 0 else f".weight.{t}"
246                yield (base + suffix, data_torch[:, :, t, ...])
247            return
248
249        # Permute ViT q/k. HF [Ta Ha Wa | Tb Hb Wb | pad] reorder to [Ta Tb | Ha Hb | Wa Wb | pad].
250        for new_name, tensor in super().modify_tensors(data_torch, name, bid):
251            if ".attn_q." in new_name or ".attn_k." in new_name:
252                tensor = self._permute_vit_qk(tensor, new_name)
253            yield new_name, tensor
254
255    def _permute_vit_qk(self, t: "Tensor", new_name: str) -> "Tensor":
256        assert self.hparams_vision is not None
257        n_head = self.hparams_vision["num_attention_heads"]
258        d_head = t.shape[0] // n_head
259        axis_dim = 2 * ((2 * (d_head // 2) // 3) // 2)
260        ah = axis_dim // 2
261        half = 3 * ah
262        perm = []
263        perm += list(range(0, ah))
264        perm += list(range(half, half + ah))
265        perm += list(range(ah, 2 * ah))
266        perm += list(range(half + ah, half + 2 * ah))
267        perm += list(range(2 * ah, 3 * ah))
268        perm += list(range(half + 2 * ah, half + 3 * ah))
269        perm += list(range(2 * half, d_head))
270
271        assert axis_dim % 2 == 0
272        assert 3 * axis_dim <= d_head
273        assert len(perm) == d_head
274        assert sorted(perm) == list(range(d_head)), "perm is not a bijection of d_head"
275        assert t.shape[0] == n_head * d_head, f"{new_name}: {t.shape[0]} != {n_head}*{d_head}"
276        assert d_head == 80
277
278        idx = torch.tensor(perm, dtype=torch.long)
279        if t.ndim == 2:
280            return t.reshape(n_head, d_head, t.shape[1])[:, idx, :].reshape(t.shape)
281        return t.reshape(n_head, d_head)[:, idx].reshape(t.shape)