Upload folder using huggingface_hub

README.md

@@ -0,0 +1,70 @@
+---
+license: apache-2.0
+language:
+- en
+- zh
+metrics:
+- accuracy
+library_name: transformers
+pipeline_tag: question-answering
+tags:
+- llm
+- nanbeige
+---
+<div align="center">
+<h1>
+  Nanbeige2-16B-Chat
+</h1>
+</div>
+
+
+## <span id="Introduction">模型介绍（Introduction）</span>
+
+Nanbeige2-16B-Chat是南北阁实验室最新研发的160亿参数模型，在预训练中使用4.5T Tokens高质量语料。
+在对齐阶段，我们首先使用了100万条样本进行SFT训练，然后用40万高质量且难度较高的样本进行课程学习，再通过人类反馈DPO，得到Nanbeige2-16B-Chat。Nanbeige2-16B-Chat在各个权威测评数据集上都取得了较优的效果。
+
+
+The Nanbeige2-16B-Chat is the latest 16B model developed by the Nanbeige Lab, which utilized 4.5T tokens of high-quality training data during the training phase.
+During the alignment phase, we initially trained our model using 1 million samples through Supervised Fine-Tuning (SFT). We then engaged in curriculum learning with 400,000 high-quality samples that presented a greater level of difficulty. Subsequently, we incorporated human feedback through the Dynamic Policy Optimization (DPO), culminating in the development of Nanbeige2-16B-Chat. Nanbeige2-16B-Chat has achieved superior performance across various authoritative benchmark datasets.
+
+
+## <span id="Inference">模型推理（Inference）</span>
+
+```
+from transformers import AutoModelForCausalLM, AutoTokenizer
+tokenizer = AutoTokenizer.from_pretrained(
+  'Nanbeige/Nanbeige2-16B-Chat',
+  use_fast=False,
+  trust_remote_code=True
+)
+model = AutoModelForCausalLM.from_pretrained(
+  'Nanbeige/Nanbeige2-16B-Chat',
+  torch_dtype='auto',
+  device_map='auto',
+  trust_remote_code=True
+)
+messages = [
+  {'role': 'user', 'content': 'Hello'}
+]
+prompt = tokenizer.apply_chat_template(
+  messages,
+  add_generation_prompt=True,
+  tokenize=False
+)
+input_ids = tokenizer(prompt, add_special_tokens=False, return_tensors='pt').input_ids
+output_ids = model.generate(input_ids.to('cuda'))
+resp = tokenizer.decode(output_ids[0][len(input_ids[0]):], skip_special_tokens=True)
+print(resp)
+```
+
+## <span id="Limitations">局限性（Limitations）</span>
+
+虽然我们在训练过程中非常注重模型的安全性，力求确保其输出符合伦理和法律要求的文本，但由于模型大小和概率生成范式的限制，无法完全避免产生各种不符合预期的输出情况。这些输出可能包含偏见、歧视等有害内容，请勿传播这些内容。我们不承担因传播不良信息而导致的任何后果。
+
+While we place great emphasis on the safety of the model during the training process, striving to ensure that its outputs align with ethical and legal requirements, it may not completely avoid generating unexpected outputs due to the model's size and probabilistic nature. These outputs may include harmful content such as bias or discrimination. Please don't propagate such content. We do not assume any responsibility for the consequences resulting from the dissemination of inappropriate information.
+
+## <span id="License">协议（License）</span>
+
+使用 Nanbeige 模型时，您必须遵守 Apache 2.0 许可证和[《南北阁大语言模型许可协议》](https://huggingface.co/Nanbeige/Nanbeige-16B-Base-32k/resolve/main/南北阁大语言模型许可协议.pdf)。如果您打算将 Nanbeige 模型或其衍生产品用于商业目的，请通过以下联系邮箱 [email protected] 提交申请材料，以满足《南北阁大语言模型许可协议》的要求。经过审核后，我们将授予您非排他性、全球范围内、不可转让、不可再许可、可撤销的商业版权许可。
+
+When using the Nanbeige models, you must comply with the Apache 2.0 License and the [License Agreement for Large Language Models Nanbeige](https://huggingface.co/Nanbeige/Nanbeige-16B-Base-32k/resolve/main/License_Agreement_for_Large_Language_Models_Nanbeige.pdf). If you intend to use the Nanbeige Models or its derivatives for commercial purposes, please submit application materials to meet the requirements of the Nanbeige Models Community License Agreement by contacting [email protected]. After review, We will grant you a non-exclusive, worldwide, non-transferable, non-sublicensable and revocable commercial copyright license.

added_tokens.json

@@ -0,0 +1,5 @@
+{
+  "<|endoftext|>": 58980,
+  "<|im_end|>": 58979,
+  "<|im_start|>": 58978
+}

config.json

@@ -0,0 +1,44 @@
+{
+    "architectures": [
+        "NanbeigeForCausalLM"
+    ],
+    "auto_map": {
+        "AutoConfig": "configuration_nanbeige.NanbeigeConfig",
+        "AutoModelForCausalLM": "modeling_nanbeige.NanbeigeForCausalLM"
+    },
+    "attention_bias": false,
+    "attention_dropout": 0.0,
+    "bos_token_id": 1,
+    "eos_token_id": 58979,
+    "hidden_act": "silu",
+    "hidden_size": 5120,
+    "initializer_range": 0.02,
+    "intermediate_size": 13824,
+    "max_length": 4096,
+    "max_position_embeddings": 4096,
+    "model_type": "nanbeige",
+    "num_attention_heads": 40,
+    "num_hidden_layers": 48,
+    "num_key_value_heads": 40,
+    "pad_token_id": 0,
+    "pretraining_tp": 1,
+    "rms_norm_eps": 1e-05,
+    "rope_scaling": null,
+    "rope_theta": 10000.0,
+    "tie_word_embeddings": false,
+    "torch_dtype": "bfloat16",
+    "transformers_version": "4.38.0",
+    "use_cache": true,
+    "vocab_size": 59392,
+    "quantization_config": {
+        "quant_method": "exl2",
+        "version": "0.0.21",
+        "bits": 6.0,
+        "head_bits": 8,
+        "calibration": {
+            "rows": 100,
+            "length": 2048,
+            "dataset": "(default)"
+        }
+    }
+}

configuration_nanbeige.py

@@ -0,0 +1,53 @@
+# Copyright (c) 2023 Nanbeige LLM Lab All Rights Reserved.
+
+""" Nanbeige model configuration"""
+
+from transformers.configuration_utils import PretrainedConfig
+from transformers.utils import logging
+
+
+logger = logging.get_logger(__name__)
+
+NANBEIGE_PRETRAINED_CONFIG_ARCHIVE_MAP = {}
+
+
+class NanbeigeConfig(PretrainedConfig):
+    model_type = "nanbeige"
+
+    def __init__(
+        self,
+        vocab_size=32000,
+        hidden_size=4096,
+        intermediate_size=11008,
+        num_hidden_layers=32,
+        num_attention_heads=32,
+        hidden_act="silu",
+        max_position_embeddings=2048,
+        initializer_range=0.02,
+        rms_norm_eps=1e-6,
+        use_cache=True,
+        pad_token_id=0,
+        bos_token_id=1,
+        eos_token_id=2,
+        tie_word_embeddings=False,
+        yarn_scale=1.,
+        **kwargs,
+    ):
+        self.vocab_size = vocab_size
+        self.max_position_embeddings = max_position_embeddings
+        self.hidden_size = hidden_size
+        self.intermediate_size = intermediate_size
+        self.num_hidden_layers = num_hidden_layers
+        self.num_attention_heads = num_attention_heads
+        self.hidden_act = hidden_act
+        self.initializer_range = initializer_range
+        self.rms_norm_eps = rms_norm_eps
+        self.use_cache = use_cache
+        self.yarn_scale = yarn_scale
+        super().__init__(
+            pad_token_id=pad_token_id,
+            bos_token_id=bos_token_id,
+            eos_token_id=eos_token_id,
+            tie_word_embeddings=tie_word_embeddings,
+            **kwargs,
+        )

generation_config.json

@@ -0,0 +1,11 @@
+{
+  "_from_model_config": true,
+  "bos_token_id": 1,
+  "eos_token_id": 58979,
+  "max_length": 4096,
+  "pad_token_id": 0,
+  "do_sample": true,
+  "temperature": 0.3,
+  "top_p": 0.9,
+  "transformers_version": "4.38.0"
+}

model.safetensors.index.json

@@ -0,0 +1,442 @@
+{
+  "metadata": {
+    "total_size": 31667988480
+  },
+  "weight_map": {
+    "lm_head.weight": "model-00007-of-00007.safetensors",
+    "model.embed_tokens.weight": "model-00001-of-00007.safetensors",
+    "model.layers.0.input_layernorm.weight": "model-00001-of-00007.safetensors",
+    "model.layers.0.mlp.down_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.0.mlp.gate_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.0.mlp.up_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.0.post_attention_layernorm.weight": "model-00001-of-00007.safetensors",
+    "model.layers.0.self_attn.k_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.0.self_attn.o_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.0.self_attn.q_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.0.self_attn.v_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.1.input_layernorm.weight": "model-00001-of-00007.safetensors",
+    "model.layers.1.mlp.down_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.1.mlp.gate_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.1.mlp.up_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.1.post_attention_layernorm.weight": "model-00001-of-00007.safetensors",
+    "model.layers.1.self_attn.k_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.1.self_attn.o_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.1.self_attn.q_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.1.self_attn.v_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.10.input_layernorm.weight": "model-00002-of-00007.safetensors",
+    "model.layers.10.mlp.down_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.10.mlp.gate_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.10.mlp.up_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.10.post_attention_layernorm.weight": "model-00002-of-00007.safetensors",
+    "model.layers.10.self_attn.k_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.10.self_attn.o_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.10.self_attn.q_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.10.self_attn.v_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.11.input_layernorm.weight": "model-00002-of-00007.safetensors",
+    "model.layers.11.mlp.down_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.11.mlp.gate_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.11.mlp.up_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.11.post_attention_layernorm.weight": "model-00002-of-00007.safetensors",
+    "model.layers.11.self_attn.k_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.11.self_attn.o_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.11.self_attn.q_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.11.self_attn.v_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.12.input_layernorm.weight": "model-00002-of-00007.safetensors",
+    "model.layers.12.mlp.down_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.12.mlp.gate_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.12.mlp.up_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.12.post_attention_layernorm.weight": "model-00002-of-00007.safetensors",
+    "model.layers.12.self_attn.k_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.12.self_attn.o_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.12.self_attn.q_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.12.self_attn.v_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.13.input_layernorm.weight": "model-00002-of-00007.safetensors",
+    "model.layers.13.mlp.down_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.13.mlp.gate_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.13.mlp.up_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.13.post_attention_layernorm.weight": "model-00002-of-00007.safetensors",
+    "model.layers.13.self_attn.k_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.13.self_attn.o_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.13.self_attn.q_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.13.self_attn.v_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.14.input_layernorm.weight": "model-00003-of-00007.safetensors",
+    "model.layers.14.mlp.down_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.14.mlp.gate_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.14.mlp.up_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.14.post_attention_layernorm.weight": "model-00003-of-00007.safetensors",
+    "model.layers.14.self_attn.k_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.14.self_attn.o_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.14.self_attn.q_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.14.self_attn.v_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.15.input_layernorm.weight": "model-00003-of-00007.safetensors",
+    "model.layers.15.mlp.down_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.15.mlp.gate_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.15.mlp.up_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.15.post_attention_layernorm.weight": "model-00003-of-00007.safetensors",
+    "model.layers.15.self_attn.k_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.15.self_attn.o_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.15.self_attn.q_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.15.self_attn.v_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.16.input_layernorm.weight": "model-00003-of-00007.safetensors",
+    "model.layers.16.mlp.down_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.16.mlp.gate_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.16.mlp.up_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.16.post_attention_layernorm.weight": "model-00003-of-00007.safetensors",
+    "model.layers.16.self_attn.k_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.16.self_attn.o_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.16.self_attn.q_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.16.self_attn.v_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.17.input_layernorm.weight": "model-00003-of-00007.safetensors",
+    "model.layers.17.mlp.down_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.17.mlp.gate_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.17.mlp.up_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.17.post_attention_layernorm.weight": "model-00003-of-00007.safetensors",
+    "model.layers.17.self_attn.k_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.17.self_attn.o_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.17.self_attn.q_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.17.self_attn.v_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.18.input_layernorm.weight": "model-00003-of-00007.safetensors",
+    "model.layers.18.mlp.down_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.18.mlp.gate_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.18.mlp.up_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.18.post_attention_layernorm.weight": "model-00003-of-00007.safetensors",
+    "model.layers.18.self_attn.k_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.18.self_attn.o_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.18.self_attn.q_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.18.self_attn.v_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.19.input_layernorm.weight": "model-00003-of-00007.safetensors",
+    "model.layers.19.mlp.down_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.19.mlp.gate_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.19.mlp.up_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.19.post_attention_layernorm.weight": "model-00003-of-00007.safetensors",
+    "model.layers.19.self_attn.k_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.19.self_attn.o_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.19.self_attn.q_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.19.self_attn.v_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.2.input_layernorm.weight": "model-00001-of-00007.safetensors",
+    "model.layers.2.mlp.down_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.2.mlp.gate_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.2.mlp.up_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.2.post_attention_layernorm.weight": "model-00001-of-00007.safetensors",
+    "model.layers.2.self_attn.k_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.2.self_attn.o_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.2.self_attn.q_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.2.self_attn.v_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.20.input_layernorm.weight": "model-00003-of-00007.safetensors",
+    "model.layers.20.mlp.down_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.20.mlp.gate_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.20.mlp.up_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.20.post_attention_layernorm.weight": "model-00003-of-00007.safetensors",
+    "model.layers.20.self_attn.k_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.20.self_attn.o_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.20.self_attn.q_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.20.self_attn.v_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.21.input_layernorm.weight": "model-00003-of-00007.safetensors",
+    "model.layers.21.mlp.down_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.21.mlp.gate_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.21.mlp.up_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.21.post_attention_layernorm.weight": "model-00003-of-00007.safetensors",
+    "model.layers.21.self_attn.k_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.21.self_attn.o_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.21.self_attn.q_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.21.self_attn.v_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.22.input_layernorm.weight": "model-00004-of-00007.safetensors",
+    "model.layers.22.mlp.down_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.22.mlp.gate_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.22.mlp.up_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.22.post_attention_layernorm.weight": "model-00004-of-00007.safetensors",
+    "model.layers.22.self_attn.k_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.22.self_attn.o_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.22.self_attn.q_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.22.self_attn.v_proj.weight": "model-00003-of-00007.safetensors",
+    "model.layers.23.input_layernorm.weight": "model-00004-of-00007.safetensors",
+    "model.layers.23.mlp.down_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.23.mlp.gate_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.23.mlp.up_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.23.post_attention_layernorm.weight": "model-00004-of-00007.safetensors",
+    "model.layers.23.self_attn.k_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.23.self_attn.o_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.23.self_attn.q_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.23.self_attn.v_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.24.input_layernorm.weight": "model-00004-of-00007.safetensors",
+    "model.layers.24.mlp.down_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.24.mlp.gate_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.24.mlp.up_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.24.post_attention_layernorm.weight": "model-00004-of-00007.safetensors",
+    "model.layers.24.self_attn.k_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.24.self_attn.o_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.24.self_attn.q_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.24.self_attn.v_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.25.input_layernorm.weight": "model-00004-of-00007.safetensors",
+    "model.layers.25.mlp.down_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.25.mlp.gate_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.25.mlp.up_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.25.post_attention_layernorm.weight": "model-00004-of-00007.safetensors",
+    "model.layers.25.self_attn.k_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.25.self_attn.o_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.25.self_attn.q_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.25.self_attn.v_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.26.input_layernorm.weight": "model-00004-of-00007.safetensors",
+    "model.layers.26.mlp.down_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.26.mlp.gate_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.26.mlp.up_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.26.post_attention_layernorm.weight": "model-00004-of-00007.safetensors",
+    "model.layers.26.self_attn.k_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.26.self_attn.o_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.26.self_attn.q_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.26.self_attn.v_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.27.input_layernorm.weight": "model-00004-of-00007.safetensors",
+    "model.layers.27.mlp.down_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.27.mlp.gate_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.27.mlp.up_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.27.post_attention_layernorm.weight": "model-00004-of-00007.safetensors",
+    "model.layers.27.self_attn.k_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.27.self_attn.o_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.27.self_attn.q_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.27.self_attn.v_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.28.input_layernorm.weight": "model-00004-of-00007.safetensors",
+    "model.layers.28.mlp.down_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.28.mlp.gate_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.28.mlp.up_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.28.post_attention_layernorm.weight": "model-00004-of-00007.safetensors",
+    "model.layers.28.self_attn.k_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.28.self_attn.o_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.28.self_attn.q_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.28.self_attn.v_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.29.input_layernorm.weight": "model-00004-of-00007.safetensors",
+    "model.layers.29.mlp.down_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.29.mlp.gate_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.29.mlp.up_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.29.post_attention_layernorm.weight": "model-00004-of-00007.safetensors",
+    "model.layers.29.self_attn.k_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.29.self_attn.o_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.29.self_attn.q_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.29.self_attn.v_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.3.input_layernorm.weight": "model-00001-of-00007.safetensors",
+    "model.layers.3.mlp.down_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.3.mlp.gate_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.3.mlp.up_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.3.post_attention_layernorm.weight": "model-00001-of-00007.safetensors",
+    "model.layers.3.self_attn.k_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.3.self_attn.o_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.3.self_attn.q_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.3.self_attn.v_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.30.input_layernorm.weight": "model-00005-of-00007.safetensors",
+    "model.layers.30.mlp.down_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.30.mlp.gate_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.30.mlp.up_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.30.post_attention_layernorm.weight": "model-00005-of-00007.safetensors",
+    "model.layers.30.self_attn.k_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.30.self_attn.o_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.30.self_attn.q_proj.weight": "model-00004-of-00007.safetensors",
+    "model.layers.30.self_attn.v_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.31.input_layernorm.weight": "model-00005-of-00007.safetensors",
+    "model.layers.31.mlp.down_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.31.mlp.gate_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.31.mlp.up_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.31.post_attention_layernorm.weight": "model-00005-of-00007.safetensors",
+    "model.layers.31.self_attn.k_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.31.self_attn.o_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.31.self_attn.q_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.31.self_attn.v_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.32.input_layernorm.weight": "model-00005-of-00007.safetensors",
+    "model.layers.32.mlp.down_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.32.mlp.gate_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.32.mlp.up_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.32.post_attention_layernorm.weight": "model-00005-of-00007.safetensors",
+    "model.layers.32.self_attn.k_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.32.self_attn.o_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.32.self_attn.q_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.32.self_attn.v_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.33.input_layernorm.weight": "model-00005-of-00007.safetensors",
+    "model.layers.33.mlp.down_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.33.mlp.gate_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.33.mlp.up_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.33.post_attention_layernorm.weight": "model-00005-of-00007.safetensors",
+    "model.layers.33.self_attn.k_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.33.self_attn.o_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.33.self_attn.q_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.33.self_attn.v_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.34.input_layernorm.weight": "model-00005-of-00007.safetensors",
+    "model.layers.34.mlp.down_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.34.mlp.gate_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.34.mlp.up_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.34.post_attention_layernorm.weight": "model-00005-of-00007.safetensors",
+    "model.layers.34.self_attn.k_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.34.self_attn.o_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.34.self_attn.q_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.34.self_attn.v_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.35.input_layernorm.weight": "model-00005-of-00007.safetensors",
+    "model.layers.35.mlp.down_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.35.mlp.gate_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.35.mlp.up_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.35.post_attention_layernorm.weight": "model-00005-of-00007.safetensors",
+    "model.layers.35.self_attn.k_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.35.self_attn.o_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.35.self_attn.q_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.35.self_attn.v_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.36.input_layernorm.weight": "model-00005-of-00007.safetensors",
+    "model.layers.36.mlp.down_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.36.mlp.gate_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.36.mlp.up_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.36.post_attention_layernorm.weight": "model-00005-of-00007.safetensors",
+    "model.layers.36.self_attn.k_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.36.self_attn.o_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.36.self_attn.q_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.36.self_attn.v_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.37.input_layernorm.weight": "model-00005-of-00007.safetensors",
+    "model.layers.37.mlp.down_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.37.mlp.gate_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.37.mlp.up_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.37.post_attention_layernorm.weight": "model-00005-of-00007.safetensors",
+    "model.layers.37.self_attn.k_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.37.self_attn.o_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.37.self_attn.q_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.37.self_attn.v_proj.weight": "model-00005-of-00007.safetensors",
+    "model.layers.38.input_layernorm.weight": "model-00006-of-00007.safetensors",
+    "model.layers.38.mlp.down_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.38.mlp.gate_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.38.mlp.up_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.38.post_attention_layernorm.weight": "model-00006-of-00007.safetensors",
+    "model.layers.38.self_attn.k_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.38.self_attn.o_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.38.self_attn.q_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.38.self_attn.v_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.39.input_layernorm.weight": "model-00006-of-00007.safetensors",
+    "model.layers.39.mlp.down_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.39.mlp.gate_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.39.mlp.up_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.39.post_attention_layernorm.weight": "model-00006-of-00007.safetensors",
+    "model.layers.39.self_attn.k_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.39.self_attn.o_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.39.self_attn.q_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.39.self_attn.v_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.4.input_layernorm.weight": "model-00001-of-00007.safetensors",
+    "model.layers.4.mlp.down_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.4.mlp.gate_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.4.mlp.up_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.4.post_attention_layernorm.weight": "model-00001-of-00007.safetensors",
+    "model.layers.4.self_attn.k_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.4.self_attn.o_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.4.self_attn.q_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.4.self_attn.v_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.40.input_layernorm.weight": "model-00006-of-00007.safetensors",
+    "model.layers.40.mlp.down_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.40.mlp.gate_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.40.mlp.up_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.40.post_attention_layernorm.weight": "model-00006-of-00007.safetensors",
+    "model.layers.40.self_attn.k_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.40.self_attn.o_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.40.self_attn.q_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.40.self_attn.v_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.41.input_layernorm.weight": "model-00006-of-00007.safetensors",
+    "model.layers.41.mlp.down_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.41.mlp.gate_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.41.mlp.up_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.41.post_attention_layernorm.weight": "model-00006-of-00007.safetensors",
+    "model.layers.41.self_attn.k_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.41.self_attn.o_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.41.self_attn.q_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.41.self_attn.v_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.42.input_layernorm.weight": "model-00006-of-00007.safetensors",
+    "model.layers.42.mlp.down_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.42.mlp.gate_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.42.mlp.up_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.42.post_attention_layernorm.weight": "model-00006-of-00007.safetensors",
+    "model.layers.42.self_attn.k_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.42.self_attn.o_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.42.self_attn.q_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.42.self_attn.v_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.43.input_layernorm.weight": "model-00006-of-00007.safetensors",
+    "model.layers.43.mlp.down_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.43.mlp.gate_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.43.mlp.up_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.43.post_attention_layernorm.weight": "model-00006-of-00007.safetensors",
+    "model.layers.43.self_attn.k_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.43.self_attn.o_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.43.self_attn.q_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.43.self_attn.v_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.44.input_layernorm.weight": "model-00006-of-00007.safetensors",
+    "model.layers.44.mlp.down_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.44.mlp.gate_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.44.mlp.up_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.44.post_attention_layernorm.weight": "model-00006-of-00007.safetensors",
+    "model.layers.44.self_attn.k_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.44.self_attn.o_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.44.self_attn.q_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.44.self_attn.v_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.45.input_layernorm.weight": "model-00007-of-00007.safetensors",
+    "model.layers.45.mlp.down_proj.weight": "model-00007-of-00007.safetensors",
+    "model.layers.45.mlp.gate_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.45.mlp.up_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.45.post_attention_layernorm.weight": "model-00007-of-00007.safetensors",
+    "model.layers.45.self_attn.k_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.45.self_attn.o_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.45.self_attn.q_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.45.self_attn.v_proj.weight": "model-00006-of-00007.safetensors",
+    "model.layers.46.input_layernorm.weight": "model-00007-of-00007.safetensors",
+    "model.layers.46.mlp.down_proj.weight": "model-00007-of-00007.safetensors",
+    "model.layers.46.mlp.gate_proj.weight": "model-00007-of-00007.safetensors",
+    "model.layers.46.mlp.up_proj.weight": "model-00007-of-00007.safetensors",
+    "model.layers.46.post_attention_layernorm.weight": "model-00007-of-00007.safetensors",
+    "model.layers.46.self_attn.k_proj.weight": "model-00007-of-00007.safetensors",
+    "model.layers.46.self_attn.o_proj.weight": "model-00007-of-00007.safetensors",
+    "model.layers.46.self_attn.q_proj.weight": "model-00007-of-00007.safetensors",
+    "model.layers.46.self_attn.v_proj.weight": "model-00007-of-00007.safetensors",
+    "model.layers.47.input_layernorm.weight": "model-00007-of-00007.safetensors",
+    "model.layers.47.mlp.down_proj.weight": "model-00007-of-00007.safetensors",
+    "model.layers.47.mlp.gate_proj.weight": "model-00007-of-00007.safetensors",
+    "model.layers.47.mlp.up_proj.weight": "model-00007-of-00007.safetensors",
+    "model.layers.47.post_attention_layernorm.weight": "model-00007-of-00007.safetensors",
+    "model.layers.47.self_attn.k_proj.weight": "model-00007-of-00007.safetensors",
+    "model.layers.47.self_attn.o_proj.weight": "model-00007-of-00007.safetensors",
+    "model.layers.47.self_attn.q_proj.weight": "model-00007-of-00007.safetensors",
+    "model.layers.47.self_attn.v_proj.weight": "model-00007-of-00007.safetensors",
+    "model.layers.5.input_layernorm.weight": "model-00001-of-00007.safetensors",
+    "model.layers.5.mlp.down_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.5.mlp.gate_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.5.mlp.up_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.5.post_attention_layernorm.weight": "model-00001-of-00007.safetensors",
+    "model.layers.5.self_attn.k_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.5.self_attn.o_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.5.self_attn.q_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.5.self_attn.v_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.6.input_layernorm.weight": "model-00002-of-00007.safetensors",
+    "model.layers.6.mlp.down_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.6.mlp.gate_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.6.mlp.up_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.6.post_attention_layernorm.weight": "model-00002-of-00007.safetensors",
+    "model.layers.6.self_attn.k_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.6.self_attn.o_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.6.self_attn.q_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.6.self_attn.v_proj.weight": "model-00001-of-00007.safetensors",
+    "model.layers.7.input_layernorm.weight": "model-00002-of-00007.safetensors",
+    "model.layers.7.mlp.down_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.7.mlp.gate_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.7.mlp.up_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.7.post_attention_layernorm.weight": "model-00002-of-00007.safetensors",
+    "model.layers.7.self_attn.k_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.7.self_attn.o_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.7.self_attn.q_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.7.self_attn.v_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.8.input_layernorm.weight": "model-00002-of-00007.safetensors",
+    "model.layers.8.mlp.down_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.8.mlp.gate_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.8.mlp.up_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.8.post_attention_layernorm.weight": "model-00002-of-00007.safetensors",
+    "model.layers.8.self_attn.k_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.8.self_attn.o_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.8.self_attn.q_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.8.self_attn.v_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.9.input_layernorm.weight": "model-00002-of-00007.safetensors",
+    "model.layers.9.mlp.down_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.9.mlp.gate_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.9.mlp.up_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.9.post_attention_layernorm.weight": "model-00002-of-00007.safetensors",
+    "model.layers.9.self_attn.k_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.9.self_attn.o_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.9.self_attn.q_proj.weight": "model-00002-of-00007.safetensors",
+    "model.layers.9.self_attn.v_proj.weight": "model-00002-of-00007.safetensors",
+    "model.norm.weight": "model-00007-of-00007.safetensors"
+  }
+}

modeling_nanbeige.py

@@ -0,0 +1,935 @@
+import math
+import queue
+import threading
+from typing import List, Optional, Tuple, Union
+
+import torch
+import torch.utils.checkpoint
+from torch import nn
+from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss
+from transformers.activations import ACT2FN
+from transformers.generation.streamers import BaseStreamer
+from transformers.modeling_outputs import BaseModelOutputWithPast, CausalLMOutputWithPast, \
+    SequenceClassifierOutputWithPast
+from transformers.modeling_utils import PreTrainedModel
+from transformers.utils import logging
+
+from .configuration_nanbeige import NanbeigeConfig
+
+logger = logging.get_logger(__name__)
+
+try:
+    import flash_attn
+    from flash_attn import flash_attn_func
+
+    if int(flash_attn.__version__.split(".")[0]) >= 2 and int(flash_attn.__version__.split(".")[1]) >= 1:
+        Version_ = True
+    else:
+        Version_ = False
+except:
+    logger.warn(
+        "Warning: import flash_attn fail, please install FlashAttention to get higher efficiency "
+        "https://github.com/Dao-AILab/flash-attention"
+    )
+    Version_ = False
+    flash_attn_func = None
+
+
+def _make_causal_mask(
+        input_ids_shape: torch.Size, dtype: torch.dtype, device: torch.device, past_key_values_length: int = 0
+):
+    """
+    Make causal mask used for bi-directional self-attention.
+    """
+    bsz, tgt_len = input_ids_shape
+    mask = torch.full((tgt_len, tgt_len), torch.tensor(torch.finfo(dtype).min, device=device), device=device)
+    mask_cond = torch.arange(mask.size(-1), device=device)
+    mask.masked_fill_(mask_cond < (mask_cond + 1).view(mask.size(-1), 1), 0)
+    mask = mask.to(dtype)
+
+    if past_key_values_length > 0:
+        mask = torch.cat([torch.zeros(tgt_len, past_key_values_length, dtype=dtype, device=device), mask], dim=-1)
+    return mask[None, None, :, :].expand(bsz, 1, tgt_len, tgt_len + past_key_values_length)
+
+
+def _expand_mask(mask: torch.Tensor, dtype: torch.dtype, tgt_len: Optional[int] = None):
+    """
+    Expands attention_mask from `[bsz, seq_len]` to `[bsz, 1, tgt_seq_len, src_seq_len]`.
+    """
+    bsz, src_len = mask.size()
+    tgt_len = tgt_len if tgt_len is not None else src_len
+
+    expanded_mask = mask[:, None, None, :].expand(bsz, 1, tgt_len, src_len).to(dtype)
+
+    inverted_mask = 1.0 - expanded_mask
+
+    return inverted_mask.masked_fill(inverted_mask.to(torch.bool), torch.finfo(dtype).min)
+
+
+def find_correction_dim(num_rotations, dim, base=10000, max_position_embeddings=2048):
+    return (dim * math.log(max_position_embeddings / (num_rotations * 2 * math.pi))) / (2 * math.log(base))
+
+
+def find_correction_range(low_rot, high_rot, dim, base=10000, max_position_embeddings=2048):
+    low = math.floor(find_correction_dim(
+        low_rot, dim, base, max_position_embeddings))
+    high = math.ceil(find_correction_dim(
+        high_rot, dim, base, max_position_embeddings))
+    return max(low, 0), min(high, dim - 1)  # Clamp values just in case
+
+
+def linear_ramp_mask(min, max, dim):
+    if min == max:
+        max += 0.001  # Prevent singularity
+
+    linear_func = (torch.arange(dim, dtype=torch.float32) - min) / (max - min)
+    ramp_func = torch.clamp(linear_func, 0, 1)
+    return ramp_func
+
+
+def get_mscale(scale=1):
+    if scale <= 1:
+        return 1.0
+    return 0.1 * math.log(scale) + 1.0
+
+
+class YaRNScaledRotaryEmbedding(torch.nn.Module):
+    def __init__(self, dim, max_position_embeddings=4096, base=10000, scale=1, original_max_position_embeddings=4096,
+                 extrapolation_factor=1, attn_factor=1, beta_fast=32, beta_slow=1, finetuned=False, device=None):
+        super().__init__()
+        self.dim = dim
+        self.max_position_embeddings = max_position_embeddings
+        self.base = base
+        self.scale = scale
+        self.original_max_position_embeddings = original_max_position_embeddings
+        self.extrapolation_factor = extrapolation_factor
+        self.attn_factor = attn_factor
+        self.beta_fast = beta_fast
+        self.beta_slow = beta_slow
+
+        self.yarn(device)
+
+        # Build here to make `torch.jit.trace` work.
+        self.max_seq_len_cached = max_position_embeddings
+        t = torch.arange(self.max_seq_len_cached, device=self.inv_freq.device, dtype=self.inv_freq.dtype)
+        freqs = torch.einsum("i,j->ij", t, self.inv_freq)
+        # Different from paper, but it uses a different permutation in order to obtain the same calculation
+        emb = torch.cat((freqs, freqs), dim=-1)
+        dtype = torch.get_default_dtype()
+
+        self.register_buffer("cos_cached", (emb.cos() * self.mscale)[None, None, :, :].to(dtype), persistent=False)
+        self.register_buffer("sin_cached", (emb.sin() * self.mscale)[None, None, :, :].to(dtype), persistent=False)
+
+    def forward(self, x, seq_len=None):
+        # x: [bs, num_attention_heads, seq_len, head_size]
+        # This `if` block is unlikely to be run after we build sin/cos in `__init__`. Keep the logic here just in case.
+        if seq_len > self.max_seq_len_cached:
+            self.max_seq_len_cached = seq_len
+
+            t = torch.arange(self.max_seq_len_cached, device=x.device, dtype=self.inv_freq.dtype)
+            freqs = torch.einsum("i,j->ij", t, self.inv_freq)
+            # Different from paper, but it uses a different permutation in order to obtain the same calculation
+            emb = torch.cat((freqs, freqs), dim=-1).to(x.device)
+
+            self.register_buffer("cos_cached", (emb.cos() * self.mscale)[None, None, :, :].to(x.dtype),
+                                 persistent=False)
+            self.register_buffer("sin_cached", (emb.sin() * self.mscale)[None, None, :, :].to(x.dtype),
+                                 persistent=False)
+        return (
+            self.cos_cached[:, :, :seq_len, ...].to(dtype=x.dtype),
+            self.sin_cached[:, :, :seq_len, ...].to(dtype=x.dtype),
+        )
+
+    def yarn(self, device):
+        pos_freqs = self.base ** (torch.arange(0, self.dim, 2).float().to(device) / self.dim)
+        inv_freq_extrapolation = 1.0 / pos_freqs
+        inv_freq_interpolation = 1.0 / (self.scale * pos_freqs)
+
+        low, high = find_correction_range(self.beta_fast, self.beta_slow, self.dim, self.base,
+                                          self.original_max_position_embeddings)
+        inv_freq_mask = (1 - linear_ramp_mask(low, high, self.dim // 2).float().to(
+            device)) * self.extrapolation_factor  # Get n-d rotational scaling corrected for extrapolation
+        inv_freq = inv_freq_interpolation * (1 - inv_freq_mask) + inv_freq_extrapolation * inv_freq_mask
+
+        self.register_buffer("inv_freq", inv_freq)
+        self.mscale = float(
+            get_mscale(self.scale) * self.attn_factor)  # Get n-d magnitude scaling corrected for interpolation
+
+
+class RMSNorm(nn.Module):
+    def __init__(self, hidden_size, eps=1e-6):
+        super().__init__()
+        self.weight = nn.Parameter(torch.ones(hidden_size))
+        self.variance_epsilon = eps
+
+    def forward(self, hidden_states):
+        variance = hidden_states.to(torch.float32).pow(2).mean(-1, keepdim=True)
+        hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)
+
+        # convert into half-precision if necessary
+        if self.weight.dtype in [torch.float16, torch.bfloat16]:
+            hidden_states = hidden_states.to(self.weight.dtype)
+
+        return self.weight * hidden_states
+
+
+class RotaryEmbedding(torch.nn.Module):
+    def __init__(self, dim, max_position_embeddings=2048, base=10000, device=None):
+        super().__init__()
+        inv_freq = 1.0 / (base ** (torch.arange(0, dim, 2).float().to(device) / dim))
+        self.register_buffer("inv_freq", inv_freq)
+        self.max_seq_len_cached = max_position_embeddings
+        t = torch.arange(self.max_seq_len_cached, device=self.inv_freq.device, dtype=self.inv_freq.dtype)
+        freqs = torch.einsum("i,j->ij", t, self.inv_freq)
+        emb = torch.cat((freqs, freqs), dim=-1)
+        self.register_buffer("cos_cached", emb.cos()[None, None, :, :], persistent=False)
+        self.register_buffer("sin_cached", emb.sin()[None, None, :, :], persistent=False)
+
+    def forward(self, x, seq_len=None):
+        # x: [bs, num_attention_heads, seq_len, head_size]
+        # This `if` block is unlikely to be run after we build sin/cos in `__init__`. Keep the logic here just in case.
+        if seq_len > self.max_seq_len_cached:
+            self.max_seq_len_cached = seq_len
+            t = torch.arange(self.max_seq_len_cached, device=x.device, dtype=self.inv_freq.dtype)
+            freqs = torch.einsum("i,j->ij", t, self.inv_freq)
+            # Different from paper, but it uses a different permutation in order to obtain the same calculation
+            emb = torch.cat((freqs, freqs), dim=-1).to(x.device)
+            self.register_buffer("cos_cached", emb.cos()[None, None, :, :], persistent=False)
+            self.register_buffer("sin_cached", emb.sin()[None, None, :, :], persistent=False)
+        return (
+            self.cos_cached[:, :, :seq_len, ...].to(dtype=x.dtype),
+            self.sin_cached[:, :, :seq_len, ...].to(dtype=x.dtype),
+        )
+
+
+def rotate_half(x):
+    """Rotates half the hidden dims of the input."""
+    x1 = x[..., : x.shape[-1] // 2]
+    x2 = x[..., x.shape[-1] // 2:]
+    return torch.cat((-x2, x1), dim=-1)
+
+
+def apply_rotary_pos_emb(q, k, cos, sin, position_ids):
+    # The first two dimensions of cos and sin are always 1, so we can `squeeze` them.
+    cos = cos.squeeze(1).squeeze(0)  # [seq_len, dim]
+    sin = sin.squeeze(1).squeeze(0)  # [seq_len, dim]
+    cos = cos[position_ids].unsqueeze(1)  # [bs, 1, seq_len, dim]
+    sin = sin[position_ids].unsqueeze(1)  # [bs, 1, seq_len, dim]
+    q_embed = (q * cos) + (rotate_half(q) * sin)
+    k_embed = (k * cos) + (rotate_half(k) * sin)
+    return q_embed, k_embed
+
+
+class NanbeigeMLP(nn.Module):
+    def __init__(
+            self,
+            hidden_size: int,
+            intermediate_size: int,
+            hidden_act: str,
+    ):
+        super().__init__()
+        self.gate_proj = nn.Linear(hidden_size, intermediate_size, bias=False)
+        self.down_proj = nn.Linear(intermediate_size, hidden_size, bias=False)
+        self.up_proj = nn.Linear(hidden_size, intermediate_size, bias=False)
+        self.act_fn = ACT2FN[hidden_act]
+
+    def forward(self, x):
+        return self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))
+
+
+class NanbeigeAttention(nn.Module):
+    """Multi-headed attention from 'Attention Is All You Need' paper"""
+
+    def __init__(self, config: NanbeigeConfig):
+        super().__init__()
+        self.config = config
+        self.hidden_size = config.hidden_size
+        self.num_heads = config.num_attention_heads
+        self.head_dim = self.hidden_size // self.num_heads
+        self.max_position_embeddings = config.max_position_embeddings
+
+        if (self.head_dim * self.num_heads) != self.hidden_size:
+            raise ValueError(
+                f"hidden_size must be divisible by num_heads (got `hidden_size`: {self.hidden_size}"
+                f" and `num_heads`: {self.num_heads})."
+            )
+        self.q_proj = nn.Linear(self.hidden_size, self.num_heads * self.head_dim, bias=False)
+        self.k_proj = nn.Linear(self.hidden_size, self.num_heads * self.head_dim, bias=False)
+        self.v_proj = nn.Linear(self.hidden_size, self.num_heads * self.head_dim, bias=False)
+        self.o_proj = nn.Linear(self.num_heads * self.head_dim, self.hidden_size, bias=False)
+        if self.config.yarn_scale > 1:
+            self.rotary_emb = YaRNScaledRotaryEmbedding(self.head_dim, scale=self.config.yarn_scale,
+                                                        original_max_position_embeddings=self.max_position_embeddings)
+        else:
+            self.rotary_emb = RotaryEmbedding(self.head_dim, max_position_embeddings=self.max_position_embeddings)
+
+    def _shape(self, tensor: torch.Tensor, seq_len: int, bsz: int):
+        return tensor.view(bsz, seq_len, self.num_heads, self.head_dim).transpose(1, 2).contiguous()
+
+    def forward(
+            self,
+            hidden_states: torch.Tensor,
+            attention_mask: Optional[torch.Tensor] = None,
+            position_ids: Optional[torch.LongTensor] = None,
+            past_key_value: Optional[Tuple[torch.Tensor]] = None,
+            output_attentions: bool = False,
+            use_cache: bool = False,
+    ) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[Tuple[torch.Tensor]]]:
+        bsz, q_len, _ = hidden_states.size()
+
+        query_states = self.q_proj(hidden_states).view(bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2)
+        key_states = self.k_proj(hidden_states).view(bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2)
+        value_states = self.v_proj(hidden_states).view(bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2)
+
+        kv_seq_len = key_states.shape[-2]
+        if past_key_value is not None:
+            kv_seq_len += past_key_value[0].shape[-2]
+        cos, sin = self.rotary_emb(value_states, seq_len=kv_seq_len)
+        query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin, position_ids)
+
+        if past_key_value is not None:
+            key_states = torch.cat([past_key_value[0], key_states], dim=2)
+            value_states = torch.cat([past_key_value[1], value_states], dim=2)
+
+        past_key_value = (key_states, value_states) if use_cache else None
+
+        if Version_ or (flash_attn_func and query_states.size() == key_states.size()):
+            attn_output = flash_attn_func(query_states.transpose(1, 2), key_states.transpose(1, 2),
+                                          value_states.transpose(1, 2), dropout_p=0.0, softmax_scale=None, causal=True)
+        else:
+            attn_weights = torch.matmul(query_states, key_states.transpose(2, 3)) / math.sqrt(self.head_dim)
+
+            if attn_weights.size() != (bsz, self.num_heads, q_len, kv_seq_len):
+                raise ValueError(
+                    f"Attention weights should be of size {(bsz, self.num_heads, q_len, kv_seq_len)}, but is"
+                    f" {attn_weights.size()}"
+                )
+
+            if attention_mask is not None:
+                if attention_mask.size() != (bsz, 1, q_len, kv_seq_len):
+                    raise ValueError(
+                        f"Attention mask should be of size {(bsz, 1, q_len, kv_seq_len)}, but is {attention_mask.size()}"
+                    )
+                attn_weights = attn_weights + attention_mask
+                attn_weights = torch.max(attn_weights, torch.tensor(torch.finfo(attn_weights.dtype).min))
+
+            # upcast attention to fp32
+            attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query_states.dtype)
+            attn_output = torch.matmul(attn_weights, value_states)
+
+            if attn_output.size() != (bsz, self.num_heads, q_len, self.head_dim):
+                raise ValueError(
+                    f"`attn_output` should be of size {(bsz, self.num_heads, q_len, self.head_dim)}, but is"
+                    f" {attn_output.size()}"
+                )
+
+            attn_output = attn_output.transpose(1, 2)
+
+        attn_output = attn_output.reshape(bsz, q_len, self.hidden_size)
+
+        attn_output = self.o_proj(attn_output)
+
+        if not output_attentions:
+            attn_weights = None
+
+        return attn_output, attn_weights, past_key_value
+
+
+class NanbeigeDecoderLayer(nn.Module):
+    def __init__(self, config: NanbeigeConfig):
+        super().__init__()
+        self.hidden_size = config.hidden_size
+        self.self_attn = NanbeigeAttention(config=config)
+        self.mlp = NanbeigeMLP(
+            hidden_size=self.hidden_size,
+            intermediate_size=config.intermediate_size,
+            hidden_act=config.hidden_act,
+        )
+        self.input_layernorm = RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+        self.post_attention_layernorm = RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+
+    def forward(
+            self,
+            hidden_states: torch.Tensor,
+            attention_mask: Optional[torch.Tensor] = None,
+            position_ids: Optional[torch.LongTensor] = None,
+            past_key_value: Optional[Tuple[torch.Tensor]] = None,
+            output_attentions: Optional[bool] = False,
+            use_cache: Optional[bool] = False,
+    ) -> Tuple[torch.FloatTensor, Optional[Tuple[torch.FloatTensor, torch.FloatTensor]]]:
+        """
+        Args:
+            hidden_states (`torch.FloatTensor`): input to the layer of shape `(batch, seq_len, embed_dim)`
+            attention_mask (`torch.FloatTensor`, *optional*): attention mask of size
+                `(batch, 1, tgt_len, src_len)` where padding elements are indicated by very large negative values.
+            output_attentions (`bool`, *optional*):
+                Whether or not to return the attentions tensors of all attention layers. See `attentions` under
+                returned tensors for more detail.
+            use_cache (`bool`, *optional*):
+                If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding
+                (see `past_key_values`).
+            past_key_value (`Tuple(torch.FloatTensor)`, *optional*): cached past key and value projection states
+        """
+
+        residual = hidden_states
+
+        hidden_states = self.input_layernorm(hidden_states)
+
+        # Self Attention
+        hidden_states, self_attn_weights, present_key_value = self.self_attn(
+            hidden_states=hidden_states,
+            attention_mask=attention_mask,
+            position_ids=position_ids,
+            past_key_value=past_key_value,
+            output_attentions=output_attentions,
+            use_cache=use_cache,
+        )
+        hidden_states = residual + hidden_states
+
+        # Fully Connected
+        residual = hidden_states
+        hidden_states = self.post_attention_layernorm(hidden_states)
+        hidden_states = self.mlp(hidden_states)
+        hidden_states = residual + hidden_states
+
+        outputs = (hidden_states,)
+
+        if output_attentions:
+            outputs += (self_attn_weights,)
+
+        if use_cache:
+            outputs += (present_key_value,)
+
+        return outputs
+
+
+class NanbeigePreTrainedModel(PreTrainedModel):
+    config_class = NanbeigeConfig
+    base_model_prefix = "model"
+    supports_gradient_checkpointing = True
+    _no_split_modules = ["NanbeigeDecoderLayer"]
+    _keys_to_ignore_on_load_unexpected = [r"decoder\.version"]
+
+    def _init_weights(self, module):
+        std = self.config.initializer_range
+        if isinstance(module, nn.Linear):
+            module.weight.data.normal_(mean=0.0, std=std)
+            if module.bias is not None:
+                module.bias.data.zero_()
+        elif isinstance(module, nn.Embedding):
+            module.weight.data.normal_(mean=0.0, std=std)
+            if module.padding_idx is not None:
+                module.weight.data[module.padding_idx].zero_()
+
+    def _set_gradient_checkpointing(self, module, value=False):
+        if isinstance(module, NanbeigeModel):
+            module.gradient_checkpointing = value
+
+
+class NanbeigeModel(NanbeigePreTrainedModel):
+    def __init__(self, config: NanbeigeConfig):
+        super().__init__(config)
+        self.padding_idx = config.pad_token_id
+        self.vocab_size = config.vocab_size
+
+        self.embed_tokens = nn.Embedding(config.vocab_size, config.hidden_size, self.padding_idx)
+        self.layers = nn.ModuleList([NanbeigeDecoderLayer(config) for _ in range(config.num_hidden_layers)])
+        self.norm = RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+
+        self.gradient_checkpointing = False
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def get_input_embeddings(self):
+        return self.embed_tokens
+
+    def set_input_embeddings(self, value):
+        self.embed_tokens = value
+
+    # Copied from transformers.models.bart.modeling_bart.BartDecoder._prepare_decoder_attention_mask
+    def _prepare_decoder_attention_mask(self, attention_mask, input_shape, inputs_embeds, past_key_values_length):
+        # create causal mask
+        # [bsz, seq_len] -> [bsz, 1, tgt_seq_len, src_seq_len]
+        combined_attention_mask = None
+        if input_shape[-1] > 1:
+            combined_attention_mask = _make_causal_mask(
+                input_shape,
+                inputs_embeds.dtype,
+                device=inputs_embeds.device,
+                past_key_values_length=past_key_values_length,
+            )
+
+        if attention_mask is not None:
+            # [bsz, seq_len] -> [bsz, 1, tgt_seq_len, src_seq_len]
+            expanded_attn_mask = _expand_mask(attention_mask, inputs_embeds.dtype, tgt_len=input_shape[-1]).to(
+                inputs_embeds.device
+            )
+            combined_attention_mask = (
+                expanded_attn_mask if combined_attention_mask is None else expanded_attn_mask + combined_attention_mask
+            )
+
+        return combined_attention_mask
+
+    def forward(
+            self,
+            input_ids: torch.LongTensor = None,
+            attention_mask: Optional[torch.Tensor] = None,
+            position_ids: Optional[torch.LongTensor] = None,
+            past_key_values: Optional[List[torch.FloatTensor]] = None,
+            inputs_embeds: Optional[torch.FloatTensor] = None,
+            use_cache: Optional[bool] = None,
+            output_attentions: Optional[bool] = None,
+            output_hidden_states: Optional[bool] = None,
+            return_dict: Optional[bool] = None,
+    ) -> Union[Tuple, BaseModelOutputWithPast]:
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        output_hidden_states = (
+            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        )
+        use_cache = use_cache if use_cache is not None else self.config.use_cache
+
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        # retrieve input_ids and inputs_embeds
+        if input_ids is not None and inputs_embeds is not None:
+            raise ValueError("You cannot specify both decoder_input_ids and decoder_inputs_embeds at the same time")
+        elif input_ids is not None:
+            batch_size, seq_length = input_ids.shape
+        elif inputs_embeds is not None:
+            batch_size, seq_length, _ = inputs_embeds.shape
+        else:
+            raise ValueError("You have to specify either decoder_input_ids or decoder_inputs_embeds")
+
+        seq_length_with_past = seq_length
+        past_key_values_length = 0
+
+        if past_key_values is not None:
+            past_key_values_length = past_key_values[0][0].shape[2]
+            seq_length_with_past = seq_length_with_past + past_key_values_length
+        else:
+            past_key_values = [None for _ in range(len(self.layers))]
+
+        if position_ids is None:
+            device = input_ids.device if input_ids is not None else inputs_embeds.device
+            position_ids = torch.arange(
+                past_key_values_length, seq_length + past_key_values_length, dtype=torch.long, device=device
+            )
+            position_ids = position_ids.unsqueeze(0).view(-1, seq_length)
+        else:
+            position_ids = position_ids.view(-1, seq_length).long()
+
+        if inputs_embeds is None:
+            inputs_embeds = self.embed_tokens(input_ids)
+        # embed positions
+        if attention_mask is None:
+            attention_mask = torch.ones(
+                (batch_size, seq_length_with_past), dtype=torch.bool, device=inputs_embeds.device
+            )
+        attention_mask = self._prepare_decoder_attention_mask(
+            attention_mask, (batch_size, seq_length), inputs_embeds, past_key_values_length
+        )
+
+        hidden_states = inputs_embeds
+
+        if self.gradient_checkpointing and self.training:
+            if use_cache:
+                logger.warning_once(
+                    "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..."
+                )
+                use_cache = False
+
+        # decoder layers
+        all_hidden_states = () if output_hidden_states else None
+        all_self_attns = () if output_attentions else None
+        next_cache = [] if use_cache else None
+
+        for idx, decoder_layer in enumerate(self.layers):
+            if output_hidden_states:
+                all_hidden_states += (hidden_states,)
+
+            past_key_value = past_key_values.pop(0) if past_key_values is not None else None
+
+            if self.gradient_checkpointing and self.training:
+
+                def create_custom_forward(module):
+                    def custom_forward(*inputs):
+                        # None for past_key_value
+                        return module(*inputs, output_attentions, None)
+
+                    return custom_forward
+
+                layer_outputs = torch.utils.checkpoint.checkpoint(
+                    create_custom_forward(decoder_layer),
+                    hidden_states,
+                    attention_mask,
+                    position_ids,
+                    None,
+                )
+            else:
+                layer_outputs = decoder_layer(
+                    hidden_states,
+                    attention_mask=attention_mask,
+                    position_ids=position_ids,
+                    past_key_value=past_key_value,
+                    output_attentions=output_attentions,
+                    use_cache=use_cache,
+                )
+
+            hidden_states = layer_outputs[0]
+
+            if use_cache:
+                next_cache.append(layer_outputs[2 if output_attentions else 1])
+
+            if output_attentions:
+                all_self_attns += (layer_outputs[1],)
+
+        hidden_states = self.norm(hidden_states)
+
+        # add hidden states from the last decoder layer
+        if output_hidden_states:
+            all_hidden_states += (hidden_states,)
+
+        if not return_dict:
+            return tuple(v for v in [hidden_states, next_cache, all_hidden_states, all_self_attns] if v is not None)
+        return BaseModelOutputWithPast(
+            last_hidden_state=hidden_states,
+            past_key_values=next_cache,
+            hidden_states=all_hidden_states,
+            attentions=all_self_attns,
+        )
+
+
+class NanbeigeForCausalLM(NanbeigePreTrainedModel):
+    def __init__(self, config):
+        super().__init__(config)
+        self.model = NanbeigeModel(config)
+
+        self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def get_input_embeddings(self):
+        return self.model.embed_tokens
+
+    def set_input_embeddings(self, value):
+        self.model.embed_tokens = value
+
+    def get_output_embeddings(self):
+        return self.lm_head
+
+    def set_output_embeddings(self, new_embeddings):
+        self.lm_head = new_embeddings
+
+    def set_decoder(self, decoder):
+        self.model = decoder
+
+    def get_decoder(self):
+        return self.model
+
+    def forward(
+            self,
+            input_ids: torch.LongTensor = None,
+            attention_mask: Optional[torch.Tensor] = None,
+            position_ids: Optional[torch.LongTensor] = None,
+            past_key_values: Optional[List[torch.FloatTensor]] = None,
+            inputs_embeds: Optional[torch.FloatTensor] = None,
+            labels: Optional[torch.LongTensor] = None,
+            use_cache: Optional[bool] = None,
+            output_attentions: Optional[bool] = None,
+            output_hidden_states: Optional[bool] = None,
+            return_dict: Optional[bool] = None,
+    ) -> Union[Tuple, CausalLMOutputWithPast]:
+
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        output_hidden_states = (
+            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        )
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        # decoder outputs consists of (dec_features, layer_state, dec_hidden, dec_attn)
+        outputs = self.model(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            position_ids=position_ids,
+            past_key_values=past_key_values,
+            inputs_embeds=inputs_embeds,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+
+        hidden_states = outputs[0]
+        logits = self.lm_head(hidden_states)
+
+        loss = None
+        if labels is not None:
+            # Shift so that tokens < n predict n
+            shift_logits = logits[..., :-1, :].contiguous()
+            shift_labels = labels[..., 1:].contiguous()
+            # Flatten the tokens
+            loss_fct = CrossEntropyLoss()
+            shift_logits = shift_logits.view(-1, self.config.vocab_size)
+            shift_labels = shift_labels.view(-1)
+            # Enable model parallelism
+            shift_labels = shift_labels.to(shift_logits.device)
+            loss = loss_fct(shift_logits, shift_labels)
+
+        if not return_dict:
+            output = (logits,) + outputs[1:]
+            return (loss,) + output if loss is not None else output
+
+        return CausalLMOutputWithPast(
+            loss=loss,
+            logits=logits,
+            past_key_values=outputs.past_key_values,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )
+
+    def prepare_inputs_for_generation(
+            self, input_ids, past_key_values=None, attention_mask=None, inputs_embeds=None, **kwargs
+    ):
+        if past_key_values:
+            input_ids = input_ids[:, -1:]
+
+        position_ids = kwargs.get("position_ids", None)
+        if attention_mask is not None and position_ids is None:
+            # create position_ids on the fly for batch generation
+            position_ids = attention_mask.long().cumsum(-1) - 1
+            position_ids.masked_fill_(attention_mask == 0, 1)
+            if past_key_values:
+                position_ids = position_ids[:, -1].unsqueeze(-1)
+
+        # if `inputs_embeds` are passed, we only want to use them in the 1st generation step
+        if inputs_embeds is not None and past_key_values is None:
+            model_inputs = {"inputs_embeds": inputs_embeds}
+        else:
+            model_inputs = {"input_ids": input_ids}
+
+        model_inputs.update(
+            {
+                "position_ids": position_ids,
+                "past_key_values": past_key_values,
+                "use_cache": kwargs.get("use_cache"),
+                "attention_mask": attention_mask,
+            }
+        )
+        return model_inputs
+
+    @staticmethod
+    def _reorder_cache(past_key_values, beam_idx):
+        reordered_past = ()
+        for layer_past in past_key_values:
+            reordered_past += (tuple(past_state.index_select(0, beam_idx) for past_state in layer_past),)
+        return reordered_past
+
+    @torch.no_grad()
+    def chat(self,
+             tokenizer,
+             query: str,
+             messages: List[dict] = None,
+             streamer: Optional[BaseStreamer] = None,
+             max_new_tokens: int = 512,
+             do_sample: bool = True,
+             temperature: float = 0.3,
+             top_p: float = 0.9,
+             **kwargs):
+        if messages is None:
+            messages = []
+        messages = messages + [{'role': 'user', 'content': query}]
+        prompt = tokenizer.apply_chat_template(messages, add_generation_prompt=True, tokenize=False)
+        inputs = tokenizer(prompt, add_special_tokens=False, return_tensors='pt')
+        inputs = {k: v.to(self.device) for k, v in inputs.items() if torch.is_tensor(v)}
+        outputs = self.generate(**inputs,
+                                streamer=streamer,
+                                max_new_tokens=max_new_tokens,
+                                do_sample=do_sample,
+                                temperature=temperature,
+                                top_p=top_p,
+                                **kwargs)
+        outputs = outputs[0].cpu().tolist()[len(inputs["input_ids"][0]):]
+        response = tokenizer.decode(outputs, skip_special_tokens=True)
+        response = response.split(tokenizer.eos_token)[0]
+        messages.append({'role': 'user', 'content': query})
+        messages.append({'role': 'assistant', 'content': response})
+        return response, messages
+
+    @torch.no_grad()
+    def stream_chat(self,
+                    tokenizer,
+                    query: str,
+                    messages: List[dict] = None,
+                    max_new_tokens: int = 1024,
+                    do_sample: bool = True,
+                    temperature: float = 0.8,
+                    top_p: float = 0.8,
+                    **kwargs):
+
+        response_queue = queue.Queue(maxsize=20)
+        if messages is None:
+            messages = [{'role': 'system', 'content': NANBEIGE_SYSTEM_PROMPT}]
+
+        class ChatStreamer(BaseStreamer):
+            def __init__(self, tokenizer) -> None:
+                super().__init__()
+                self.tokenizer = tokenizer
+                self.queue = response_queue
+                self.query = query
+                self.messages = messages
+                self.response = ""
+                self.received_inputs = False
+                self.queue.put((self.response, messages + [{'role': 'user', 'content': self.query},
+                                                           {'role': 'assistant', 'content': self.response}]))
+
+            def put(self, value):
+                if len(value.shape) > 1 and value.shape[0] > 1:
+                    raise ValueError("ChatStreamer only supports batch size 1")
+                elif len(value.shape) > 1:
+                    value = value[0]
+
+                if not self.received_inputs:
+                    # The first received value is input_ids, ignore here
+                    self.received_inputs = True
+                    return
+
+                token = self.tokenizer.decode([value[-1]], skip_special_tokens=True)
+                if token.strip() != "</s>":
+                    self.response = self.response + token
+                    messages = self.messages + [{'role': 'user', 'content': self.query},
+                                                {'role': 'assistant', 'content': self.response}]
+                    self.queue.put((self.response, messages))
+
+            def end(self):
+                self.queue.put(None)
+
+        def stream_task():
+            return self.chat(
+                tokenizer=tokenizer,
+                query=query,
+                messages=messages,
+                streamer=ChatStreamer(tokenizer=tokenizer),
+                max_new_tokens=max_new_tokens,
+                do_sample=do_sample,
+                temperature=temperature,
+                top_p=top_p,
+                **kwargs
+            )
+
+        def consumer():
+            threading.Thread(target=stream_task).start()
+            while True:
+                res = response_queue.get()
+                if res is None:
+                    return
+                yield res
+
+        return consumer()
+
+
+class NanbeigeForSequenceClassification(NanbeigePreTrainedModel):
+    _keys_to_ignore_on_load_missing = [r"lm_head.weight"]
+
+    def __init__(self, config):
+        super().__init__(config)
+        self.num_labels = config.num_labels
+        self.model = NanbeigeModel(config)
+        self.score = nn.Linear(config.hidden_size, self.num_labels, bias=False)
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def get_input_embeddings(self):
+        return self.model.embed_tokens
+
+    def set_input_embeddings(self, value):
+        self.model.embed_tokens = value
+
+    def forward(
+            self,
+            input_ids: torch.LongTensor = None,
+            attention_mask: Optional[torch.Tensor] = None,
+            position_ids: Optional[torch.LongTensor] = None,
+            past_key_values: Optional[List[torch.FloatTensor]] = None,
+            inputs_embeds: Optional[torch.FloatTensor] = None,
+            labels: Optional[torch.LongTensor] = None,
+            use_cache: Optional[bool] = None,
+            output_attentions: Optional[bool] = None,
+            output_hidden_states: Optional[bool] = None,
+            return_dict: Optional[bool] = None,
+    ) -> Union[Tuple, SequenceClassifierOutputWithPast]:
+        r"""
+        labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+            Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
+            config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+            `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+        """
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        transformer_outputs = self.model(
+            input_ids,
+            attention_mask=attention_mask,
+            position_ids=position_ids,
+            past_key_values=past_key_values,
+            inputs_embeds=inputs_embeds,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+        hidden_states = transformer_outputs[0]
+        logits = self.score(hidden_states)
+
+        if input_ids is not None:
+            batch_size = input_ids.shape[0]
+        else:
+            batch_size = inputs_embeds.shape[0]
+
+        if self.config.pad_token_id is None and batch_size != 1:
+            raise ValueError("Cannot handle batch sizes > 1 if no padding token is defined.")
+        if self.config.pad_token_id is None:
+            sequence_lengths = -1
+        else:
+            if input_ids is not None:
+                sequence_lengths = (torch.ne(input_ids, self.config.pad_token_id).sum(-1) - 1).to(logits.device)
+            else:
+                sequence_lengths = -1
+
+        pooled_logits = logits[torch.arange(batch_size, device=logits.device), sequence_lengths]
+
+        loss = None
+        if labels is not None:
+            labels = labels.to(logits.device)
+            if self.config.problem_type is None:
+                if self.num_labels == 1:
+                    self.config.problem_type = "regression"
+                elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
+                    self.config.problem_type = "single_label_classification"
+                else:
+                    self.config.problem_type = "multi_label_classification"
+
+            if self.config.problem_type == "regression":
+                loss_fct = MSELoss()
+                if self.num_labels == 1:
+                    loss = loss_fct(pooled_logits.squeeze(), labels.squeeze())
+                else:
+                    loss = loss_fct(pooled_logits, labels)
+            elif self.config.problem_type == "single_label_classification":
+                loss_fct = CrossEntropyLoss()
+                loss = loss_fct(pooled_logits.view(-1, self.num_labels), labels.view(-1))
+            elif self.config.problem_type == "multi_label_classification":
+                loss_fct = BCEWithLogitsLoss()
+                loss = loss_fct(pooled_logits, labels)
+        if not return_dict:
+            output = (pooled_logits,) + transformer_outputs[1:]
+            return ((loss,) + output) if loss is not None else output
+
+        return SequenceClassifierOutputWithPast(
+            loss=loss,
+            logits=pooled_logits,
+            past_key_values=transformer_outputs.past_key_values,
+            hidden_states=transformer_outputs.hidden_states,
+            attentions=transformer_outputs.attentions,
+        )
+

output-00001-of-00002.safetensors

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

output-00002-of-00002.safetensors

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

special_tokens_map.json

@@ -0,0 +1,27 @@
+{
+  "additional_special_tokens": [
+    {
+      "content": "<|endoftext|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false
+    }
+  ],
+  "bos_token": "<|im_start|>",
+  "eos_token": "<|im_end|>",
+  "pad_token": {
+    "content": "<unk>",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  },
+  "unk_token": {
+    "content": "<unk>",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  }
+}

tokenizer.model

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

tokenizer_config.json

@@ -0,0 +1,71 @@
+{
+  "add_bos_token": false,
+  "add_eos_token": false,
+  "added_tokens_decoder": {
+    "0": {
+      "content": "<unk>",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "1": {
+      "content": "<s>",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "2": {
+      "content": "</s>",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "58978": {
+      "content": "<|im_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "58979": {
+      "content": "<|im_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "58980": {
+      "content": "<|endoftext|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "additional_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|endoftext|>"
+  ],
+  "bos_token": "<|im_start|>",
+  "chat_template": "{% for message in messages %}{% if loop.first and messages[0]['role'] != 'system' %}{{ '<|im_start|>system\n你是一个名为\"南北阁\"的人工智能助手，正在与人类用户进行交谈。你的目标是以最有帮助和最逻辑的方式回答问题，同时确保内容的安全性。你的回答中不应包含任何有害、政治化、宗教化、不道德、种族主义、非法的内容。请确保你的回答不带有社会偏见，符合社会主义价值观。如果遇到的问题无意义或事实上不连贯，请不要回答错误的内容，而是解释问题为何无效或不连贯。如果你不知道问题的答案，也请勿提供错误的信息。<|im_end|>\n' }}{% endif %}{{'<|im_start|>' + message['role'] + '\n' + message['content'].strip() + '<|im_end|>' + '\n'}}{% endfor %}{% if (add_generation_prompt is defined and add_generation_prompt) %}{{ '<|im_start|>assistant\n' }}{% endif %}",
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "legacy": true,
+  "model_max_length": 4096,
+  "pad_token": "<unk>",
+  "sp_model_kwargs": {},
+  "spaces_between_special_tokens": false,
+  "tokenizer_class": "LlamaTokenizer",
+  "unk_token": "<unk>",
+  "use_default_system_prompt": false
+}