Upload w4 quantized checkpoint

.ms_upload_cache

@@ -0,0 +1 @@
+{"version": 3, "repo_id": "Hakureirm/rwkv7-g1-1.5b-w4gptq", "files": {"README.md|1783059674.9222023|1327": {"hash": "7f30e8b5d39e6a92928306ce5cc6ff5711fb92a838e5bec775389c81c8121f63", "size": 1327, "status": "c"}, "config.json|1782932188.1250534|710": {"hash": "2dba5c444c3e24b4fd534b62681ea066222272258824e7edfbce4b29e48eb4d0", "size": 710, "status": "c"}, "hf_rwkv_tokenizer.py|1782876484.9366663|9420": {"hash": "aaca5e6a0f56d043ca1654e9dcaf906fcf3c0e03b5172863ad75060e8685a10e", "size": 9420, "status": "c"}, "special_tokens_map.json|1782876596.6262796|198": {"hash": "6c67f3d0cfe9c8eadd1e22068ba52f207b02901e6a991369e2c600845e66478f", "size": 198, "status": "c"}, "tokenizer_config.json|1782876596.6262796|1126": {"hash": "79928b9e809faa8d992975476b8d09d335a300a66754d651d2ecc4a849a986f0", "size": 1126, "status": "c"}, "rwkv_vocab_v20230424.txt|1782876484.9366663|1093733": {"hash": "e6dee3d4e31b4d5c40ac99508ac6c701ceef4bed681bf2167ce9a908552bca89", "size": 1093733, "status": "c"}, "model.safetensors|1782932188.1170533|1280718296": {"hash": "db885ede508ab1def39160b090c680437f411d2c177b03426bffa9df666b7917", "size": 1280718296, "status": "c"}}}

README.md

@@ -0,0 +1,29 @@
+---
+license: apache-2.0
+frameworks: [pytorch]
+tasks: [text-generation]
+base_model: [BlinkDL/rwkv7-g1]
+---
+
+# RWKV-7 G1 1.5B — int4 GPTQ for rwkv-sglang
+
+Hand-written **weight-only int4** (GPTQ-calibrated) quantization of BlinkDL's RWKV-7 "Goose"
+G1 1.5B, for the [rwkv-sglang](https://github.com/Hakureirm/rwkv-sglang) serving overlay.
+
+- **Accuracy:** GPTQ (wikitext-calibrated) lambada 0.639 vs 0.672 fp16 (−3.34pt), recovering
+  +1.6pt over calibration-free RTN; kernel output is bit-identical to the offline dequant.
+- **Speed:** faster than fp16 at every batch size ≤ 32 on an RTX 3090 (1.03–1.56× decode),
+  via a hand-written int4 GEMV / small-M GEMM / tensor-core GEMM family (JIT, Turing→Blackwell).
+- **VRAM:** checkpoint 1.2 GB vs 2.9 GB fp16 (~2.4×); serve VRAM −950 MiB at bsz1.
+
+## Format & loading (important)
+Not a drop-in HuggingFace checkpoint. Weights are group-wise (GROUP=64) symmetric int4
+(`.qweight` + `.scale`); they load **only** through the rwkv-sglang overlay:
+
+```bash
+bash scripts/deploy.sh   # from github.com/Hakureirm/rwkv-sglang, onto sglang v0.5.10.post1
+RWKV_W4=1 python -m sglang.launch_server --model-path <this-dir> --dtype float16 \
+  --trust-remote-code --disable-radix-cache
+```
+
+LoRA/norm/embedding/head stay full precision. Base model © BlinkDL (Bo Peng), Apache-2.0.

config.json

@@ -0,0 +1,34 @@
+{
+  "architectures": [
+    "RWKV7ForCausalLM"
+  ],
+  "model_type": "rwkv7",
+  "hidden_size": 2048,
+  "num_hidden_layers": 24,
+  "head_dim": 64,
+  "num_heads": 32,
+  "decay_low_rank_dim": 96,
+  "a_low_rank_dim": 96,
+  "v_low_rank_dim": 64,
+  "gate_low_rank_dim": 256,
+  "intermediate_size": 8192,
+  "hidden_ratio": 4.0,
+  "hidden_act": "sqrelu",
+  "norm_eps": 1e-05,
+  "norm_bias": true,
+  "norm_first": true,
+  "vocab_size": 65536,
+  "tie_word_embeddings": false,
+  "attn": null,
+  "attn_mode": "chunk",
+  "bos_token_id": 0,
+  "eos_token_id": 0,
+  "use_cache": true,
+  "torch_dtype": "float32",
+  "rwkv7_w4_info": {
+    "quant_method": "rwkv_w4_gptq",
+    "group_size": 64,
+    "bits": 4,
+    "sym": true
+  }
+}

hf_rwkv_tokenizer.py

@@ -0,0 +1,279 @@
+# coding=utf-8
+# Copyright 2024 The HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Tokenization classes for RWKV."""
+
+import os
+import re
+from typing import TYPE_CHECKING, List, Optional, Tuple
+
+from transformers.tokenization_utils import AddedToken, PreTrainedTokenizer
+from transformers.utils import logging
+
+
+if TYPE_CHECKING:
+    pass
+
+logger = logging.get_logger(__name__)
+
+
+VOCAB_FILES_NAMES = {
+    "vocab_file": "rwkv_vocab_v20230424.txt",
+}
+
+class TRIE:
+    __slots__ = tuple("ch,to,values,front".split(","))
+    to: list
+    values: set
+
+    def __init__(self, front=None, ch=None):
+        self.ch = ch
+        self.to = [None for ch in range(256)]
+        self.values = set()
+        self.front = front
+
+    def __repr__(self):
+        fr = self
+        ret = []
+        while fr != None:
+            if fr.ch != None:
+                ret.append(fr.ch)
+            fr = fr.front
+        return "<TRIE %s %s>" % (ret[::-1], self.values)
+
+    def add(self, key: bytes, idx: int = 0, val=None):
+        if idx == len(key):
+            if val is None:
+                val = key
+            self.values.add(val)
+            return self
+        ch = key[idx]
+        if self.to[ch] is None:
+            self.to[ch] = TRIE(front=self, ch=ch)
+        return self.to[ch].add(key, idx=idx + 1, val=val)
+
+    def find_longest(self, key: bytes, idx: int = 0):
+        u: TRIE = self
+        ch: int = key[idx]
+
+        while u.to[ch] is not None:
+            u = u.to[ch]
+            idx += 1
+            if u.values:
+                ret = idx, u, u.values
+            if idx == len(key):
+                break
+            ch = key[idx]
+        return ret
+
+
+class RWKV_TOKENIZER:
+    def __init__(self, file_name):
+        self.idx2token = {}
+        sorted = []  # must be already sorted
+        with open(file_name, "r", encoding="utf-8") as f:
+            lines = f.readlines()
+        for l in lines:
+            idx = int(l[: l.index(" ")])
+            x = eval(l[l.index(" ") : l.rindex(" ")])
+            x = x.encode("utf-8") if isinstance(x, str) else x
+            assert isinstance(x, bytes)
+
+            assert len(x) == int(l[l.rindex(" ") :])
+            sorted += [x]
+            self.idx2token[idx] = x
+
+        self.token2idx = {}
+        for k, v in self.idx2token.items():
+            self.token2idx[v] = int(k)
+
+        self.root = TRIE()
+        for t, i in self.token2idx.items():
+            _ = self.root.add(t, val=(t, i))
+
+    def encodeBytes(self, src: bytes):
+        idx: int = 0
+        tokens = []
+        while idx < len(src):
+            _idx: int = idx
+            idx, _, values = self.root.find_longest(src, idx)
+            assert idx != _idx
+            _, token = next(iter(values))
+            tokens.append(token)
+        return tokens
+
+    def decodeBytes(self, tokens):
+        return b"".join(map(lambda i: self.idx2token[i], tokens))
+
+    def encode(self, src):
+        if isinstance(src, str):
+            return [self.encodeBytes(src.encode("utf-8"))]
+        elif isinstance(src, list):
+            return [self.encodeBytes(s.encode("utf-8")) for s in src]
+
+    def decode(self, tokens):
+        return [self.decodeBytes(batch).decode("utf-8") for batch in tokens]
+        # try:
+        #     return self.decodeBytes(tokens).decode('utf-8')
+        # except:
+        #     return '\ufffd' # bad utf-8
+
+    def printTokens(self, tokens):
+        for i in tokens:
+            s = self.idx2token[i]
+            try:
+                s = s.decode("utf-8")
+            except:
+                pass
+            print(f"{repr(s)}{i}", end=" ")
+        print()
+
+
+class RwkvTokenizer(PreTrainedTokenizer):
+    vocab_files_names = VOCAB_FILES_NAMES
+    model_input_names = ["input_ids", "attention_mask"]
+
+    def __init__(
+        self, vocab_file, bos_token="<|rwkv_tokenizer_end_of_text|>", eos_token="<|rwkv_tokenizer_end_of_text|>", unk_token="<|rwkv_tokenizer_end_of_text|>", **kwargs
+    ):
+        if not os.path.isfile(vocab_file):
+            raise ValueError(
+                f"Can't find a vocabulary file at path '{vocab_file}'."
+            )
+
+        with open(vocab_file, "r", encoding="utf-8") as reader:
+            tokens = reader.readlines()
+
+        if "add_bos_token" in kwargs:
+            self.add_bos_token = kwargs["add_bos_token"]
+        else:
+            self.add_bos_token = False
+        self.trie_tokenizer = RWKV_TOKENIZER(vocab_file)
+        vocab = self.trie_tokenizer.token2idx
+        self.encoder = vocab
+        self.decoder = {v: k for k, v in vocab.items()}
+        self._added_tokens_decoder = {0: AddedToken(str(bos_token))}
+        super().__init__(
+            bos_token=bos_token, eos_token=eos_token, unk_token=unk_token, **kwargs
+        )
+
+    @property
+    def vocab_size(self):
+        return len(self.encoder)
+
+    def get_vocab(self):
+        vocab = self.encoder
+        vocab.update(self.added_tokens_encoder)
+        vocab = dict(sorted(vocab.items(), key=lambda item: item[1]))
+        return vocab
+
+    def _tokenize(self, text, split_special_tokens=False):
+        # return self.wordpiece_tokenizer.tokenize(text.encode("utf-8"))
+        return self.trie_tokenizer.encode(text)[0]
+
+    def _convert_token_to_id(self, token):
+        return token
+
+    def _convert_id_to_token(self, index):
+        """Converts an index (integer) in a token (byte) using the vocab."""
+        token = self.decoder.get(index, self.unk_token)
+        if isinstance(token, (bytes)):
+            token = token.decode("utf-8", errors="replace")
+        return token
+
+    def convert_tokens_to_string(self, tokens):
+        """Converts a sequence of tokens (bytes) in a single string. Additional tokens are encoded to bytes"""
+        out_string = b"".join(
+            [k.encode(errors="replace") if isinstance(k, str) else k for k in tokens]
+        ).decode("utf-8")
+        return out_string
+
+    def save_vocabulary(
+        self, save_directory: str, filename_prefix: Optional[str] = None
+    ) -> Tuple[str]:
+        index = 0
+        if os.path.isdir(save_directory):
+            vocab_file = os.path.join(
+                save_directory,
+                (filename_prefix + "-" if filename_prefix else "") + "vocab.txt",
+            )
+        else:
+            vocab_file = (
+                filename_prefix + "-" if filename_prefix else ""
+            ) + save_directory
+        with open(vocab_file, "w", encoding="utf-8") as writer:
+            for token, token_index in sorted(
+                self.encoder.items(), key=lambda kv: kv[1]
+            ):
+                if index != token_index:
+                    logger.warning(
+                        f"Saving vocabulary to {vocab_file}: vocabulary indices are not consecutive."
+                        " Please check that the vocabulary is not corrupted!"
+                    )
+                    index = token_index
+                writer.write(str(token) + "\n")
+                index += 1
+        return (vocab_file,)
+
+    def build_inputs_with_special_tokens(self, token_ids_0, token_ids_1=None):
+        if self.add_bos_token:
+            bos_token_ids = [self.bos_token_id]
+        else:
+            bos_token_ids = []
+
+        output = bos_token_ids + token_ids_0
+
+        if token_ids_1 is None:
+            return output
+
+        return output + bos_token_ids + token_ids_1
+
+    def get_special_tokens_mask(
+        self,
+        token_ids_0: List[int],
+        token_ids_1: Optional[List[int]] = None,
+        already_has_special_tokens: bool = False,
+    ) -> List[int]:
+        """
+        Retrieves sequence ids from a token list that has no special tokens added. This method is called when adding
+        special tokens using the tokenizer `prepare_for_model` or `encode_plus` methods.
+
+        Args:
+            token_ids_0 (`List[int]`):
+                List of IDs.
+            token_ids_1 (`List[int]`, *optional*):
+                Optional second list of IDs for sequence pairs.
+            already_has_special_tokens (`bool`, *optional*, defaults to `False`):
+                Whether or not the token list is already formatted with special tokens for the model.
+
+        Returns:
+            `List[int]`: A list of integers in the range [0, 1]: 1 for a special token, 0 for a sequence token.
+        """
+        if already_has_special_tokens:
+            return super().get_special_tokens_mask(
+                token_ids_0=token_ids_0,
+                token_ids_1=token_ids_1,
+                already_has_special_tokens=True,
+            )
+
+        if not self.add_bos_token:
+            return super().get_special_tokens_mask(
+                token_ids_0=token_ids_0,
+                token_ids_1=token_ids_1,
+                already_has_special_tokens=False,
+            )
+
+        if token_ids_1 is None:
+            return [1] + ([0] * len(token_ids_0))
+        return [1] + ([0] * len(token_ids_0)) + [1] + ([0] * len(token_ids_1))

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:db885ede508ab1def39160b090c680437f411d2c177b03426bffa9df666b7917
+size 1280718296

special_tokens_map.json

@@ -0,0 +1,6 @@
+{
+  "bos_token": "<|rwkv_tokenizer_end_of_text|>",
+  "eos_token": "<|rwkv_tokenizer_end_of_text|>",
+  "unk_token": "<|rwkv_tokenizer_end_of_text|>",
+  "pad_token": "<|rwkv_tokenizer_end_of_text|>"
+}

tokenizer_config.json

@@ -0,0 +1,28 @@
+{
+  "add_prefix_space": false,
+  "added_tokens_decoder": {
+    "0": {
+      "content": "<|rwkv_tokenizer_end_of_text|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "auto_map": {
+    "AutoTokenizer": [
+      "hf_rwkv_tokenizer.RwkvTokenizer",
+      null
+    ]
+  },
+  "bos_token": "<|rwkv_tokenizer_end_of_text|>",
+  "pad_token": "<|rwkv_tokenizer_end_of_text|>",
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|rwkv_tokenizer_end_of_text|>",
+  "model_max_length": 1000000000000000019884624838656,
+  "tokenizer_class": "RwkvTokenizer",
+  "unk_token": "<|rwkv_tokenizer_end_of_text|>",
+  "use_fast": false,
+  "chat_template": "{{ '<|rwkv_tokenizer_end_of_text|>' }}{% for message in messages %}{% if message['role'] == 'user' %}{{'User: ' + message['content'] + '\n\n'}}{% elif message['role'] == 'system' %}{{'System: ' + message['content'] + '\n\n'}}{% elif message['role'] == 'assistant' %}{{'Assistant: ' + message['content'] + '\n\n'}}{% endif %}{% endfor %}{% if add_generation_prompt %}{{ 'Assistant:' }}{% endif %}"
+}