Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,10 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+image-1.png filter=lfs diff=lfs merge=lfs -text
+image-10.png filter=lfs diff=lfs merge=lfs -text
+image-11.png filter=lfs diff=lfs merge=lfs -text
+image-16.png filter=lfs diff=lfs merge=lfs -text
+image-18.png filter=lfs diff=lfs merge=lfs -text
+image-9.png filter=lfs diff=lfs merge=lfs -text
+tokenizer.json filter=lfs diff=lfs merge=lfs -text

1_Pooling/config.json

@@ -0,0 +1,10 @@
+{
+  "word_embedding_dimension": 3584,
+  "pooling_mode_cls_token": false,
+  "pooling_mode_mean_tokens": true,
+  "pooling_mode_max_tokens": false,
+  "pooling_mode_mean_sqrt_len_tokens": false,
+  "pooling_mode_weightedmean_tokens": false,
+  "pooling_mode_lasttoken": false,
+  "include_prompt": true
+}

README.md

@@ -1,3 +1,206 @@
----
-license: apache-2.0
----
+
+# QZhou-Embedding
+<div align="center">
+<img src="image-1.png" width="800" height="300"></img>
+</div>
+
+## Introduction
+We have released <a href="https://huggingface.co/Kingsoft-LLM/QZhou-Embedding">QZhou-Embedding</a> (called "Qingzhou Embedding"), a large-scale text embedding model designed for general use，excelling at various text embedding tasks (retrieval, re-ranking, sentence similarity, and classification). Leveraging the general language capabilities of its underlying model, and pre-trained on massive amounts of text, QZhou-Embedding achieves even more powerful text embedding representations. QZhou-Embedding is continuously trained using millions of high-quality open-source embedding datasets and over 5 million high-quality synthetic data (using two synthetic techniques: rewriting and expansion). Initial retrieval training provides the model with a foundation for query-doc semantic matching capabilities. Later, multi-dimensional training such as STS and clustering, helps the model achieve continuous breakthroughs in various tasks. QZhou-Embedding is a 7B model and can embed long text vectors up to 8k in size. It achieved the highest average score on the mteb/cmteb evaluation benchmarks. In terms of various task scores, its clustering, sentence pair classification, rearrangement, and STS task achieved the highest average scores.
+## Basic Features
+
+- Powerful text embedding capabilities；
+- Long context: up to 8k context length；
+- 7B parameter size
+
+
+## Technical Introduction
+### Unified Task Modeling Framework
+We unify the text embedding objectives into three major modeling optimization issues and propose a unified training data structured solution and corresponding training mechanism. This approach can integrate most open source data as retrieval training sets. The structured data can be as follows:
+- Retrieval
+  - title-body
+  - title-abstract
+  - Question Answering Dataset
+  - Reading comprehension
+  - ...
+
+- STS
+  - text pair + label in {true, false}、{yes, no}
+  - text pair + score（such as 0.2, 3.1. 4.8, etc.）
+  - NLI dataset：text pair + label in {'entailment', 'neutral', 'contradiction'}
+
+- CLS
+  - text+CLS label
+
+<div align="center"><img src="image-18.png" width="1000" height="600"></img></div>
+<div align="center"><img src="image-16.png" width="1000" height="550"></img></div>
+
+### Training Objectives
+
+- Retrieval: Apply InfoNCE contrastive loss function, and follow the gte/qwen3-embedding to add the query-query negative as part of the denominator.<br>
+$$
+L_{ret}=-\frac{1}{n}\sum_{i} log{\frac{e^{sim(q_i,d_i^+)/\tau}}{e^{sim(q_i,d_i^+)/\tau}+\sum_{j}e^{sim(q_i,d_j^-)/\tau}+\sum_{j≠i}e^{sim(q_i,q_j)/\tau}}}
+$$
+
+- STS：Apply Cosent loss：
+$$
+L_{cosent}=log \bigg(1+\sum_{sim(i,j)>sim(k,l)}exp(\frac{sim(x_k, x_l)-sim(x_i,x_j)}{\tau})\bigg)
+$$
+
+- CLS: Apply the same InfoNCE loss as retrieval, but for In-Batch Negative, due to the high probability of same-class conflicts, a mask mechanism is used to cover up similar samples in negative examples shared by different samples.
+$$
+L_{ret}=-\frac{1}{n}\sum_{i} log{\frac{e^{sim(t_i,t_i^+)/\tau}}{e^{sim(t_i,t_i^+)/\tau}+\sum_{n}MASK(t_i,t_{i,n}^-)·e^{sim(t_i,t_{i,n}^-)/\tau}+\sum_{j≠i}MASK(t_i,t_j)·e^{sim(t_i,t_j)/\tau}+\sum_{j≠i}\sum_{n}MASK(t_i,t_{j,n}^-)e^{sim(t_i,t_{j,n}^-)/\tau}}}
+$$
+$$
+where\:\:C_{t_i}=C_{t_i^+}
+$$
+$$
+MASK(t_i, t_j)=
+\begin{cases}
+0 & \quad \text{if } C_{t_i}=C_{t_j}, \\
+1 & \quad \text{otherwise}
+\end{cases}
+$$
+Where $C_{t_i}$ represents the class label of sample $t_i$ , and $n$ is the number of negative samples for a single data point.
+### Feature Enhancement Data Synthesis Technology
+In the context of powerful languages and writing capabilities in LLMs, we've fully leveraged the LLMs API to propose a data synthesis technology. To address issues like limited data and narrow topics/features in training sets, we've proposed rewriting and expanding synthesis techniques. Furthermore, to increase the difficulty of negative examples during training, we've designed a hard negative example synthesis technology based on big models, combined with existing strong retriever-based hard negative examples sampling. Several of these technologies are described below:
+<div align="center"><img src="image-9.png" width="930" height="290"></img></div>
+<div align="center"><img src="image-10.png" width="880" height="220"></img></div>
+<div align="center"><img src="image-11.png" width="880" height="210"></img></div>
+
+For more details, including reproduction of evaluation results, Instruction content and adding method, please refer to our <a href="https://github.com/Kingsoft-LLM/QZhou-Embedding">GitHub</a> repo, thanks! 
+
+## Evaluation Results
+### mteb details
+<div align="center"><img src="image-7.png" width="1100" height="260"></img></div>
+
+### cmteb details
+<div align="center"><img src="image-8.png" width="1000" height="260"></img></div>
+
+## Usage
+### Completely reproduce the benchmark results
+We provide detailed parameters and environment configurations so that you can run results that are completely consistent with the mteb leaderboard on your own machine, including configurations such as environment dependencies and model arguments.
+#### Requirements
+- Python: 3.10.12
+- Sentence Transformers: 3.4.1
+- Transformers: 4.51.1
+- PyTorch: 2.7.1
+- Accelerate: 1.3.0
+- Datasets: 3.2.0
+- Tokenizers: 0.21.2
+#### Transformers model load arguments
+torch_dtype=torch.bfloat16<br>
+attn_implementation='sdpa'<br>
+**NOTE：** The ranking results use the sdpa mode. Other modes ('eager', 'flash_attention_2') may have deviations in results, but still keep the overall performance consistent.
+#### Instruction Adding Rules
+Details can be found on our <a href="https://github.com/Kingsoft-LLM/QZhou-Embedding">GitHub</a>.
+#### Evaluation code usage
+Find our benchmark evaluation code on <a href="https://github.com/Kingsoft-LLM/QZhou-Embedding">GitHub</a>. The mteb benchmark script is **run_mteb_all_v2.py**, and the cmteb benchmark script is **run_cmteb_all.py**. Run the following command:
+```
+POOLING_MODE=mean
+normalize=true
+use_instruction=true
+export TOKENIZERS_PARALLELISM=true
+
+model_name_or_path=<model dir>
+
+python3 ./run_cmteb_all.py \
+    --model_name_or_path ${model_name_or_path}  \
+    --pooling_mode ${POOLING_MODE} \
+    --normalize ${normalize} \
+    --use_instruction ${use_instruction} \
+    --output_dir <output dir>
+
+python3 ./run_mteb_all_v2.py \
+    --model_name_or_path ${model_name_or_path}  \
+    --pooling_mode ${POOLING_MODE} \
+    --normalize ${normalize} \
+    --use_instruction ${use_instruction} \
+    --output_dir <output dir>
+```
+The "<>" should be replaced with your actual setting.<br>
+This is a general script that can be used to evaluate other huggingface embedding models, but you need to ensure that the pooling and other configurations are correct.
+
+### Sentence-transformers
+
+```
+from sentence_transformers import SentenceTransformer
+
+model = SentenceTransformer("QZhou-Embedding")
+
+model = SentenceTransformer(
+    "QZhou-Embedding",
+    model_kwargs={"device_map": "auto", "trust_remote_code": True},
+    tokenizer_kwargs={"padding_side": "left", "trust_remote_code": True},
+    trust_remote_code=True
+)
+
+queries = [
+    "What is photosynthesis?",
+    "Who invented the telephone?",
+]
+documents = [
+    "Photosynthesis is the process by which green plants use sunlight, carbon dioxide, and water to produce glucose and oxygen. This biochemical reaction occurs in chloroplasts.",
+    "Alexander Graham Bell is credited with inventing the first practical telephone in 1876, receiving US patent number 174,465 for his device."
+]
+
+query_embeddings = model.encode(queries, prompt_name="query", normalize_embeddings=True)
+document_embeddings = model.encode(documents, normalize_embeddings=True)
+
+similarity = model.similarity(query_embeddings, document_embeddings)
+```
+
+### Huggingface Transformers
+
+```
+import torch
+import torch.nn.functional as F
+
+from torch import Tensor
+from transformers import AutoTokenizer, AutoModel
+
+
+def last_token_pool(last_hidden_states: Tensor,
+                 attention_mask: Tensor) -> Tensor:
+    left_padding = (attention_mask[:, -1].sum() == attention_mask.shape[0])
+    if left_padding:
+        return last_hidden_states[:, -1]
+    else:
+        sequence_lengths = attention_mask.sum(dim=1) - 1
+        batch_size = last_hidden_states.shape[0]
+        return last_hidden_states[torch.arange(batch_size, device=last_hidden_states.device), sequence_lengths]
+
+
+def get_detailed_instruct(task_description: str, query: str) -> str:
+    return f'Instruct: {task_description}\nQuery:{query}'
+
+task = 'Given a web search query, retrieve relevant passages that answer the query'
+
+queries = [
+    get_detailed_instruct(task, 'What is photosynthesis?'),
+    get_detailed_instruct(task, 'Who invented the telephone?')
+]
+
+documents = [
+    "Photosynthesis is the process by which green plants use sunlight, carbon dioxide, and water to produce glucose and oxygen. This biochemical reaction occurs in chloroplasts.",
+    "Alexander Graham Bell is credited with inventing the first practical telephone in 1876, receiving US patent number 174,465 for his device."
+]
+
+input_texts = queries + documents
+
+tokenizer = AutoTokenizer.from_pretrained('QZhou-Embedding', padding_side='left', trust_remote_code=True)
+model = AutoModel.from_pretrained('QZhou-Embedding', trust_remote_code=True, device_map='auto')
+
+batch_dict = tokenizer(
+    input_texts,
+    padding=True,
+    truncation=True,
+    max_length=8192,
+    return_tensors="pt",
+)
+batch_dict.to(model.device)
+outputs = model(**batch_dict)
+embeddings = last_token_pool(outputs.last_hidden_state, batch_dict['attention_mask'])
+
+embeddings = F.normalize(embeddings, p=2, dim=1)
+scores = (embeddings[:2] @ embeddings[2:].T)
+```

README_zh.md

@@ -0,0 +1,207 @@
+
+# QZhou-Embedding
+<div align="center">
+<img src="image-1.png" width="800" height="300"></img>
+</div>
+
+## 简介
+我们发布<a href="https://huggingface.co/Kingsoft-LLM/QZhou-Embedding">QZhou-Embedding</a>(轻舟Embedding😈😈😈)，面向通用领域的文本向量表示大模型，擅长各种文本嵌入（检索、重排、句对相似度、分类）任务。得益于基础模型在海量文本上预训练获得的通用语言能力，QZhou-Embedding能够获得更加强大的文本嵌入表示。QZhou-Embedding使用百万量级高质量开源检索数据，以及500万+高质量合成数据（改写、扩展两大合成技术）进行持续训练。我们通过第一阶段检索训练为模型提供query-doc语义匹配能力基础，第二阶段的STS、聚类等多维度能力训练帮助模型在各种场景下持续突破。QZhou-Embedding的模型参数为7B，具备最大8k的长文本向量嵌入能力。在mteb/cmteb评测基准上取得均值全榜最高，各任务指标方面，聚类、句对分类、重排、STS任务指标均值全榜最高的效果。
+
+## QZhou-Embedding基本特点
+
+- 强大的文本嵌入能力；
+- 长上下文：最大支持8k；
+- 参数量7B
+
+
+## 技术介绍
+### 统一任务建模框架
+将文本嵌入目标统一为三大问题建模优化，提出统一的训练数据结构化方案和对应的训练机制---可融入大部分开源数据作为检索训练集，可结构化数据如下：
+- 检索
+  - title-body
+  - title-abstract
+  - 问答类数据
+  - 阅读理解
+  - ...
+
+- STS
+  - 文本对+{true, false}、{yes, no}标签
+  - 文本对+分数（如0.2、3.1、4.8等）
+  - NLI数据：文本对+{'entailment', 'neutral', 'contradiction'}标签
+
+- CLS
+  - 句子+类标签
+
+<div align="center"><img src="image-18.png" width="1000" height="600"></img></div>
+<div align="center"><img src="image-16.png" width="1000" height="550"></img></div>
+
+### 训练目标
+
+- 检索：使用InfoNCE对比学习loss函数，效仿gte/qwen3-embedding的改进增加q-q对负样例惩罚<br>
+$$
+L_{ret}=-\frac{1}{n}\sum_{i} log{\frac{e^{sim(q_i,d_i^+)/\tau}}{e^{sim(q_i,d_i^+)/\tau}+\sum_{j}e^{sim(q_i,d_j^-)/\tau}+\sum_{j≠i}e^{sim(q_i,q_j)/\tau}}}
+$$
+
+- STS：使用Cosent loss：
+$$
+L_{cosent}=log \bigg(1+\sum_{sim(i,j)>sim(k,l)}exp(\frac{sim(x_k, x_l)-sim(x_i,x_j)}{\tau})\bigg)
+$$
+
+- CLS：同检索一致使用InfoNCE loss，但In-Batch Negative时由于同类冲突概率大，使用mask机制掩盖不同样本共享的负样例中的同类样本。
+$$
+L_{ret}=-\frac{1}{n}\sum_{i} log{\frac{e^{sim(t_i,t_i^+)/\tau}}{e^{sim(t_i,t_i^+)/\tau}+\sum_{n}MASK(t_i,t_{i,n}^-)·e^{sim(t_i,t_{i,n}^-)/\tau}+\sum_{j≠i}MASK(t_i,t_j)·e^{sim(t_i,t_j)/\tau}+\sum_{j≠i}\sum_{n}MASK(t_i,t_{j,n}^-)e^{sim(t_i,t_{j,n}^-)/\tau}}}
+$$
+$$
+其中C_{t_i}=C_{t_i^+}
+$$
+$$
+MASK(t_i, t_j)=
+\begin{cases}
+0 & \quad \text{if } C_{t_i}=C_{t_j}, \\
+1 & \quad \text{otherwise}
+\end{cases}
+$$
+其中${C_{t_i}}$表示样本${t_i}$的类标签，n是单条数据的负样本数。
+
+### 特征增强数据合成技术
+在当今大模型语言及创作能力强大的背景下，我们充分利用了大模型API设计数据合成技术。针对训练集中存在数据少、话题狭隘等问题，我们提出改写、扩展合成技术；同时为增强训练时的负样例难度，我们在现有基于强大Embedding实现难负例采样的基础上，使用基于大模型的难负样例合成技术。几种技术介绍如下：
+<div align="center"><img src="image-9.png" width="930" height="290"></img></div>
+<div align="center"><img src="image-10.png" width="880" height="220"></img></div>
+<div align="center"><img src="image-11.png" width="880" height="210"></img></div>
+
+想要获取更多信息（如评测脚本、指令格式等），欢迎访问我们的Github：<a href="https://github.com/Kingsoft-LLM/QZhou-Embedding">GitHub</a>
+
+## 评测结果
+### mteb榜单明细
+<div align="center"><img src="image-7.png" width="1100" height="260"></img></div>
+
+### cmteb榜单明细
+<div align="center"><img src="image-8.png" width="1000" height="260"></img></div>
+
+## 使用指南
+### 完全复现榜单结果
+我们提供详细的参数、环境配置，以便能够在自己的机器上完全跑出跟榜单一致的结果，包括环境依赖、模型参数等配置。
+#### 环境依赖版本
+- Python: 3.10.12
+- Sentence Transformers: 3.4.1
+- Transformers: 4.51.1
+- PyTorch: 2.7.1
+- Accelerate: 1.3.0
+- Datasets: 3.2.0
+- Tokenizers: 0.21.2
+#### 模型加载参数
+torch_dtype=torch.bfloat16<br>
+attn_implementation='sdpa'<br>
+**注：** 榜单结果使用了sdpa模式，其他模式('eager'、 'flash_attention_2')存在偏差，但不影响整体表现
+#### 指令添加规则
+在我们的<a href="https://github.com/Kingsoft-LLM/QZhou-Embedding">GitHub</a>上可以找到。
+#### 评测代码使用
+在<a href="https://github.com/Kingsoft-LLM/QZhou-Embedding">GitHub</a>上找到我们的评测代码，其中mteb评测脚本是**run_mteb_all_v2.py**，cmteb评测脚本是**run_cmteb_all.py**，运行如下命令：
+```
+POOLING_MODE=mean
+normalize=true
+use_instruction=true
+export TOKENIZERS_PARALLELISM=true
+
+model_name_or_path=模型目录位置
+
+python3 ./run_cmteb_all.py \
+    --model_name_or_path ${model_name_or_path}  \
+    --pooling_mode ${POOLING_MODE} \
+    --normalize ${normalize} \
+    --use_instruction ${use_instruction} \
+    --output_dir 结果输出路径
+
+python3 ./run_mteb_all_v2.py \
+    --model_name_or_path ${model_name_or_path}  \
+    --pooling_mode ${POOLING_MODE} \
+    --normalize ${normalize} \
+    --use_instruction ${use_instruction} \
+    --output_dir 结果输出路径
+```
+这是一套通用脚本，可以用于其他huggingface embedding模型的评测，但需要确保pooling等配置正确。
+
+### Sentence Transformers
+
+```
+from sentence_transformers import SentenceTransformer
+
+model = SentenceTransformer("QZhou-Embedding")
+
+model = SentenceTransformer(
+    "QZhou-Embedding",
+    model_kwargs={"device_map": "auto", "trust_remote_code": True},
+    tokenizer_kwargs={"padding_side": "left", "trust_remote_code": True},
+    trust_remote_code=True
+)
+
+queries = [
+    "What is photosynthesis?",
+    "Who invented the telephone?",
+]
+documents = [
+    "Photosynthesis is the process by which green plants use sunlight, carbon dioxide, and water to produce glucose and oxygen. This biochemical reaction occurs in chloroplasts.",
+    "Alexander Graham Bell is credited with inventing the first practical telephone in 1876, receiving US patent number 174,465 for his device."
+]
+
+query_embeddings = model.encode(queries, prompt_name="query", normalize_embeddings=True)
+document_embeddings = model.encode(documents, normalize_embeddings=True)
+
+similarity = model.similarity(query_embeddings, document_embeddings)
+```
+
+### Huggingface Transformers
+
+```
+import torch
+import torch.nn.functional as F
+
+from torch import Tensor
+from transformers import AutoTokenizer, AutoModel
+
+
+def last_token_pool(last_hidden_states: Tensor,
+                 attention_mask: Tensor) -> Tensor:
+    left_padding = (attention_mask[:, -1].sum() == attention_mask.shape[0])
+    if left_padding:
+        return last_hidden_states[:, -1]
+    else:
+        sequence_lengths = attention_mask.sum(dim=1) - 1
+        batch_size = last_hidden_states.shape[0]
+        return last_hidden_states[torch.arange(batch_size, device=last_hidden_states.device), sequence_lengths]
+
+
+def get_detailed_instruct(task_description: str, query: str) -> str:
+    return f'Instruct: {task_description}\nQuery:{query}'
+
+task = 'Given a web search query, retrieve relevant passages that answer the query'
+
+queries = [
+    get_detailed_instruct(task, 'What is photosynthesis?'),
+    get_detailed_instruct(task, 'Who invented the telephone?')
+]
+
+documents = [
+    "Photosynthesis is the process by which green plants use sunlight, carbon dioxide, and water to produce glucose and oxygen. This biochemical reaction occurs in chloroplasts.",
+    "Alexander Graham Bell is credited with inventing the first practical telephone in 1876, receiving US patent number 174,465 for his device."
+]
+
+input_texts = queries + documents
+
+tokenizer = AutoTokenizer.from_pretrained('QZhou-Embedding', padding_side='left', trust_remote_code=True)
+model = AutoModel.from_pretrained('QZhou-Embedding', trust_remote_code=True, device_map='auto')
+
+batch_dict = tokenizer(
+    input_texts,
+    padding=True,
+    truncation=True,
+    max_length=8192,
+    return_tensors="pt",
+)
+batch_dict.to(model.device)
+outputs = model(**batch_dict)
+embeddings = last_token_pool(outputs.last_hidden_state, batch_dict['attention_mask'])
+
+embeddings = F.normalize(embeddings, p=2, dim=1)
+scores = (embeddings[:2] @ embeddings[2:].T)
+```

added_tokens.json

@@ -0,0 +1,24 @@
+{
+  "</tool_call>": 151658,
+  "<tool_call>": 151657,
+  "<|box_end|>": 151649,
+  "<|box_start|>": 151648,
+  "<|endoftext|>": 151643,
+  "<|file_sep|>": 151664,
+  "<|fim_middle|>": 151660,
+  "<|fim_pad|>": 151662,
+  "<|fim_prefix|>": 151659,
+  "<|fim_suffix|>": 151661,
+  "<|im_end|>": 151645,
+  "<|im_start|>": 151644,
+  "<|image_pad|>": 151655,
+  "<|object_ref_end|>": 151647,
+  "<|object_ref_start|>": 151646,
+  "<|quad_end|>": 151651,
+  "<|quad_start|>": 151650,
+  "<|repo_name|>": 151663,
+  "<|video_pad|>": 151656,
+  "<|vision_end|>": 151653,
+  "<|vision_pad|>": 151654,
+  "<|vision_start|>": 151652
+}

config.json

@@ -0,0 +1,31 @@
+{
+  "architectures": [
+    "QZhouModel"
+  ],
+  "attention_dropout": 0.0,
+  "auto_map": {
+    "AutoModel": "modeling_qzhou.QZhouModel"
+  },
+  "bos_token_id": 151643,
+  "eos_token_id": 151643,
+  "hidden_act": "silu",
+  "hidden_size": 3584,
+  "initializer_range": 0.02,
+  "intermediate_size": 18944,
+  "max_position_embeddings": 32768,
+  "max_window_layers": 28,
+  "model_type": "qwen2",
+  "num_attention_heads": 28,
+  "num_hidden_layers": 28,
+  "num_key_value_heads": 4,
+  "rms_norm_eps": 1e-06,
+  "rope_scaling": null,
+  "rope_theta": 1000000.0,
+  "sliding_window": 131072,
+  "tie_word_embeddings": false,
+  "torch_dtype": "bfloat16",
+  "transformers_version": "4.51.1",
+  "use_cache": true,
+  "use_sliding_window": false,
+  "vocab_size": 152064
+}

config_sentence_transformers.json

@@ -0,0 +1,12 @@
+{
+  "__version__": {
+    "sentence_transformers": "3.4.1",
+    "transformers": "4.51.1",
+    "pytorch": "2.4.1+cu121"
+  },
+  "prompts": {
+    "query": "Instruct: Given a web search query, retrieve relevant passages that answer the query\nQuery: "
+  },
+  "default_prompt_name": null,
+  "similarity_fn_name": "cosine"
+}

model.safetensors.index.json

@@ -0,0 +1,345 @@
+{
+  "metadata": {
+    "total_size": 14141238272
+  },
+  "weight_map": {
+    "embed_tokens.weight": "model-00001-of-00003.safetensors",
+    "layers.0.input_layernorm.weight": "model-00001-of-00003.safetensors",
+    "layers.0.mlp.down_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.0.mlp.gate_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.0.mlp.up_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.0.post_attention_layernorm.weight": "model-00001-of-00003.safetensors",
+    "layers.0.self_attn.k_proj.bias": "model-00001-of-00003.safetensors",
+    "layers.0.self_attn.k_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.0.self_attn.o_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.0.self_attn.q_proj.bias": "model-00001-of-00003.safetensors",
+    "layers.0.self_attn.q_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.0.self_attn.v_proj.bias": "model-00001-of-00003.safetensors",
+    "layers.0.self_attn.v_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.1.input_layernorm.weight": "model-00001-of-00003.safetensors",
+    "layers.1.mlp.down_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.1.mlp.gate_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.1.mlp.up_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.1.post_attention_layernorm.weight": "model-00001-of-00003.safetensors",
+    "layers.1.self_attn.k_proj.bias": "model-00001-of-00003.safetensors",
+    "layers.1.self_attn.k_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.1.self_attn.o_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.1.self_attn.q_proj.bias": "model-00001-of-00003.safetensors",
+    "layers.1.self_attn.q_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.1.self_attn.v_proj.bias": "model-00001-of-00003.safetensors",
+    "layers.1.self_attn.v_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.10.input_layernorm.weight": "model-00002-of-00003.safetensors",
+    "layers.10.mlp.down_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.10.mlp.gate_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.10.mlp.up_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.10.post_attention_layernorm.weight": "model-00002-of-00003.safetensors",
+    "layers.10.self_attn.k_proj.bias": "model-00002-of-00003.safetensors",
+    "layers.10.self_attn.k_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.10.self_attn.o_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.10.self_attn.q_proj.bias": "model-00002-of-00003.safetensors",
+    "layers.10.self_attn.q_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.10.self_attn.v_proj.bias": "model-00002-of-00003.safetensors",
+    "layers.10.self_attn.v_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.11.input_layernorm.weight": "model-00002-of-00003.safetensors",
+    "layers.11.mlp.down_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.11.mlp.gate_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.11.mlp.up_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.11.post_attention_layernorm.weight": "model-00002-of-00003.safetensors",
+    "layers.11.self_attn.k_proj.bias": "model-00002-of-00003.safetensors",
+    "layers.11.self_attn.k_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.11.self_attn.o_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.11.self_attn.q_proj.bias": "model-00002-of-00003.safetensors",
+    "layers.11.self_attn.q_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.11.self_attn.v_proj.bias": "model-00002-of-00003.safetensors",
+    "layers.11.self_attn.v_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.12.input_layernorm.weight": "model-00002-of-00003.safetensors",
+    "layers.12.mlp.down_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.12.mlp.gate_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.12.mlp.up_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.12.post_attention_layernorm.weight": "model-00002-of-00003.safetensors",
+    "layers.12.self_attn.k_proj.bias": "model-00002-of-00003.safetensors",
+    "layers.12.self_attn.k_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.12.self_attn.o_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.12.self_attn.q_proj.bias": "model-00002-of-00003.safetensors",
+    "layers.12.self_attn.q_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.12.self_attn.v_proj.bias": "model-00002-of-00003.safetensors",
+    "layers.12.self_attn.v_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.13.input_layernorm.weight": "model-00002-of-00003.safetensors",
+    "layers.13.mlp.down_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.13.mlp.gate_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.13.mlp.up_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.13.post_attention_layernorm.weight": "model-00002-of-00003.safetensors",
+    "layers.13.self_attn.k_proj.bias": "model-00002-of-00003.safetensors",
+    "layers.13.self_attn.k_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.13.self_attn.o_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.13.self_attn.q_proj.bias": "model-00002-of-00003.safetensors",
+    "layers.13.self_attn.q_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.13.self_attn.v_proj.bias": "model-00002-of-00003.safetensors",
+    "layers.13.self_attn.v_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.14.input_layernorm.weight": "model-00002-of-00003.safetensors",
+    "layers.14.mlp.down_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.14.mlp.gate_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.14.mlp.up_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.14.post_attention_layernorm.weight": "model-00002-of-00003.safetensors",
+    "layers.14.self_attn.k_proj.bias": "model-00002-of-00003.safetensors",
+    "layers.14.self_attn.k_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.14.self_attn.o_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.14.self_attn.q_proj.bias": "model-00002-of-00003.safetensors",
+    "layers.14.self_attn.q_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.14.self_attn.v_proj.bias": "model-00002-of-00003.safetensors",
+    "layers.14.self_attn.v_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.15.input_layernorm.weight": "model-00002-of-00003.safetensors",
+    "layers.15.mlp.down_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.15.mlp.gate_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.15.mlp.up_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.15.post_attention_layernorm.weight": "model-00002-of-00003.safetensors",
+    "layers.15.self_attn.k_proj.bias": "model-00002-of-00003.safetensors",
+    "layers.15.self_attn.k_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.15.self_attn.o_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.15.self_attn.q_proj.bias": "model-00002-of-00003.safetensors",
+    "layers.15.self_attn.q_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.15.self_attn.v_proj.bias": "model-00002-of-00003.safetensors",
+    "layers.15.self_attn.v_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.16.input_layernorm.weight": "model-00002-of-00003.safetensors",
+    "layers.16.mlp.down_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.16.mlp.gate_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.16.mlp.up_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.16.post_attention_layernorm.weight": "model-00002-of-00003.safetensors",
+    "layers.16.self_attn.k_proj.bias": "model-00002-of-00003.safetensors",
+    "layers.16.self_attn.k_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.16.self_attn.o_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.16.self_attn.q_proj.bias": "model-00002-of-00003.safetensors",
+    "layers.16.self_attn.q_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.16.self_attn.v_proj.bias": "model-00002-of-00003.safetensors",
+    "layers.16.self_attn.v_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.17.input_layernorm.weight": "model-00002-of-00003.safetensors",
+    "layers.17.mlp.down_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.17.mlp.gate_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.17.mlp.up_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.17.post_attention_layernorm.weight": "model-00002-of-00003.safetensors",
+    "layers.17.self_attn.k_proj.bias": "model-00002-of-00003.safetensors",
+    "layers.17.self_attn.k_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.17.self_attn.o_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.17.self_attn.q_proj.bias": "model-00002-of-00003.safetensors",
+    "layers.17.self_attn.q_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.17.self_attn.v_proj.bias": "model-00002-of-00003.safetensors",
+    "layers.17.self_attn.v_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.18.input_layernorm.weight": "model-00003-of-00003.safetensors",
+    "layers.18.mlp.down_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.18.mlp.gate_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.18.mlp.up_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.18.post_attention_layernorm.weight": "model-00003-of-00003.safetensors",
+    "layers.18.self_attn.k_proj.bias": "model-00002-of-00003.safetensors",
+    "layers.18.self_attn.k_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.18.self_attn.o_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.18.self_attn.q_proj.bias": "model-00002-of-00003.safetensors",
+    "layers.18.self_attn.q_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.18.self_attn.v_proj.bias": "model-00002-of-00003.safetensors",
+    "layers.18.self_attn.v_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.19.input_layernorm.weight": "model-00003-of-00003.safetensors",
+    "layers.19.mlp.down_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.19.mlp.gate_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.19.mlp.up_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.19.post_attention_layernorm.weight": "model-00003-of-00003.safetensors",
+    "layers.19.self_attn.k_proj.bias": "model-00003-of-00003.safetensors",
+    "layers.19.self_attn.k_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.19.self_attn.o_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.19.self_attn.q_proj.bias": "model-00003-of-00003.safetensors",
+    "layers.19.self_attn.q_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.19.self_attn.v_proj.bias": "model-00003-of-00003.safetensors",
+    "layers.19.self_attn.v_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.2.input_layernorm.weight": "model-00001-of-00003.safetensors",
+    "layers.2.mlp.down_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.2.mlp.gate_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.2.mlp.up_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.2.post_attention_layernorm.weight": "model-00001-of-00003.safetensors",
+    "layers.2.self_attn.k_proj.bias": "model-00001-of-00003.safetensors",
+    "layers.2.self_attn.k_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.2.self_attn.o_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.2.self_attn.q_proj.bias": "model-00001-of-00003.safetensors",
+    "layers.2.self_attn.q_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.2.self_attn.v_proj.bias": "model-00001-of-00003.safetensors",
+    "layers.2.self_attn.v_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.20.input_layernorm.weight": "model-00003-of-00003.safetensors",
+    "layers.20.mlp.down_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.20.mlp.gate_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.20.mlp.up_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.20.post_attention_layernorm.weight": "model-00003-of-00003.safetensors",
+    "layers.20.self_attn.k_proj.bias": "model-00003-of-00003.safetensors",
+    "layers.20.self_attn.k_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.20.self_attn.o_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.20.self_attn.q_proj.bias": "model-00003-of-00003.safetensors",
+    "layers.20.self_attn.q_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.20.self_attn.v_proj.bias": "model-00003-of-00003.safetensors",
+    "layers.20.self_attn.v_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.21.input_layernorm.weight": "model-00003-of-00003.safetensors",
+    "layers.21.mlp.down_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.21.mlp.gate_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.21.mlp.up_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.21.post_attention_layernorm.weight": "model-00003-of-00003.safetensors",
+    "layers.21.self_attn.k_proj.bias": "model-00003-of-00003.safetensors",
+    "layers.21.self_attn.k_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.21.self_attn.o_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.21.self_attn.q_proj.bias": "model-00003-of-00003.safetensors",
+    "layers.21.self_attn.q_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.21.self_attn.v_proj.bias": "model-00003-of-00003.safetensors",
+    "layers.21.self_attn.v_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.22.input_layernorm.weight": "model-00003-of-00003.safetensors",
+    "layers.22.mlp.down_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.22.mlp.gate_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.22.mlp.up_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.22.post_attention_layernorm.weight": "model-00003-of-00003.safetensors",
+    "layers.22.self_attn.k_proj.bias": "model-00003-of-00003.safetensors",
+    "layers.22.self_attn.k_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.22.self_attn.o_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.22.self_attn.q_proj.bias": "model-00003-of-00003.safetensors",
+    "layers.22.self_attn.q_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.22.self_attn.v_proj.bias": "model-00003-of-00003.safetensors",
+    "layers.22.self_attn.v_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.23.input_layernorm.weight": "model-00003-of-00003.safetensors",
+    "layers.23.mlp.down_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.23.mlp.gate_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.23.mlp.up_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.23.post_attention_layernorm.weight": "model-00003-of-00003.safetensors",
+    "layers.23.self_attn.k_proj.bias": "model-00003-of-00003.safetensors",
+    "layers.23.self_attn.k_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.23.self_attn.o_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.23.self_attn.q_proj.bias": "model-00003-of-00003.safetensors",
+    "layers.23.self_attn.q_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.23.self_attn.v_proj.bias": "model-00003-of-00003.safetensors",
+    "layers.23.self_attn.v_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.24.input_layernorm.weight": "model-00003-of-00003.safetensors",
+    "layers.24.mlp.down_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.24.mlp.gate_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.24.mlp.up_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.24.post_attention_layernorm.weight": "model-00003-of-00003.safetensors",
+    "layers.24.self_attn.k_proj.bias": "model-00003-of-00003.safetensors",
+    "layers.24.self_attn.k_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.24.self_attn.o_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.24.self_attn.q_proj.bias": "model-00003-of-00003.safetensors",
+    "layers.24.self_attn.q_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.24.self_attn.v_proj.bias": "model-00003-of-00003.safetensors",
+    "layers.24.self_attn.v_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.25.input_layernorm.weight": "model-00003-of-00003.safetensors",
+    "layers.25.mlp.down_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.25.mlp.gate_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.25.mlp.up_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.25.post_attention_layernorm.weight": "model-00003-of-00003.safetensors",
+    "layers.25.self_attn.k_proj.bias": "model-00003-of-00003.safetensors",
+    "layers.25.self_attn.k_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.25.self_attn.o_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.25.self_attn.q_proj.bias": "model-00003-of-00003.safetensors",
+    "layers.25.self_attn.q_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.25.self_attn.v_proj.bias": "model-00003-of-00003.safetensors",
+    "layers.25.self_attn.v_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.26.input_layernorm.weight": "model-00003-of-00003.safetensors",
+    "layers.26.mlp.down_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.26.mlp.gate_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.26.mlp.up_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.26.post_attention_layernorm.weight": "model-00003-of-00003.safetensors",
+    "layers.26.self_attn.k_proj.bias": "model-00003-of-00003.safetensors",
+    "layers.26.self_attn.k_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.26.self_attn.o_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.26.self_attn.q_proj.bias": "model-00003-of-00003.safetensors",
+    "layers.26.self_attn.q_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.26.self_attn.v_proj.bias": "model-00003-of-00003.safetensors",
+    "layers.26.self_attn.v_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.27.input_layernorm.weight": "model-00003-of-00003.safetensors",
+    "layers.27.mlp.down_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.27.mlp.gate_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.27.mlp.up_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.27.post_attention_layernorm.weight": "model-00003-of-00003.safetensors",
+    "layers.27.self_attn.k_proj.bias": "model-00003-of-00003.safetensors",
+    "layers.27.self_attn.k_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.27.self_attn.o_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.27.self_attn.q_proj.bias": "model-00003-of-00003.safetensors",
+    "layers.27.self_attn.q_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.27.self_attn.v_proj.bias": "model-00003-of-00003.safetensors",
+    "layers.27.self_attn.v_proj.weight": "model-00003-of-00003.safetensors",
+    "layers.3.input_layernorm.weight": "model-00001-of-00003.safetensors",
+    "layers.3.mlp.down_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.3.mlp.gate_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.3.mlp.up_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.3.post_attention_layernorm.weight": "model-00001-of-00003.safetensors",
+    "layers.3.self_attn.k_proj.bias": "model-00001-of-00003.safetensors",
+    "layers.3.self_attn.k_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.3.self_attn.o_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.3.self_attn.q_proj.bias": "model-00001-of-00003.safetensors",
+    "layers.3.self_attn.q_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.3.self_attn.v_proj.bias": "model-00001-of-00003.safetensors",
+    "layers.3.self_attn.v_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.4.input_layernorm.weight": "model-00001-of-00003.safetensors",
+    "layers.4.mlp.down_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.4.mlp.gate_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.4.mlp.up_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.4.post_attention_layernorm.weight": "model-00001-of-00003.safetensors",
+    "layers.4.self_attn.k_proj.bias": "model-00001-of-00003.safetensors",
+    "layers.4.self_attn.k_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.4.self_attn.o_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.4.self_attn.q_proj.bias": "model-00001-of-00003.safetensors",
+    "layers.4.self_attn.q_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.4.self_attn.v_proj.bias": "model-00001-of-00003.safetensors",
+    "layers.4.self_attn.v_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.5.input_layernorm.weight": "model-00001-of-00003.safetensors",
+    "layers.5.mlp.down_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.5.mlp.gate_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.5.mlp.up_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.5.post_attention_layernorm.weight": "model-00001-of-00003.safetensors",
+    "layers.5.self_attn.k_proj.bias": "model-00001-of-00003.safetensors",
+    "layers.5.self_attn.k_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.5.self_attn.o_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.5.self_attn.q_proj.bias": "model-00001-of-00003.safetensors",
+    "layers.5.self_attn.q_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.5.self_attn.v_proj.bias": "model-00001-of-00003.safetensors",
+    "layers.5.self_attn.v_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.6.input_layernorm.weight": "model-00001-of-00003.safetensors",
+    "layers.6.mlp.down_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.6.mlp.gate_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.6.mlp.up_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.6.post_attention_layernorm.weight": "model-00001-of-00003.safetensors",
+    "layers.6.self_attn.k_proj.bias": "model-00001-of-00003.safetensors",
+    "layers.6.self_attn.k_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.6.self_attn.o_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.6.self_attn.q_proj.bias": "model-00001-of-00003.safetensors",
+    "layers.6.self_attn.q_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.6.self_attn.v_proj.bias": "model-00001-of-00003.safetensors",
+    "layers.6.self_attn.v_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.7.input_layernorm.weight": "model-00001-of-00003.safetensors",
+    "layers.7.mlp.down_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.7.mlp.gate_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.7.mlp.up_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.7.post_attention_layernorm.weight": "model-00001-of-00003.safetensors",
+    "layers.7.self_attn.k_proj.bias": "model-00001-of-00003.safetensors",
+    "layers.7.self_attn.k_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.7.self_attn.o_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.7.self_attn.q_proj.bias": "model-00001-of-00003.safetensors",
+    "layers.7.self_attn.q_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.7.self_attn.v_proj.bias": "model-00001-of-00003.safetensors",
+    "layers.7.self_attn.v_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.8.input_layernorm.weight": "model-00002-of-00003.safetensors",
+    "layers.8.mlp.down_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.8.mlp.gate_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.8.mlp.up_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.8.post_attention_layernorm.weight": "model-00002-of-00003.safetensors",
+    "layers.8.self_attn.k_proj.bias": "model-00001-of-00003.safetensors",
+    "layers.8.self_attn.k_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.8.self_attn.o_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.8.self_attn.q_proj.bias": "model-00001-of-00003.safetensors",
+    "layers.8.self_attn.q_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.8.self_attn.v_proj.bias": "model-00001-of-00003.safetensors",
+    "layers.8.self_attn.v_proj.weight": "model-00001-of-00003.safetensors",
+    "layers.9.input_layernorm.weight": "model-00002-of-00003.safetensors",
+    "layers.9.mlp.down_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.9.mlp.gate_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.9.mlp.up_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.9.post_attention_layernorm.weight": "model-00002-of-00003.safetensors",
+    "layers.9.self_attn.k_proj.bias": "model-00002-of-00003.safetensors",
+    "layers.9.self_attn.k_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.9.self_attn.o_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.9.self_attn.q_proj.bias": "model-00002-of-00003.safetensors",
+    "layers.9.self_attn.q_proj.weight": "model-00002-of-00003.safetensors",
+    "layers.9.self_attn.v_proj.bias": "model-00002-of-00003.safetensors",
+    "layers.9.self_attn.v_proj.weight": "model-00002-of-00003.safetensors",
+    "norm.weight": "model-00003-of-00003.safetensors"
+  }
+}

modeling_qzhou.py

@@ -0,0 +1,934 @@
+
+import math
+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.cache_utils import Cache, DynamicCache, StaticCache
+from transformers.modeling_attn_mask_utils import AttentionMaskConverter
+from transformers.modeling_outputs import (
+    BaseModelOutputWithPast,
+    CausalLMOutputWithPast,
+    SequenceClassifierOutputWithPast,
+    TokenClassifierOutput,
+)
+from transformers.modeling_utils import PreTrainedModel
+from transformers.utils import (
+    add_start_docstrings,
+    add_start_docstrings_to_model_forward,
+    is_flash_attn_2_available,
+    is_flash_attn_greater_or_equal_2_10,
+    logging,
+    replace_return_docstrings,
+)
+from transformers.models.qwen2.configuration_qwen2 import Qwen2Config
+
+if is_flash_attn_2_available():
+    from transformers.modeling_flash_attention_utils import _flash_attention_forward
+
+logger = logging.get_logger(__name__)
+
+
+def _prepare_4d_causal_attention_mask_with_cache_position(
+    attention_mask: torch.Tensor,
+    sequence_length: int,
+    target_length: int,
+    dtype: torch.dtype,
+    device: torch.device,
+    min_dtype: float,
+    cache_position: torch.Tensor,
+    batch_size: int,
+):
+    """
+    Creates a causal 4D mask of shape `(batch_size, 1, query_length, key_value_length)` from a 2D mask of shape
+    `(batch_size, key_value_length)`, or if the input `attention_mask` is already 4D, do nothing.
+
+    Args:
+        attention_mask (`torch.Tensor`):
+            A 2D attention mask of shape `(batch_size, key_value_length)` or a 4D attention mask of shape `(batch_size, 1, query_length, key_value_length)`.
+        sequence_length (`int`):
+            The sequence length being processed.
+        target_length (`int`):
+            The target length: when generating with static cache, the mask should be as long as the static cache, to account for the 0 padding, the part of the cache that is not filled yet.
+        dtype (`torch.dtype`):
+            The dtype to use for the 4D attention mask.
+        device (`torch.device`):
+            The device to plcae the 4D attention mask on.
+        min_dtype (`float`):
+            The minimum value representable with the dtype `dtype`.
+        cache_position (`torch.Tensor`):
+            Indices depicting the position of the input sequence tokens in the sequence.
+        batch_size (`torch.Tensor`):
+            Batch size.
+    """
+    if attention_mask is not None and attention_mask.dim() == 4:
+        # In this case we assume that the mask comes already in inverted form and requires no inversion or slicing.
+        causal_mask = attention_mask
+    else:
+        causal_mask = torch.full((sequence_length, target_length), fill_value=min_dtype, dtype=dtype, device=device)
+        if sequence_length != 1:
+            causal_mask = torch.triu(causal_mask, diagonal=1)
+        causal_mask *= torch.arange(target_length, device=device) > cache_position.reshape(-1, 1)
+        causal_mask = causal_mask[None, None, :, :].expand(batch_size, 1, -1, -1)
+        if attention_mask is not None:
+            causal_mask = causal_mask.clone()  # copy to contiguous memory for in-place edit
+            mask_length = attention_mask.shape[-1]
+            padding_mask = causal_mask[:, :, :, :mask_length] + attention_mask[:, None, None, :]
+            padding_mask = padding_mask == 0
+            causal_mask[:, :, :, :mask_length] = causal_mask[:, :, :, :mask_length].masked_fill(
+                padding_mask, min_dtype
+            )
+
+    return causal_mask
+
+
+def _prepare_4d_attention_mask(mask: torch.Tensor, dtype: torch.dtype, tgt_len: Optional[int] = None):
+    """
+    Creates a non-causal 4D mask of shape `(batch_size, 1, query_length, key_value_length)` from a 2D mask of shape
+    `(batch_size, key_value_length)`
+
+    Args:
+        mask (`torch.Tensor`):
+            A 2D attention mask of shape `(batch_size, key_value_length)`
+        dtype (`torch.dtype`):
+            The torch dtype the created mask shall have.
+        tgt_len (`int`):
+            The target length or query length the created mask shall have.
+    """
+    return AttentionMaskConverter._expand_mask(mask=mask, dtype=dtype, tgt_len=tgt_len)
+
+
+def _prepare_4d_attention_mask_for_sdpa(mask: torch.Tensor, dtype: torch.dtype, tgt_len: Optional[int] = None):
+    """
+    Creates a non-causal 4D mask of shape `(batch_size, 1, query_length, key_value_length)` from a 2D mask of shape
+    `(batch_size, key_value_length)`
+
+    Args:
+        mask (`torch.Tensor`):
+            A 2D attention mask of shape `(batch_size, key_value_length)`
+        dtype (`torch.dtype`):
+            The torch dtype the created mask shall have.
+        tgt_len (`int`):
+            The target length or query length the created mask shall have.
+    """
+    _, key_value_length = mask.shape
+    tgt_len = tgt_len if tgt_len is not None else key_value_length
+
+    is_tracing = (
+        torch.jit.is_tracing()
+        or isinstance(mask, torch.fx.Proxy)
+        or (hasattr(torch, "_dynamo") and torch._dynamo.is_compiling())
+    )
+
+    # torch.jit.trace, symbolic_trace and torchdynamo with fullgraph=True are unable to capture data-dependent controlflows.
+    if not is_tracing and torch.all(mask == 1):
+        return None
+    else:
+        return AttentionMaskConverter._expand_mask(mask=mask, dtype=dtype, tgt_len=tgt_len)
+
+
+class Qwen2RMSNorm(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):
+        input_dtype = hidden_states.dtype
+        hidden_states = hidden_states.to(torch.float32)
+        variance = hidden_states.pow(2).mean(-1, keepdim=True)
+        hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)
+        return self.weight * hidden_states.to(input_dtype)
+
+    def extra_repr(self):
+        return f"{tuple(self.weight.shape)}, eps={self.variance_epsilon}"
+
+
+class Qwen2RotaryEmbedding(nn.Module):
+    def __init__(self, dim, max_position_embeddings=2048, base=10000, device=None):
+        super().__init__()
+
+        self.dim = dim
+        self.max_position_embeddings = max_position_embeddings
+        self.base = base
+        inv_freq = 1.0 / (self.base ** (torch.arange(0, self.dim, 2, dtype=torch.int64).float().to(device) / self.dim))
+        self.register_buffer("inv_freq", inv_freq, persistent=False)
+
+        # Build here to make `torch.jit.trace` work.
+        self._set_cos_sin_cache(
+            seq_len=max_position_embeddings, device=self.inv_freq.device, dtype=torch.get_default_dtype()
+        )
+
+    def _set_cos_sin_cache(self, seq_len, device, dtype):
+        self.max_seq_len_cached = seq_len
+        t = torch.arange(self.max_seq_len_cached, device=device, dtype=torch.int64).type_as(self.inv_freq)
+
+        freqs = torch.outer(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)
+        self.register_buffer("cos_cached", emb.cos().to(dtype), persistent=False)
+        self.register_buffer("sin_cached", emb.sin().to(dtype), persistent=False)
+
+    def forward(self, x, seq_len=None):
+        # x: [bs, num_attention_heads, seq_len, head_size]
+        if seq_len > self.max_seq_len_cached:
+            self._set_cos_sin_cache(seq_len=seq_len, device=x.device, dtype=x.dtype)
+
+        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, unsqueeze_dim=1):
+    """Applies Rotary Position Embedding to the query and key tensors.
+
+    Args:
+        q (`torch.Tensor`): The query tensor.
+        k (`torch.Tensor`): The key tensor.
+        cos (`torch.Tensor`): The cosine part of the rotary embedding.
+        sin (`torch.Tensor`): The sine part of the rotary embedding.
+        position_ids (`torch.Tensor`):
+            The position indices of the tokens corresponding to the query and key tensors. For example, this can be
+            used to pass offsetted position ids when working with a KV-cache.
+        unsqueeze_dim (`int`, *optional*, defaults to 1):
+            The 'unsqueeze_dim' argument specifies the dimension along which to unsqueeze cos[position_ids] and
+            sin[position_ids] so that they can be properly broadcasted to the dimensions of q and k. For example, note
+            that cos[position_ids] and sin[position_ids] have the shape [batch_size, seq_len, head_dim]. Then, if q and
+            k have the shape [batch_size, heads, seq_len, head_dim], then setting unsqueeze_dim=1 makes
+            cos[position_ids] and sin[position_ids] broadcastable to the shapes of q and k. Similarly, if q and k have
+            the shape [batch_size, seq_len, heads, head_dim], then set unsqueeze_dim=2.
+    Returns:
+        `tuple(torch.Tensor)` comprising of the query and key tensors rotated using the Rotary Position Embedding.
+    """
+    cos = cos[position_ids].unsqueeze(unsqueeze_dim)
+    sin = sin[position_ids].unsqueeze(unsqueeze_dim)
+    q_embed = (q * cos) + (rotate_half(q) * sin)
+    k_embed = (k * cos) + (rotate_half(k) * sin)
+    return q_embed, k_embed
+
+
+class Qwen2MLP(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.hidden_size = config.hidden_size
+        self.intermediate_size = config.intermediate_size
+        self.gate_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=False)
+        self.up_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=False)
+        self.down_proj = nn.Linear(self.intermediate_size, self.hidden_size, bias=False)
+        self.act_fn = ACT2FN[config.hidden_act]
+
+    def forward(self, hidden_state):
+        return self.down_proj(self.act_fn(self.gate_proj(hidden_state)) * self.up_proj(hidden_state))
+
+
+def repeat_kv(hidden_states: torch.Tensor, n_rep: int) -> torch.Tensor:
+    """
+    This is the equivalent of torch.repeat_interleave(x, dim=1, repeats=n_rep). The hidden states go from (batch,
+    num_key_value_heads, seqlen, head_dim) to (batch, num_attention_heads, seqlen, head_dim)
+    """
+    batch, num_key_value_heads, slen, head_dim = hidden_states.shape
+    if n_rep == 1:
+        return hidden_states
+    hidden_states = hidden_states[:, :, None, :, :].expand(batch, num_key_value_heads, n_rep, slen, head_dim)
+    return hidden_states.reshape(batch, num_key_value_heads * n_rep, slen, head_dim)
+
+
+class Qwen2Attention(nn.Module):
+    """
+    Multi-headed attention from 'Attention Is All You Need' paper. Modified to use sliding window attention: Longformer
+    and "Generating Long Sequences with Sparse Transformers".
+    """
+
+    def __init__(self, config: Qwen2Config, layer_idx: Optional[int] = None):
+        super().__init__()
+        self.config = config
+        self.layer_idx = layer_idx
+        if layer_idx is None:
+            logger.warning_once(
+                f"Instantiating {self.__class__.__name__} without passing `layer_idx` is not recommended and will "
+                "to errors during the forward call, if caching is used. Please make sure to provide a `layer_idx` "
+                "when creating this class."
+            )
+
+        self.hidden_size = config.hidden_size
+        self.num_heads = config.num_attention_heads
+        self.head_dim = self.hidden_size // self.num_heads
+        self.num_key_value_heads = config.num_key_value_heads
+        self.num_key_value_groups = self.num_heads // self.num_key_value_heads
+        self.max_position_embeddings = config.max_position_embeddings
+        self.rope_theta = config.rope_theta
+        self.is_causal = True
+        self.attention_dropout = config.attention_dropout
+
+        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=True)
+        self.k_proj = nn.Linear(self.hidden_size, self.num_key_value_heads * self.head_dim, bias=True)
+        self.v_proj = nn.Linear(self.hidden_size, self.num_key_value_heads * self.head_dim, bias=True)
+        self.o_proj = nn.Linear(self.num_heads * self.head_dim, self.hidden_size, bias=False)
+
+        self.rotary_emb = Qwen2RotaryEmbedding(
+            self.head_dim,
+            max_position_embeddings=self.max_position_embeddings,
+            base=self.rope_theta,
+        )
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.LongTensor] = None,
+        past_key_value: Optional[Cache] = None,
+        output_attentions: bool = False,
+        use_cache: bool = False,
+        cache_position: Optional[torch.LongTensor] = None,
+    ) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[Tuple[torch.Tensor]]]:
+        bsz, q_len, _ = hidden_states.size()
+
+        query_states = self.q_proj(hidden_states)
+        key_states = self.k_proj(hidden_states)
+        value_states = self.v_proj(hidden_states)
+
+        query_states = query_states.view(bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2)
+        key_states = key_states.view(bsz, q_len, self.num_key_value_heads, self.head_dim).transpose(1, 2)
+        value_states = value_states.view(bsz, q_len, self.num_key_value_heads, self.head_dim).transpose(1, 2)
+
+        kv_seq_len = key_states.shape[-2]
+        if past_key_value is not None:
+            if self.layer_idx is None:
+                raise ValueError(
+                    f"The cache structure has changed since version v4.36. If you are using {self.__class__.__name__} "
+                    "for auto-regressive decoding with k/v caching, please make sure to initialize the attention class "
+                    "with a layer index."
+                )
+            kv_seq_len += past_key_value.get_usable_length(kv_seq_len, self.layer_idx)
+        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:
+            cache_kwargs = {"sin": sin, "cos": cos, "cache_position": cache_position}  # Specific to RoPE models
+            key_states, value_states = past_key_value.update(key_states, value_states, self.layer_idx, cache_kwargs)
+
+        # repeat k/v heads if n_kv_heads < n_heads
+        key_states = repeat_kv(key_states, self.num_key_value_groups)
+        value_states = repeat_kv(value_states, self.num_key_value_groups)
+
+        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:  # no matter the length, we just slice it
+            causal_mask = attention_mask[:, :, :, : key_states.shape[-2]]
+            attn_weights = attn_weights + causal_mask
+
+        # upcast attention to fp32
+        attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query_states.dtype)
+        attn_weights = nn.functional.dropout(attn_weights, p=self.attention_dropout, training=self.training)
+        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).contiguous()
+        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 Qwen2FlashAttention2(Qwen2Attention):
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        # TODO: Should be removed once Flash Attention for RoCm is bumped to 2.1.
+        # flash_attn<2.1 generates top-left aligned causal mask, while what is needed here is bottom-right alignement, that was made default for flash_attn>=2.1. This attribute is used to handle this difference. Reference: https://github.com/Dao-AILab/flash-attention/releases/tag/v2.1.0.
+        # Beware that with flash_attn<2.1, using q_seqlen != k_seqlen (except for the case q_seqlen == 1) produces a wrong mask (top-left).
+        self._flash_attn_uses_top_left_mask = not is_flash_attn_greater_or_equal_2_10()
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.LongTensor] = None,
+        past_key_value: Optional[Cache] = None,
+        output_attentions: bool = False,
+        use_cache: bool = False,
+        cache_position: Optional[torch.LongTensor] = None,
+    ):
+        bsz, q_len, _ = hidden_states.size()
+
+        query_states = self.q_proj(hidden_states)
+        key_states = self.k_proj(hidden_states)
+        value_states = self.v_proj(hidden_states)
+
+        query_states = query_states.view(bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2)
+        key_states = key_states.view(bsz, q_len, self.num_key_value_heads, self.head_dim).transpose(1, 2)
+        value_states = value_states.view(bsz, q_len, self.num_key_value_heads, self.head_dim).transpose(1, 2)
+
+        kv_seq_len = key_states.shape[-2]
+        if past_key_value is not None:
+            if self.layer_idx is None:
+                raise ValueError(
+                    f"The cache structure has changed since version v4.36. If you are using {self.__class__.__name__} "
+                    "for auto-regressive decoding with k/v caching, please make sure to initialize the attention class "
+                    "with a layer index."
+                )
+            kv_seq_len += past_key_value.get_usable_length(kv_seq_len, self.layer_idx)
+
+        # Because the input can be padded, the absolute sequence length depends on the max position id.
+        rotary_seq_len = (
+            max(kv_seq_len, position_ids[:, -1].max().item() + 1) if position_ids is not None else kv_seq_len
+        )
+
+        cos, sin = self.rotary_emb(value_states, seq_len=rotary_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:
+            # Activate slicing cache only if the config has a value `sliding_windows` attribute
+            cache_has_contents = past_key_value.get_seq_length(self.layer_idx) > 0
+            if (
+                getattr(self.config, "sliding_window", None) is not None
+                and kv_seq_len > self.config.sliding_window
+                and cache_has_contents
+            ):
+                slicing_tokens = 1 - self.config.sliding_window
+
+                past_key = past_key_value[self.layer_idx][0]
+                past_value = past_key_value[self.layer_idx][1]
+
+                past_key = past_key[:, :, slicing_tokens:, :].contiguous()
+                past_value = past_value[:, :, slicing_tokens:, :].contiguous()
+
+                if past_key.shape[-2] != self.config.sliding_window - 1:
+                    raise ValueError(
+                        f"past key must have a shape of (`batch_size, num_heads, self.config.sliding_window-1, head_dim`), got"
+                        f" {past_key.shape}"
+                    )
+
+                if attention_mask is not None:
+                    attention_mask = attention_mask[:, slicing_tokens:]
+                    attention_mask = torch.cat([attention_mask, torch.ones_like(attention_mask[:, -1:])], dim=-1)
+
+            cache_kwargs = {"sin": sin, "cos": cos, "cache_position": cache_position}  # Specific to RoPE models
+            key_states, value_states = past_key_value.update(key_states, value_states, self.layer_idx, cache_kwargs)
+
+        # repeat k/v heads if n_kv_heads < n_heads
+        key_states = repeat_kv(key_states, self.num_key_value_groups)
+        value_states = repeat_kv(value_states, self.num_key_value_groups)
+        dropout_rate = 0.0 if not self.training else self.attention_dropout
+
+        # In PEFT, usually we cast the layer norms in float32 for training stability reasons
+        # therefore the input hidden states gets silently casted in float32. Hence, we need
+        # cast them back in float16 just to be sure everything works as expected.
+        input_dtype = query_states.dtype
+        if input_dtype == torch.float32:
+            if torch.is_autocast_enabled():
+                target_dtype = torch.get_autocast_gpu_dtype()
+            # Handle the case where the model is quantized
+            elif hasattr(self.config, "_pre_quantization_dtype"):
+                target_dtype = self.config._pre_quantization_dtype
+            else:
+                target_dtype = self.q_proj.weight.dtype
+
+            logger.warning_once(
+                f"The input hidden states seems to be silently casted in float32, this might be related to"
+                f" the fact you have upcasted embedding or layer norm layers in float32. We will cast back the input in"
+                f" {target_dtype}."
+            )
+
+            query_states = query_states.to(target_dtype)
+            key_states = key_states.to(target_dtype)
+            value_states = value_states.to(target_dtype)
+
+        # Reashape to the expected shape for Flash Attention
+        query_states = query_states.transpose(1, 2)
+        key_states = key_states.transpose(1, 2)
+        value_states = value_states.transpose(1, 2)
+
+        if (
+            self.config.use_sliding_window
+            and getattr(self.config, "sliding_window", None) is not None
+            and self.layer_idx >= self.config.max_window_layers
+        ):
+            sliding_window = self.config.sliding_window
+        else:
+            sliding_window = None
+
+        attn_output = _flash_attention_forward(
+            query_states,
+            key_states,
+            value_states,
+            attention_mask,
+            q_len,
+            position_ids=position_ids,
+            dropout=dropout_rate,
+            sliding_window=sliding_window,
+            is_causal=False, #### Revised
+            use_top_left_mask=self._flash_attn_uses_top_left_mask,
+        )
+
+        attn_output = attn_output.reshape(bsz, q_len, self.hidden_size).contiguous()
+        attn_output = self.o_proj(attn_output)
+
+        if not output_attentions:
+            attn_weights = None
+
+        return attn_output, attn_weights, past_key_value
+
+
+class Qwen2SdpaAttention(Qwen2Attention):
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.LongTensor] = None,
+        past_key_value: Optional[Cache] = None,
+        output_attentions: bool = False,
+        use_cache: bool = False,
+        cache_position: Optional[torch.LongTensor] = None,
+    ) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[Tuple[torch.Tensor]]]:
+        if output_attentions:
+            # TODO: Improve this warning with e.g. `model.config.attn_implementation = "manual"` once this is implemented.
+            logger.warning_once(
+                "QZhouModel is using Qwen2SdpaAttention, but `torch.nn.functional.scaled_dot_product_attention` does not support `output_attentions=True`. Falling back to the manual attention implementation, "
+                'but specifying the manual implementation will be required from Transformers version v5.0.0 onwards. This warning can be removed using the argument `attn_implementation="eager"` when loading the model.'
+            )
+            return super().forward(
+                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,
+            )
+
+        bsz, q_len, _ = hidden_states.size()
+
+        query_states = self.q_proj(hidden_states)
+        key_states = self.k_proj(hidden_states)
+        value_states = self.v_proj(hidden_states)
+
+        query_states = query_states.view(bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2)
+        key_states = key_states.view(bsz, q_len, self.num_key_value_heads, self.head_dim).transpose(1, 2)
+        value_states = value_states.view(bsz, q_len, self.num_key_value_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.get_usable_length(kv_seq_len, self.layer_idx)
+        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:
+            cache_kwargs = {"sin": sin, "cos": cos, "cache_position": cache_position}  # Specific to RoPE models
+            key_states, value_states = past_key_value.update(key_states, value_states, self.layer_idx, cache_kwargs)
+
+        key_states = repeat_kv(key_states, self.num_key_value_groups)
+        value_states = repeat_kv(value_states, self.num_key_value_groups)
+
+        causal_mask = attention_mask
+        if attention_mask is not None:  # no matter the length, we just slice it
+            causal_mask = attention_mask[:, :, :, : key_states.shape[-2]]
+
+        # SDPA with memory-efficient backend is currently (torch==2.1.2) bugged with non-contiguous inputs with custom attn_mask,
+        # Reference: https://github.com/pytorch/pytorch/issues/112577.
+        if query_states.device.type == "cuda" and attention_mask is not None:
+            query_states = query_states.contiguous()
+            key_states = key_states.contiguous()
+            value_states = value_states.contiguous()
+
+        # We dispatch to SDPA's Flash Attention or Efficient kernels via this `is_causal` if statement instead of an inline conditional assignment
+        # in SDPA to support both torch.compile's dynamic shapes and full graph options. An inline conditional prevents dynamic shapes from compiling.
+        # The q_len > 1 is necessary to match with AttentionMaskConverter.to_causal_4d that does not create a causal mask in case q_len == 1.
+        is_causal = False # True if causal_mask is None and q_len > 1 else False #### Revised
+        attn_output = torch.nn.functional.scaled_dot_product_attention(
+            query_states,
+            key_states,
+            value_states,
+            attn_mask=causal_mask,
+            dropout_p=self.attention_dropout if self.training else 0.0,
+            is_causal=is_causal,
+        )
+
+        attn_output = attn_output.transpose(1, 2).contiguous()
+        attn_output = attn_output.view(bsz, q_len, self.hidden_size)
+
+        attn_output = self.o_proj(attn_output)
+
+        return attn_output, None, past_key_value
+
+
+QWEN2_ATTENTION_CLASSES = {
+    "eager": Qwen2Attention,
+    "flash_attention_2": Qwen2FlashAttention2,
+    "sdpa": Qwen2SdpaAttention,
+}
+
+
+class Qwen2DecoderLayer(nn.Module):
+    def __init__(self, config: Qwen2Config, layer_idx: int):
+        super().__init__()
+        self.hidden_size = config.hidden_size
+
+        if config.sliding_window and config._attn_implementation != "flash_attention_2":
+            logger.warning_once(
+                f"Sliding Window Attention is enabled but not implemented for `{config._attn_implementation}`; "
+                "unexpected results may be encountered."
+            )
+        self.self_attn = QWEN2_ATTENTION_CLASSES[config._attn_implementation](config, layer_idx)
+        self.mlp = Qwen2MLP(config)
+        self.input_layernorm = Qwen2RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+        self.post_attention_layernorm = Qwen2RMSNorm(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,
+        cache_position: Optional[torch.LongTensor] = None,
+        **kwargs,
+    ) -> 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, sequence_length)` where padding elements are indicated by 0.
+            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
+            cache_position (`torch.LongTensor` of shape `(sequence_length)`, *optional*):
+                Indices depicting the position of the input sequence tokens in the sequence.
+            kwargs (`dict`, *optional*):
+                Arbitrary kwargs to be ignored, used for FSDP and other methods that injects code
+                into the model
+        """
+
+        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,
+            cache_position=cache_position,
+        )
+        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 Qwen2PreTrainedModel(PreTrainedModel):
+    config_class = Qwen2Config
+    base_model_prefix = "model"
+    supports_gradient_checkpointing = True
+    _no_split_modules = ["Qwen2DecoderLayer"]
+    _skip_keys_device_placement = "past_key_values"
+    _supports_flash_attn_2 = True
+    _supports_sdpa = True
+    _supports_cache_class = True
+
+    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_()
+
+
+class QZhouModel(Qwen2PreTrainedModel):
+
+    def __init__(self, config: Qwen2Config):
+        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(
+            [Qwen2DecoderLayer(config, layer_idx) for layer_idx in range(config.num_hidden_layers)]
+        )
+        self._attn_implementation = config._attn_implementation
+        self.norm = Qwen2RMSNorm(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
+
+    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,
+        cache_position: Optional[torch.LongTensor] = 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
+        
+        if (input_ids is None) ^ (inputs_embeds is not None):
+            raise ValueError(
+                "You cannot specify both input_ids and inputs_embeds at the same time, and must specify either one"
+            )
+
+        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
+
+        use_legacy_cache = False
+        if use_cache and not isinstance(past_key_values, Cache) and not self.training:
+            use_legacy_cache = True
+            past_key_values = DynamicCache.from_legacy_cache(past_key_values)
+            logger.warning_once(
+                "We detected that you are passing `past_key_values` as a tuple and this is deprecated and will be removed in v4.43. "
+                "Please use an appropriate `Cache` class (https://huggingface.co/docs/transformers/v4.41.3/en/internal/generation_utils#transformers.Cache)"
+            )
+
+        if inputs_embeds is None:
+            inputs_embeds = self.embed_tokens(input_ids)
+
+        if cache_position is None:
+            past_seen_tokens = past_key_values.get_seq_length() if past_key_values is not None else 0
+            cache_position = torch.arange(
+                past_seen_tokens, past_seen_tokens + inputs_embeds.shape[1], device=inputs_embeds.device
+            )
+        if position_ids is None:
+            position_ids = cache_position.unsqueeze(0)
+
+        bi_attn_mask = self._update_bi_attn_mask(
+            attention_mask, inputs_embeds, cache_position, past_key_values, output_attentions
+        )
+
+        hidden_states = inputs_embeds
+
+        # decoder layers
+        all_hidden_states = () if output_hidden_states else None
+        all_self_attns = () if output_attentions else None
+        next_decoder_cache = None
+
+        for decoder_layer in self.layers:
+            if output_hidden_states:
+                all_hidden_states += (hidden_states,)
+
+            if self.gradient_checkpointing and self.training:
+                layer_outputs = self._gradient_checkpointing_func(
+                    decoder_layer.__call__,
+                    hidden_states,
+                    bi_attn_mask,
+                    position_ids,
+                    past_key_values,
+                    output_attentions,
+                    use_cache,
+                    cache_position,
+                )
+            else:
+                layer_outputs = decoder_layer(
+                    hidden_states,
+                    attention_mask=bi_attn_mask,
+                    position_ids=position_ids,
+                    past_key_value=past_key_values,
+                    output_attentions=output_attentions,
+                    use_cache=use_cache,
+                    cache_position=cache_position,
+                )
+
+            hidden_states = layer_outputs[0]
+
+            if use_cache:
+                next_decoder_cache = 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,)
+
+        next_cache = None
+        if use_cache:
+            next_cache = next_decoder_cache.to_legacy_cache() if use_legacy_cache else next_decoder_cache
+
+        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,
+        )
+
+    def _update_bi_attn_mask(
+        self,
+        attention_mask: torch.Tensor,
+        input_tensor: torch.Tensor,
+        cache_position: torch.Tensor,
+        past_key_values: Cache,
+        output_attentions: bool,
+    ):
+        if self.config._attn_implementation == "flash_attention_2":
+            if attention_mask is not None and 0.0 in attention_mask:
+                return attention_mask
+            return None
+
+        elif self.config._attn_implementation == "sdpa" and not output_attentions:
+            attention_mask = _prepare_4d_attention_mask_for_sdpa(
+                    attention_mask, input_tensor.dtype
+                )
+            return attention_mask
+        else:
+            attention_mask = _prepare_4d_attention_mask(
+                    attention_mask, input_tensor.dtype
+                )
+            return attention_mask
+
+    # Copied from transformers.models.llama.modeling_llama.LlamaModel._update_causal_mask
+    def _update_causal_mask(
+        self,
+        attention_mask: torch.Tensor,
+        input_tensor: torch.Tensor,
+        cache_position: torch.Tensor,
+        past_key_values: Cache,
+        output_attentions: bool,
+    ):
+        # TODO: As of torch==2.2.0, the `attention_mask` passed to the model in `generate` is 2D and of dynamic length even when the static
+        # KV cache is used. This is an issue for torch.compile which then recaptures cudagraphs at each decode steps due to the dynamic shapes.
+        # (`recording cudagraph tree for symint key 13`, etc.), which is VERY slow. A workaround is `@torch.compiler.disable`, but this prevents using
+        # `fullgraph=True`. See more context in https://github.com/huggingface/transformers/pull/29114
+
+        if self.config._attn_implementation == "flash_attention_2":
+            if attention_mask is not None and 0.0 in attention_mask:
+                return attention_mask
+            return None
+
+        # For SDPA, when possible, we will rely on its `is_causal` argument instead of its `attn_mask` argument, in
+        # order to dispatch on Flash Attention 2. This feature is not compatible with static cache, as SDPA will fail
+        # to infer the attention mask.
+        past_seen_tokens = past_key_values.get_seq_length() if past_key_values is not None else 0
+        using_static_cache = isinstance(past_key_values, StaticCache)
+
+        # When output attentions is True, sdpa implementation's forward method calls the eager implementation's forward
+        if self.config._attn_implementation == "sdpa" and not using_static_cache and not output_attentions:
+            if AttentionMaskConverter._ignore_causal_mask_sdpa(
+                attention_mask,
+                inputs_embeds=input_tensor,
+                past_key_values_length=past_seen_tokens,
+                is_training=self.training,
+            ):
+                return None
+
+        dtype, device = input_tensor.dtype, input_tensor.device
+        min_dtype = torch.finfo(dtype).min
+        sequence_length = input_tensor.shape[1]
+        if using_static_cache:
+            target_length = past_key_values.get_max_length()
+        else:
+            target_length = (
+                attention_mask.shape[-1]
+                if isinstance(attention_mask, torch.Tensor)
+                else past_seen_tokens + sequence_length + 1
+            )
+
+        # In case the provided `attention` mask is 2D, we generate a causal mask here (4D).
+        causal_mask = _prepare_4d_causal_attention_mask_with_cache_position(
+            attention_mask,
+            sequence_length=sequence_length,
+            target_length=target_length,
+            dtype=dtype,
+            device=device,
+            min_dtype=min_dtype,
+            cache_position=cache_position,
+            batch_size=input_tensor.shape[0],
+        )
+
+        if (
+            self.config._attn_implementation == "sdpa"
+            and attention_mask is not None
+            and attention_mask.device.type == "cuda"
+            and not output_attentions
+        ):
+            # Attend to all tokens in fully masked rows in the causal_mask, for example the relevant first rows when
+            # using left padding. This is required by F.scaled_dot_product_attention memory-efficient attention path.
+            # Details: https://github.com/pytorch/pytorch/issues/110213
+            causal_mask = AttentionMaskConverter._unmask_unattended(causal_mask, min_dtype)
+
+        return causal_mask
+

modules.json

@@ -0,0 +1,14 @@
+[
+  {
+    "idx": 0,
+    "name": "0",
+    "path": "",
+    "type": "sentence_transformers.models.Transformer"
+  },
+  {
+    "idx": 1,
+    "name": "1",
+    "path": "1_Pooling",
+    "type": "sentence_transformers.models.Pooling"
+  }
+]

sentence_bert_config.json

@@ -0,0 +1,4 @@
+{
+  "max_seq_length": 32768,
+  "do_lower_case": false
+}

special_tokens_map.json

@@ -0,0 +1,31 @@
+{
+  "additional_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|object_ref_start|>",
+    "<|object_ref_end|>",
+    "<|box_start|>",
+    "<|box_end|>",
+    "<|quad_start|>",
+    "<|quad_end|>",
+    "<|vision_start|>",
+    "<|vision_end|>",
+    "<|vision_pad|>",
+    "<|image_pad|>",
+    "<|video_pad|>"
+  ],
+  "eos_token": {
+    "content": "<|endoftext|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "<|endoftext|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

tokenizer.json

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

tokenizer_config.json

@@ -0,0 +1,216 @@
+{
+  "add_bos_token": false,
+  "add_eos_token": true,
+  "add_prefix_space": false,
+  "added_tokens_decoder": {
+    "151643": {
+      "content": "<|endoftext|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151644": {
+      "content": "<|im_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151645": {
+      "content": "<|im_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151646": {
+      "content": "<|object_ref_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151647": {
+      "content": "<|object_ref_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151648": {
+      "content": "<|box_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151649": {
+      "content": "<|box_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151650": {
+      "content": "<|quad_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151651": {
+      "content": "<|quad_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151652": {
+      "content": "<|vision_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151653": {
+      "content": "<|vision_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151654": {
+      "content": "<|vision_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151655": {
+      "content": "<|image_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151656": {
+      "content": "<|video_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151657": {
+      "content": "<tool_call>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151658": {
+      "content": "</tool_call>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151659": {
+      "content": "<|fim_prefix|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151660": {
+      "content": "<|fim_middle|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151661": {
+      "content": "<|fim_suffix|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151662": {
+      "content": "<|fim_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151663": {
+      "content": "<|repo_name|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151664": {
+      "content": "<|file_sep|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    }
+  },
+  "additional_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|object_ref_start|>",
+    "<|object_ref_end|>",
+    "<|box_start|>",
+    "<|box_end|>",
+    "<|quad_start|>",
+    "<|quad_end|>",
+    "<|vision_start|>",
+    "<|vision_end|>",
+    "<|vision_pad|>",
+    "<|image_pad|>",
+    "<|video_pad|>"
+  ],
+  "bos_token": null,
+  "chat_template": "{%- if tools %}\n    {{- '<|im_start|>system\\n' }}\n    {%- if messages[0]['role'] == 'system' %}\n        {{- messages[0]['content'] }}\n    {%- else %}\n        {{- 'You are Qwen, created by Alibaba Cloud. You are a helpful assistant.' }}\n    {%- endif %}\n    {{- \"\\n\\n# Tools\\n\\nYou may call one or more functions to assist with the user query.\\n\\nYou are provided with function signatures within <tools></tools> XML tags:\\n<tools>\" }}\n    {%- for tool in tools %}\n        {{- \"\\n\" }}\n        {{- tool | tojson }}\n    {%- endfor %}\n    {{- \"\\n</tools>\\n\\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\\n<tool_call>\\n{\\\"name\\\": <function-name>, \\\"arguments\\\": <args-json-object>}\\n</tool_call><|im_end|>\\n\" }}\n{%- else %}\n    {%- if messages[0]['role'] == 'system' %}\n        {{- '<|im_start|>system\\n' + messages[0]['content'] + '<|im_end|>\\n' }}\n    {%- else %}\n        {{- '<|im_start|>system\\nYou are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>\\n' }}\n    {%- endif %}\n{%- endif %}\n{%- for message in messages %}\n    {%- if (message.role == \"user\") or (message.role == \"system\" and not loop.first) or (message.role == \"assistant\" and not message.tool_calls) %}\n        {{- '<|im_start|>' + message.role + '\\n' + message.content + '<|im_end|>' + '\\n' }}\n    {%- elif message.role == \"assistant\" %}\n        {{- '<|im_start|>' + message.role }}\n        {%- if message.content %}\n            {{- '\\n' + message.content }}\n        {%- endif %}\n        {%- for tool_call in message.tool_calls %}\n            {%- if tool_call.function is defined %}\n                {%- set tool_call = tool_call.function %}\n            {%- endif %}\n            {{- '\\n<tool_call>\\n{\"name\": \"' }}\n            {{- tool_call.name }}\n            {{- '\", \"arguments\": ' }}\n            {{- tool_call.arguments | tojson }}\n            {{- '}\\n</tool_call>' }}\n        {%- endfor %}\n        {{- '<|im_end|>\\n' }}\n    {%- elif message.role == \"tool\" %}\n        {%- if (loop.index0 == 0) or (messages[loop.index0 - 1].role != \"tool\") %}\n            {{- '<|im_start|>user' }}\n        {%- endif %}\n        {{- '\\n<tool_response>\\n' }}\n        {{- message.content }}\n        {{- '\\n</tool_response>' }}\n        {%- if loop.last or (messages[loop.index0 + 1].role != \"tool\") %}\n            {{- '<|im_end|>\\n' }}\n        {%- endif %}\n    {%- endif %}\n{%- endfor %}\n{%- if add_generation_prompt %}\n    {{- '<|im_start|>assistant\\n' }}\n{%- endif %}\n",
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|endoftext|>",
+  "errors": "replace",
+  "extra_special_tokens": {},
+  "max_length": 1536,
+  "model_max_length": 131072,
+  "pad_to_multiple_of": null,
+  "pad_token": "<|endoftext|>",
+  "pad_token_type_id": 0,
+  "padding_side": "left",
+  "split_special_tokens": false,
+  "stride": 0,
+  "tokenizer_class": "Qwen2Tokenizer",
+  "truncation_side": "right",
+  "truncation_strategy": "longest_first",
+  "unk_token": null
+}