# sentence piece model from gguf

> Source: <https://gist.github.com/veryfadly588-afk/1d11d3e77ddef6bd905f55d2679882e6>
> Published: 2026-09-07 15:11:18+00:00



``` python
from gguf.gguf_reader import GGUFReader
python
def get_string_array_field(gguf_reader: GGUFReader, key: str):
    f = gguf_reader.get_field(key)
    return [bytes(f.parts[d]).decode("utf-8") for d in f.data]

def get_field(gguf_reader: GGUFReader, key: str):
    f = gguf_reader.get_field(key)
    if f is None:
        return 0
    if len(f.data) != 1:
        raise NotImplementedError(f"multiple data is not supported")
    part = f.parts[f.data[0]]
    if len(part) != 1:
        raise NotImplementedError(f"multiple parts are not supported")
    value = part[0]
    if isinstance(value, np.float32):
        return float(value)
    elif isinstance(value, np.uint32):
        return int(value)
    return value
gguf_path = "/path/to/mistral-7b-v0.1.Q6_K.gguf"
gguf_reader = GGUFReader(str(gguf_path))
tokens = get_string_array_field(gguf_reader, "tokenizer.ggml.tokens")
# merges = get_string_array_field(gguf_reader, "tokenizer.ggml.merges")
# merges = [tuple(m.split(" ")) for m in merges]
scores = [p.item() for p in gguf_reader.get_field("tokenizer.ggml.scores").parts[5:]]  #  why 5!?
token_types = [p.item() for p in gguf_reader.get_field("tokenizer.ggml.token_type").parts[5:]]
python
import sentencepiece as spm
python
import sentencepiece.sentencepiece_model_pb2 as model
normalizer_spec = model.NormalizerSpec(
    name="identity",
    precompiled_charsmap=b"",
    add_dummy_prefix=True,
    remove_extra_whitespaces=False,
    normalization_rule_tsv=b"",
)
trainer_spec = model.TrainerSpec(
  model_type="BPE",
  vocab_size=32000,
  input_format="text",
  split_by_unicode_script=True,
  split_by_whitespace=True,
  split_by_number=True,
  treat_whitespace_as_suffix=False,
  split_digits=True,
  allow_whitespace_only_pieces=True,
  vocabulary_output_piece_score=True,
  byte_fallback=True,
  unk_id=0,
  bos_id=1,
  eos_id=2,
  pad_id=-1,
  unk_piece="<unk>",
  bos_piece="<s>",
  eos_piece="</s>",
  pad_piece="<pad>",
  pretokenization_delimiter="",
)
m = model.ModelProto(trainer_spec=trainer_spec, normalizer_spec=normalizer_spec)
for token, score, token_type in zip(tokens, scores, token_types):
    m.pieces.append(model.ModelProto.SentencePiece(piece=token, score=score, type=token_type))
tokenizer = spm.SentencePieceProcessor(model_proto=m.SerializeToString())
tokenizer.encode("how tall is obama")
[910, 9369, 349, 818, 2786]
tokenizer.decode([910, 9369, 349, 818, 2786])
'how tall is obama'
tokenizer.id_to_piece(910)
'▁how'
```