mirror of
https://github.com/ggml-org/llama.cpp.git
synced 2026-08-04 00:50:47 -05:00
95 lines
3.6 KiB
Python
95 lines
3.6 KiB
Python
from __future__ import annotations
|
|
|
|
from typing import TYPE_CHECKING
|
|
|
|
import torch
|
|
|
|
if TYPE_CHECKING:
|
|
from torch import Tensor
|
|
|
|
from .base import ModelBase, TextModel, gguf
|
|
|
|
|
|
@ModelBase.register("MiniMaxM2ForCausalLM")
|
|
class MiniMaxM2Model(TextModel):
|
|
model_arch = gguf.MODEL_ARCH.MINIMAXM2
|
|
_experts_cache: dict[int, dict[str, Tensor]] = {}
|
|
|
|
def set_gguf_parameters(self):
|
|
super().set_gguf_parameters()
|
|
|
|
self.gguf_writer.add_expert_feed_forward_length(self.find_hparam(["intermediate_size"]))
|
|
self.gguf_writer.add_rope_dimension_count(self.find_hparam(["rotary_dim"]))
|
|
|
|
def modify_tensors(self, data_torch: Tensor, name: str, bid: int | None):
|
|
# merge expert weights
|
|
if "block_sparse_moe.experts." in name:
|
|
n_experts = self.find_hparam(["num_local_experts", "num_experts"])
|
|
assert bid is not None
|
|
|
|
expert_cache = self._experts_cache.setdefault(bid, {})
|
|
expert_cache[name] = data_torch
|
|
expert_weights = ["w1", "w2", "w3"]
|
|
|
|
# not enough expert weights to merge
|
|
if len(expert_cache) < n_experts * len(expert_weights):
|
|
return
|
|
|
|
for w_name in expert_weights:
|
|
datas: list[Tensor] = []
|
|
|
|
for xid in range(n_experts):
|
|
ename = f"model.layers.{bid}.block_sparse_moe.experts.{xid}.{w_name}.weight"
|
|
datas.append(expert_cache[ename])
|
|
del expert_cache[ename]
|
|
|
|
data_torch = torch.stack(datas, dim=0)
|
|
merged_name = f"model.layers.{bid}.block_sparse_moe.experts.{w_name}.weight"
|
|
new_name = self.map_tensor_name(merged_name)
|
|
yield from super().modify_tensors(data_torch, new_name, bid)
|
|
|
|
del self._experts_cache[bid]
|
|
return
|
|
|
|
yield from super().modify_tensors(data_torch, name, bid)
|
|
|
|
|
|
@ModelBase.register("MiniMaxM3SparseForCausalLM", "MiniMaxM3SparseForConditionalGeneration")
|
|
class MiniMaxM3Model(MiniMaxM2Model):
|
|
model_arch = gguf.MODEL_ARCH.MINIMAXM3
|
|
|
|
def tensor_force_quant(self, name, new_name, bid, n_dims):
|
|
if ".indexer." in new_name:
|
|
return gguf.GGMLQuantizationType.F32
|
|
return super().tensor_force_quant(name, new_name, bid, n_dims)
|
|
|
|
def set_gguf_parameters(self):
|
|
super().set_gguf_parameters()
|
|
|
|
self.gguf_writer.add_expert_shared_count(self.find_hparam(["n_shared_experts"]))
|
|
self.gguf_writer.add_expert_weights_scale(self.find_hparam(["routed_scaling_factor"]))
|
|
self.gguf_writer.add_expert_weights_norm(True)
|
|
|
|
sac = self.find_hparam(["sparse_attention_config"])
|
|
self.gguf_writer.add_indexer_head_count(sac["sparse_num_index_heads"])
|
|
self.gguf_writer.add_indexer_key_length(sac["sparse_index_dim"])
|
|
self.gguf_writer.add_indexer_top_k(sac["sparse_topk_blocks"])
|
|
self.gguf_writer.add_indexer_block_size(sac["sparse_block_size"])
|
|
self.gguf_writer.add_indexer_local_blocks(sac["sparse_local_block"])
|
|
|
|
moe_layer_freq = self.find_hparam(["moe_layer_freq"])
|
|
n_dense = 0
|
|
for v in moe_layer_freq:
|
|
if v == 0:
|
|
n_dense += 1
|
|
else:
|
|
break
|
|
self.gguf_writer.add_leading_dense_block_count(n_dense)
|
|
|
|
def modify_tensors(self, data_torch: Tensor, name: str, bid: int | None):
|
|
# Gemma-style (1 + w) RMSNorm: bake the +1 in so llama.cpp can use plain RMSNorm
|
|
if name.endswith("norm.weight"):
|
|
data_torch = data_torch + 1.0
|
|
|
|
yield from super().modify_tensors(data_torch, name, bid)
|