Weiyun1025 commited on
Commit
3567964
1 Parent(s): 5ec0374

Upload folder using huggingface_hub

Browse files
README.md CHANGED
@@ -1,3 +1,243 @@
1
- ---
2
- license: mit
3
- ---
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ ---
2
+ license: mit
3
+ pipeline_tag: visual-question-answering
4
+ ---
5
+
6
+ # Model Card for InternVL2-8B
7
+
8
+ [\[🆕 Blog\]](https://internvl.github.io/blog/) [\[📜 InternVL 1.0 Paper\]](https://arxiv.org/abs/2312.14238) [\[📜 InternVL 1.5 Report\]](https://arxiv.org/abs/2404.16821) [\[🗨️ Chat Demo\]](https://internvl.opengvlab.com/)
9
+
10
+ [\[🤗 HF Demo\]](https://huggingface.co/spaces/OpenGVLab/InternVL) [\[🚀 Quick Start\]](#model-usage) [\[📖 中文解读\]](https://zhuanlan.zhihu.com/p/675877376)
11
+
12
+ ## Introduction
13
+
14
+ We are excited to announce the release of InternVL 2.0, the latest addition to the InternVL series of multimodal large language models. InternVL 2.0 features a variety of instruction-tuned models, ranging from 2 billion to 108 billion parameters. This repository contains the instruction-tuned InternVL2-8B model.
15
+
16
+ Compared to the state-of-the-art open-source multimodal large language models, InternVL 2.0 surpasses most open-source models. It demonstrates competitive performance on par with proprietary commercial models across various capabilities, including document and chart comprehension, infographics QA, scene text understanding and OCR tasks, scientific and mathematical problem solving, as well as cultural understanding and integrated multimodal capabilities.
17
+
18
+ InternVL 2.0 is trained with an 8k context window and utilizes training data consisting of long texts, multiple images, and videos, significantly improving its ability to handle these types of inputs compared to InternVL 1.5. For more details, please refer to our blog and GitHub.
19
+
20
+ ## Performance
21
+
22
+ | Benchmark | MiniCPM-Llama3-V-2_5 | InternVL2-8B |
23
+ | :-----------------------: | :------------------: | :----------: |
24
+ | Model Size | 8.5B | |
25
+ | | | |
26
+ | DocVQA<sub>test</sub> | 84.8 | TODO |
27
+ | ChartQA<sub>test</sub> | - | 83.3 |
28
+ | InfoVQA<sub>test</sub> | - | TODO |
29
+ | TextVQA<sub>val</sub> | 76.6 | 77.4 |
30
+ | OCRBench | 725 | TODO |
31
+ | MME<sub>sum</sub> | 2024.6 | 2210.3 |
32
+ | RealWorldQA | 63.5 | |
33
+ | AI2D<sub>test</sub> | 78.4 | 83.8 |
34
+ | MMMU<sub>val</sub> | 45.8 | 49.3 |
35
+ | MMBench-EN<sub>test</sub> | 77.2 | 81.7 |
36
+ | MMBench-CN<sub>test</sub> | 74.2 | 81.2 |
37
+ | CCBench<sub>dev</sub> | 45.9 | 75.9 |
38
+ | MMVet<sub>GPT4-0613</sub> | - | 60.0 |
39
+ | SEED-Image | 72.3 | 76.2 |
40
+ | HallBench<sub>avg.</sub> | 42.4 | |
41
+ | MathVista<sub>mini</sub> | 54.3 | |
42
+
43
+ - We simultaneously use InternVL and VLMEvalKit repositories for model evaluation. Specifically, the results reported for DocVQA, ChartQA, InfoVQA, TextVQA, MME, AI2D, MMBench, CCBench, MMVet, and SEED-Image were tested using the InternVL repository. MMMU, OCRBench, RealWorldQA, HallBench, and MathVista were evaluated using the VLMEvalKit.
44
+
45
+ - Please note that evaluating the same model using different testing toolkits like InternVL and VLMEvalKit can result in slight differences, which is normal. Updates to code versions and variations in environment and hardware can also cause minor discrepancies in results.
46
+
47
+ - It is important to mention that the MMVet scores we report are evaluated using GPT-4-0613 as the judge model. Different versions of GPT-4 can lead to significant variations in the scores for this dataset. For instance, using GPT-4-Turbo would result in significantly lower scores.
48
+
49
+ ## Quick Start
50
+
51
+ We provide an example code to run InternVL2-8B using `transformers`.
52
+
53
+ > Please use transformers==4.37.2 to ensure the model works normally.
54
+
55
+ ```python
56
+ import torch
57
+ import torchvision.transforms as T
58
+ from PIL import Image
59
+ from torchvision.transforms.functional import InterpolationMode
60
+ from transformers import AutoModel, AutoTokenizer
61
+
62
+ IMAGENET_MEAN = (0.485, 0.456, 0.406)
63
+ IMAGENET_STD = (0.229, 0.224, 0.225)
64
+
65
+
66
+ def build_transform(input_size):
67
+ MEAN, STD = IMAGENET_MEAN, IMAGENET_STD
68
+ transform = T.Compose([
69
+ T.Lambda(lambda img: img.convert('RGB') if img.mode != 'RGB' else img),
70
+ T.Resize((input_size, input_size), interpolation=InterpolationMode.BICUBIC),
71
+ T.ToTensor(),
72
+ T.Normalize(mean=MEAN, std=STD)
73
+ ])
74
+ return transform
75
+
76
+
77
+ def find_closest_aspect_ratio(aspect_ratio, target_ratios, width, height, image_size):
78
+ best_ratio_diff = float('inf')
79
+ best_ratio = (1, 1)
80
+ area = width * height
81
+ for ratio in target_ratios:
82
+ target_aspect_ratio = ratio[0] / ratio[1]
83
+ ratio_diff = abs(aspect_ratio - target_aspect_ratio)
84
+ if ratio_diff < best_ratio_diff:
85
+ best_ratio_diff = ratio_diff
86
+ best_ratio = ratio
87
+ elif ratio_diff == best_ratio_diff:
88
+ if area > 0.5 * image_size * image_size * ratio[0] * ratio[1]:
89
+ best_ratio = ratio
90
+ return best_ratio
91
+
92
+
93
+ def dynamic_preprocess(image, min_num=1, max_num=6, image_size=448, use_thumbnail=False):
94
+ orig_width, orig_height = image.size
95
+ aspect_ratio = orig_width / orig_height
96
+
97
+ # calculate the existing image aspect ratio
98
+ target_ratios = set(
99
+ (i, j) for n in range(min_num, max_num + 1) for i in range(1, n + 1) for j in range(1, n + 1) if
100
+ i * j <= max_num and i * j >= min_num)
101
+ target_ratios = sorted(target_ratios, key=lambda x: x[0] * x[1])
102
+
103
+ # find the closest aspect ratio to the target
104
+ target_aspect_ratio = find_closest_aspect_ratio(
105
+ aspect_ratio, target_ratios, orig_width, orig_height, image_size)
106
+
107
+ # calculate the target width and height
108
+ target_width = image_size * target_aspect_ratio[0]
109
+ target_height = image_size * target_aspect_ratio[1]
110
+ blocks = target_aspect_ratio[0] * target_aspect_ratio[1]
111
+
112
+ # resize the image
113
+ resized_img = image.resize((target_width, target_height))
114
+ processed_images = []
115
+ for i in range(blocks):
116
+ box = (
117
+ (i % (target_width // image_size)) * image_size,
118
+ (i // (target_width // image_size)) * image_size,
119
+ ((i % (target_width // image_size)) + 1) * image_size,
120
+ ((i // (target_width // image_size)) + 1) * image_size
121
+ )
122
+ # split the image
123
+ split_img = resized_img.crop(box)
124
+ processed_images.append(split_img)
125
+ assert len(processed_images) == blocks
126
+ if use_thumbnail and len(processed_images) != 1:
127
+ thumbnail_img = image.resize((image_size, image_size))
128
+ processed_images.append(thumbnail_img)
129
+ return processed_images
130
+
131
+
132
+ def load_image(image_file, input_size=448, max_num=6):
133
+ image = Image.open(image_file).convert('RGB')
134
+ transform = build_transform(input_size=input_size)
135
+ images = dynamic_preprocess(image, image_size=input_size, use_thumbnail=True, max_num=max_num)
136
+ pixel_values = [transform(image) for image in images]
137
+ pixel_values = torch.stack(pixel_values)
138
+ return pixel_values
139
+
140
+
141
+ path = 'OpenGVLab/InternVL2-8B'
142
+ model = AutoModel.from_pretrained(
143
+ path,
144
+ torch_dtype=torch.bfloat16,
145
+ low_cpu_mem_usage=True,
146
+ trust_remote_code=True).eval().cuda()
147
+
148
+ tokenizer = AutoTokenizer.from_pretrained(path, trust_remote_code=True)
149
+ # set the max number of tiles in `max_num`
150
+ pixel_values = load_image('./examples/image1.jpg', max_num=6).to(torch.bfloat16).cuda()
151
+
152
+ generation_config = dict(
153
+ num_beams=1,
154
+ max_new_tokens=1024,
155
+ do_sample=False,
156
+ )
157
+
158
+ # pure-text conversation (纯文本对话)
159
+ question = 'Hello, who are you?'
160
+ response, history = model.chat(tokenizer, None, question, generation_config, history=None, return_history=True)
161
+ print(f'User: {question}')
162
+ print(f'Assistant: {response}')
163
+
164
+ question = 'Can you tell me a story?'
165
+ response, history = model.chat(tokenizer, None, question, generation_config, history=history, return_history=True)
166
+ print(f'User: {question}')
167
+ print(f'Assistant: {response}')
168
+
169
+ # single-image single-round conversation (单图单轮对话)
170
+ question = '<image>\nPlease describe the image shortly.'
171
+ response = model.chat(tokenizer, pixel_values, question, generation_config)
172
+ print(f'User: {question}')
173
+ print(f'Assistant: {response}')
174
+
175
+ # single-image multi-round conversation (单图多轮对话)
176
+ question = '<image>\nPlease describe the image in detail.'
177
+ response, history = model.chat(tokenizer, pixel_values, question, generation_config, history=None, return_history=True)
178
+ print(f'User: {question}')
179
+ print(f'Assistant: {response}')
180
+
181
+ question = 'Please write a poem according to the image.'
182
+ response, history = model.chat(tokenizer, pixel_values, question, generation_config, history=history, return_history=True)
183
+ print(f'User: {question}')
184
+ print(f'Assistant: {response}')
185
+
186
+ # multi-image multi-round conversation (多图多轮对话)
187
+ pixel_values1 = load_image('./examples/image1.jpg', max_num=6).to(torch.bfloat16).cuda()
188
+ pixel_values2 = load_image('./examples/image2.jpg', max_num=6).to(torch.bfloat16).cuda()
189
+ pixel_values = torch.cat((pixel_values1, pixel_values2), dim=0)
190
+ num_patches_list = [pixel_values1.size(0), pixel_values2.size(0)]
191
+
192
+ question = 'Image-1: <image>\nImage-2: <image>\nDescribe the two images in detail.'
193
+ response, history = model.chat(tokenizer, pixel_values, question, generation_config,
194
+ num_patches_list=num_patches_list,
195
+ history=None, return_history=True)
196
+ print(f'User: {question}')
197
+ print(f'Assistant: {response}')
198
+
199
+ question = 'What are the similarities and differences between these two images.'
200
+ response, history = model.chat(tokenizer, pixel_values, question, generation_config,
201
+ num_patches_list=num_patches_list,
202
+ history=history, return_history=True)
203
+ print(f'User: {question}')
204
+ print(f'Assistant: {response}')
205
+
206
+ # batch inference, single image per sample (单图批处理)
207
+ pixel_values1 = load_image('./examples/image1.jpg', max_num=6).to(torch.bfloat16).cuda()
208
+ pixel_values2 = load_image('./examples/image2.jpg', max_num=6).to(torch.bfloat16).cuda()
209
+ num_patches_list = [pixel_values1.size(0), pixel_values2.size(0)]
210
+ pixel_values = torch.cat((pixel_values1, pixel_values2), dim=0)
211
+
212
+ questions = ['<image>\nDescribe the image in detail.'] * len(num_patches_list)
213
+ responses = model.batch_chat(tokenizer, pixel_values,
214
+ num_patches_list=num_patches_list,
215
+ questions=questions,
216
+ generation_config=generation_config)
217
+ for question, response in zip(questions, responses):
218
+ print(f'User: {question}')
219
+ print(f'Assistant: {response}')
220
+ ```
221
+
222
+ ## License
223
+
224
+ This project is released under the MIT license.
225
+
226
+ ## Citation
227
+
228
+ If you find this project useful in your research, please consider citing:
229
+
230
+ ```BibTeX
231
+ @article{chen2023internvl,
232
+ title={InternVL: Scaling up Vision Foundation Models and Aligning for Generic Visual-Linguistic Tasks},
233
+ author={Chen, Zhe and Wu, Jiannan and Wang, Wenhai and Su, Weijie and Chen, Guo and Xing, Sen and Zhong, Muyan and Zhang, Qinglong and Zhu, Xizhou and Lu, Lewei and Li, Bin and Luo, Ping and Lu, Tong and Qiao, Yu and Dai, Jifeng},
234
+ journal={arXiv preprint arXiv:2312.14238},
235
+ year={2023}
236
+ }
237
+ @article{chen2024far,
238
+ title={How Far Are We to GPT-4V? Closing the Gap to Commercial Multimodal Models with Open-Source Suites},
239
+ author={Chen, Zhe and Wang, Weiyun and Tian, Hao and Ye, Shenglong and Gao, Zhangwei and Cui, Erfei and Tong, Wenwen and Hu, Kongzhi and Luo, Jiapeng and Ma, Zheng and others},
240
+ journal={arXiv preprint arXiv:2404.16821},
241
+ year={2024}
242
+ }
243
+ ```
added_tokens.json ADDED
@@ -0,0 +1,11 @@
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "</box>": 92552,
3
+ "</img>": 92545,
4
+ "</quad>": 92548,
5
+ "</ref>": 92550,
6
+ "<IMG_CONTEXT>": 92546,
7
+ "<box>": 92551,
8
+ "<img>": 92544,
9
+ "<quad>": 92547,
10
+ "<ref>": 92549
11
+ }
config.json ADDED
@@ -0,0 +1,198 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "_commit_hash": null,
3
+ "architectures": [
4
+ "InternVLChatModel"
5
+ ],
6
+ "auto_map": {
7
+ "AutoConfig": "configuration_internvl_chat.InternVLChatConfig",
8
+ "AutoModel": "modeling_internvl_chat.InternVLChatModel",
9
+ "AutoModelForCausalLM": "modeling_internvl_chat.InternVLChatModel"
10
+ },
11
+ "downsample_ratio": 0.5,
12
+ "dynamic_image_size": true,
13
+ "force_image_size": 448,
14
+ "llm_config": {
15
+ "_name_or_path": "./pretrained/internlm2_5-7b-chat",
16
+ "add_cross_attention": false,
17
+ "architectures": [
18
+ "InternLM2ForCausalLM"
19
+ ],
20
+ "attn_implementation": "flash_attention_2",
21
+ "auto_map": {
22
+ "AutoConfig": "configuration_internlm2.InternLM2Config",
23
+ "AutoModel": "modeling_internlm2.InternLM2ForCausalLM",
24
+ "AutoModelForCausalLM": "modeling_internlm2.InternLM2ForCausalLM"
25
+ },
26
+ "bad_words_ids": null,
27
+ "begin_suppress_tokens": null,
28
+ "bias": false,
29
+ "bos_token_id": 1,
30
+ "chunk_size_feed_forward": 0,
31
+ "cross_attention_hidden_size": null,
32
+ "decoder_start_token_id": null,
33
+ "diversity_penalty": 0.0,
34
+ "do_sample": false,
35
+ "early_stopping": false,
36
+ "encoder_no_repeat_ngram_size": 0,
37
+ "eos_token_id": 2,
38
+ "exponential_decay_length_penalty": null,
39
+ "finetuning_task": null,
40
+ "forced_bos_token_id": null,
41
+ "forced_eos_token_id": null,
42
+ "hidden_act": "silu",
43
+ "hidden_size": 4096,
44
+ "id2label": {
45
+ "0": "LABEL_0",
46
+ "1": "LABEL_1"
47
+ },
48
+ "initializer_range": 0.02,
49
+ "intermediate_size": 14336,
50
+ "is_decoder": false,
51
+ "is_encoder_decoder": false,
52
+ "label2id": {
53
+ "LABEL_0": 0,
54
+ "LABEL_1": 1
55
+ },
56
+ "length_penalty": 1.0,
57
+ "max_length": 20,
58
+ "max_position_embeddings": 32768,
59
+ "min_length": 0,
60
+ "model_type": "internlm2",
61
+ "no_repeat_ngram_size": 0,
62
+ "num_attention_heads": 32,
63
+ "num_beam_groups": 1,
64
+ "num_beams": 1,
65
+ "num_hidden_layers": 32,
66
+ "num_key_value_heads": 8,
67
+ "num_return_sequences": 1,
68
+ "output_attentions": false,
69
+ "output_hidden_states": false,
70
+ "output_scores": false,
71
+ "pad_token_id": 2,
72
+ "prefix": null,
73
+ "pretraining_tp": 1,
74
+ "problem_type": null,
75
+ "pruned_heads": {},
76
+ "remove_invalid_values": false,
77
+ "repetition_penalty": 1.0,
78
+ "return_dict": true,
79
+ "return_dict_in_generate": false,
80
+ "rms_norm_eps": 1e-05,
81
+ "rope_scaling": {
82
+ "factor": 2.0,
83
+ "type": "dynamic"
84
+ },
85
+ "rope_theta": 1000000,
86
+ "sep_token_id": null,
87
+ "suppress_tokens": null,
88
+ "task_specific_params": null,
89
+ "temperature": 1.0,
90
+ "tf_legacy_loss": false,
91
+ "tie_encoder_decoder": false,
92
+ "tie_word_embeddings": false,
93
+ "tokenizer_class": null,
94
+ "top_k": 50,
95
+ "top_p": null,
96
+ "torch_dtype": "bfloat16",
97
+ "torchscript": false,
98
+ "transformers_version": "4.37.2",
99
+ "typical_p": 1.0,
100
+ "use_bfloat16": true,
101
+ "use_cache": true,
102
+ "vocab_size": 92553
103
+ },
104
+ "max_dynamic_patch": 12,
105
+ "min_dynamic_patch": 1,
106
+ "model_type": "internvl_chat",
107
+ "ps_version": "v2",
108
+ "select_layer": -1,
109
+ "template": "internlm2-chat",
110
+ "torch_dtype": "bfloat16",
111
+ "use_backbone_lora": 0,
112
+ "use_llm_lora": 0,
113
+ "use_thumbnail": true,
114
+ "vision_config": {
115
+ "_name_or_path": "",
116
+ "add_cross_attention": false,
117
+ "architectures": [
118
+ "InternVisionModel"
119
+ ],
120
+ "attention_dropout": 0.0,
121
+ "bad_words_ids": null,
122
+ "begin_suppress_tokens": null,
123
+ "bos_token_id": null,
124
+ "chunk_size_feed_forward": 0,
125
+ "cross_attention_hidden_size": null,
126
+ "decoder_start_token_id": null,
127
+ "diversity_penalty": 0.0,
128
+ "do_sample": false,
129
+ "drop_path_rate": 0.1,
130
+ "dropout": 0.0,
131
+ "early_stopping": false,
132
+ "encoder_no_repeat_ngram_size": 0,
133
+ "eos_token_id": null,
134
+ "exponential_decay_length_penalty": null,
135
+ "finetuning_task": null,
136
+ "forced_bos_token_id": null,
137
+ "forced_eos_token_id": null,
138
+ "hidden_act": "gelu",
139
+ "hidden_size": 1024,
140
+ "id2label": {
141
+ "0": "LABEL_0",
142
+ "1": "LABEL_1"
143
+ },
144
+ "image_size": 448,
145
+ "initializer_factor": 1.0,
146
+ "initializer_range": 0.02,
147
+ "intermediate_size": 4096,
148
+ "is_decoder": false,
149
+ "is_encoder_decoder": false,
150
+ "label2id": {
151
+ "LABEL_0": 0,
152
+ "LABEL_1": 1
153
+ },
154
+ "layer_norm_eps": 1e-06,
155
+ "length_penalty": 1.0,
156
+ "max_length": 20,
157
+ "min_length": 0,
158
+ "model_type": "intern_vit_6b",
159
+ "no_repeat_ngram_size": 0,
160
+ "norm_type": "layer_norm",
161
+ "num_attention_heads": 16,
162
+ "num_beam_groups": 1,
163
+ "num_beams": 1,
164
+ "num_channels": 3,
165
+ "num_hidden_layers": 24,
166
+ "num_return_sequences": 1,
167
+ "output_attentions": false,
168
+ "output_hidden_states": false,
169
+ "output_scores": false,
170
+ "pad_token_id": null,
171
+ "patch_size": 14,
172
+ "prefix": null,
173
+ "problem_type": null,
174
+ "pruned_heads": {},
175
+ "qk_normalization": false,
176
+ "qkv_bias": true,
177
+ "remove_invalid_values": false,
178
+ "repetition_penalty": 1.0,
179
+ "return_dict": true,
180
+ "return_dict_in_generate": false,
181
+ "sep_token_id": null,
182
+ "suppress_tokens": null,
183
+ "task_specific_params": null,
184
+ "temperature": 1.0,
185
+ "tf_legacy_loss": false,
186
+ "tie_encoder_decoder": false,
187
+ "tie_word_embeddings": true,
188
+ "tokenizer_class": null,
189
+ "top_k": 50,
190
+ "top_p": null,
191
+ "torch_dtype": "bfloat16",
192
+ "torchscript": false,
193
+ "transformers_version": "4.37.2",
194
+ "typical_p": 1.0,
195
+ "use_bfloat16": true,
196
+ "use_flash_attn": true
197
+ }
198
+ }
configuration_intern_vit.py ADDED
@@ -0,0 +1,119 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # --------------------------------------------------------
2
+ # InternVL
3
+ # Copyright (c) 2023 OpenGVLab
4
+ # Licensed under The MIT License [see LICENSE for details]
5
+ # --------------------------------------------------------
6
+ import os
7
+ from typing import Union
8
+
9
+ from transformers.configuration_utils import PretrainedConfig
10
+ from transformers.utils import logging
11
+
12
+ logger = logging.get_logger(__name__)
13
+
14
+
15
+ class InternVisionConfig(PretrainedConfig):
16
+ r"""
17
+ This is the configuration class to store the configuration of a [`InternVisionModel`]. It is used to
18
+ instantiate a vision encoder according to the specified arguments, defining the model architecture.
19
+
20
+ Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
21
+ documentation from [`PretrainedConfig`] for more information.
22
+
23
+ Args:
24
+ num_channels (`int`, *optional*, defaults to 3):
25
+ Number of color channels in the input images (e.g., 3 for RGB).
26
+ patch_size (`int`, *optional*, defaults to 14):
27
+ The size (resolution) of each patch.
28
+ image_size (`int`, *optional*, defaults to 224):
29
+ The size (resolution) of each image.
30
+ qkv_bias (`bool`, *optional*, defaults to `False`):
31
+ Whether to add a bias to the queries and values in the self-attention layers.
32
+ hidden_size (`int`, *optional*, defaults to 3200):
33
+ Dimensionality of the encoder layers and the pooler layer.
34
+ num_attention_heads (`int`, *optional*, defaults to 25):
35
+ Number of attention heads for each attention layer in the Transformer encoder.
36
+ intermediate_size (`int`, *optional*, defaults to 12800):
37
+ Dimensionality of the "intermediate" (i.e., feed-forward) layer in the Transformer encoder.
38
+ qk_normalization (`bool`, *optional*, defaults to `True`):
39
+ Whether to normalize the queries and keys in the self-attention layers.
40
+ num_hidden_layers (`int`, *optional*, defaults to 48):
41
+ Number of hidden layers in the Transformer encoder.
42
+ use_flash_attn (`bool`, *optional*, defaults to `True`):
43
+ Whether to use flash attention mechanism.
44
+ hidden_act (`str` or `function`, *optional*, defaults to `"gelu"`):
45
+ The non-linear activation function (function or string) in the encoder and pooler. If string, `"gelu"`,
46
+ `"relu"`, `"selu"` and `"gelu_new"` ``"gelu"` are supported.
47
+ layer_norm_eps (`float`, *optional*, defaults to 1e-6):
48
+ The epsilon used by the layer normalization layers.
49
+ dropout (`float`, *optional*, defaults to 0.0):
50
+ The dropout probability for all fully connected layers in the embeddings, encoder, and pooler.
51
+ drop_path_rate (`float`, *optional*, defaults to 0.0):
52
+ Dropout rate for stochastic depth.
53
+ attention_dropout (`float`, *optional*, defaults to 0.0):
54
+ The dropout ratio for the attention probabilities.
55
+ initializer_range (`float`, *optional*, defaults to 0.02):
56
+ The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
57
+ initializer_factor (`float`, *optional*, defaults to 0.1):
58
+ A factor for layer scale.
59
+ """
60
+
61
+ model_type = 'intern_vit_6b'
62
+
63
+ def __init__(
64
+ self,
65
+ num_channels=3,
66
+ patch_size=14,
67
+ image_size=224,
68
+ qkv_bias=False,
69
+ hidden_size=3200,
70
+ num_attention_heads=25,
71
+ intermediate_size=12800,
72
+ qk_normalization=True,
73
+ num_hidden_layers=48,
74
+ use_flash_attn=True,
75
+ hidden_act='gelu',
76
+ norm_type='rms_norm',
77
+ layer_norm_eps=1e-6,
78
+ dropout=0.0,
79
+ drop_path_rate=0.0,
80
+ attention_dropout=0.0,
81
+ initializer_range=0.02,
82
+ initializer_factor=0.1,
83
+ **kwargs,
84
+ ):
85
+ super().__init__(**kwargs)
86
+
87
+ self.hidden_size = hidden_size
88
+ self.intermediate_size = intermediate_size
89
+ self.dropout = dropout
90
+ self.drop_path_rate = drop_path_rate
91
+ self.num_hidden_layers = num_hidden_layers
92
+ self.num_attention_heads = num_attention_heads
93
+ self.num_channels = num_channels
94
+ self.patch_size = patch_size
95
+ self.image_size = image_size
96
+ self.initializer_range = initializer_range
97
+ self.initializer_factor = initializer_factor
98
+ self.attention_dropout = attention_dropout
99
+ self.layer_norm_eps = layer_norm_eps
100
+ self.hidden_act = hidden_act
101
+ self.norm_type = norm_type
102
+ self.qkv_bias = qkv_bias
103
+ self.qk_normalization = qk_normalization
104
+ self.use_flash_attn = use_flash_attn
105
+
106
+ @classmethod
107
+ def from_pretrained(cls, pretrained_model_name_or_path: Union[str, os.PathLike], **kwargs) -> 'PretrainedConfig':
108
+ config_dict, kwargs = cls.get_config_dict(pretrained_model_name_or_path, **kwargs)
109
+
110
+ if 'vision_config' in config_dict:
111
+ config_dict = config_dict['vision_config']
112
+
113
+ if 'model_type' in config_dict and hasattr(cls, 'model_type') and config_dict['model_type'] != cls.model_type:
114
+ logger.warning(
115
+ f"You are using a model of type {config_dict['model_type']} to instantiate a model of type "
116
+ f'{cls.model_type}. This is not supported for all configurations of models and can yield errors.'
117
+ )
118
+
119
+ return cls.from_dict(config_dict, **kwargs)
configuration_internlm2.py ADDED
@@ -0,0 +1,150 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Copyright (c) The InternLM team and The HuggingFace Inc. team. All rights reserved.
2
+ #
3
+ # This code is based on transformers/src/transformers/models/llama/configuration_llama.py
4
+ #
5
+ # Licensed under the Apache License, Version 2.0 (the "License");
6
+ # you may not use this file except in compliance with the License.
7
+ # You may obtain a copy of the License at
8
+ #
9
+ # http://www.apache.org/licenses/LICENSE-2.0
10
+ #
11
+ # Unless required by applicable law or agreed to in writing, software
12
+ # distributed under the License is distributed on an "AS IS" BASIS,
13
+ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14
+ # See the License for the specific language governing permissions and
15
+ # limitations under the License.
16
+ """ InternLM2 model configuration"""
17
+
18
+ from transformers.configuration_utils import PretrainedConfig
19
+ from transformers.utils import logging
20
+
21
+ logger = logging.get_logger(__name__)
22
+
23
+ INTERNLM2_PRETRAINED_CONFIG_ARCHIVE_MAP = {}
24
+
25
+
26
+ # Modified from transformers.model.llama.configuration_llama.LlamaConfig
27
+ class InternLM2Config(PretrainedConfig):
28
+ r"""
29
+ This is the configuration class to store the configuration of a [`InternLM2Model`]. It is used to instantiate
30
+ an InternLM2 model according to the specified arguments, defining the model architecture. Instantiating a
31
+ configuration with the defaults will yield a similar configuration to that of the InternLM2-7B.
32
+
33
+ Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
34
+ documentation from [`PretrainedConfig`] for more information.
35
+
36
+
37
+ Args:
38
+ vocab_size (`int`, *optional*, defaults to 32000):
39
+ Vocabulary size of the InternLM2 model. Defines the number of different tokens that can be represented by the
40
+ `inputs_ids` passed when calling [`InternLM2Model`]
41
+ hidden_size (`int`, *optional*, defaults to 4096):
42
+ Dimension of the hidden representations.
43
+ intermediate_size (`int`, *optional*, defaults to 11008):
44
+ Dimension of the MLP representations.
45
+ num_hidden_layers (`int`, *optional*, defaults to 32):
46
+ Number of hidden layers in the Transformer encoder.
47
+ num_attention_heads (`int`, *optional*, defaults to 32):
48
+ Number of attention heads for each attention layer in the Transformer encoder.
49
+ num_key_value_heads (`int`, *optional*):
50
+ This is the number of key_value heads that should be used to implement Grouped Query Attention. If
51
+ `num_key_value_heads=num_attention_heads`, the model will use Multi Head Attention (MHA), if
52
+ `num_key_value_heads=1 the model will use Multi Query Attention (MQA) otherwise GQA is used. When
53
+ converting a multi-head checkpoint to a GQA checkpoint, each group key and value head should be constructed
54
+ by meanpooling all the original heads within that group. For more details checkout [this
55
+ paper](https://arxiv.org/pdf/2305.13245.pdf). If it is not specified, will default to
56
+ `num_attention_heads`.
57
+ hidden_act (`str` or `function`, *optional*, defaults to `"silu"`):
58
+ The non-linear activation function (function or string) in the decoder.
59
+ max_position_embeddings (`int`, *optional*, defaults to 2048):
60
+ The maximum sequence length that this model might ever be used with. Typically set this to something large
61
+ just in case (e.g., 512 or 1024 or 2048).
62
+ initializer_range (`float`, *optional*, defaults to 0.02):
63
+ The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
64
+ rms_norm_eps (`float`, *optional*, defaults to 1e-12):
65
+ The epsilon used by the rms normalization layers.
66
+ use_cache (`bool`, *optional*, defaults to `True`):
67
+ Whether or not the model should return the last key/values attentions (not used by all models). Only
68
+ relevant if `config.is_decoder=True`.
69
+ tie_word_embeddings(`bool`, *optional*, defaults to `False`):
70
+ Whether to tie weight embeddings
71
+ Example:
72
+
73
+ """
74
+ model_type = 'internlm2'
75
+ _auto_class = 'AutoConfig'
76
+
77
+ def __init__( # pylint: disable=W0102
78
+ self,
79
+ vocab_size=103168,
80
+ hidden_size=4096,
81
+ intermediate_size=11008,
82
+ num_hidden_layers=32,
83
+ num_attention_heads=32,
84
+ num_key_value_heads=None,
85
+ hidden_act='silu',
86
+ max_position_embeddings=2048,
87
+ initializer_range=0.02,
88
+ rms_norm_eps=1e-6,
89
+ use_cache=True,
90
+ pad_token_id=0,
91
+ bos_token_id=1,
92
+ eos_token_id=2,
93
+ tie_word_embeddings=False,
94
+ bias=True,
95
+ rope_theta=10000,
96
+ rope_scaling=None,
97
+ attn_implementation='eager',
98
+ **kwargs,
99
+ ):
100
+ self.vocab_size = vocab_size
101
+ self.max_position_embeddings = max_position_embeddings
102
+ self.hidden_size = hidden_size
103
+ self.intermediate_size = intermediate_size
104
+ self.num_hidden_layers = num_hidden_layers
105
+ self.num_attention_heads = num_attention_heads
106
+ self.bias = bias
107
+
108
+ if num_key_value_heads is None:
109
+ num_key_value_heads = num_attention_heads
110
+ self.num_key_value_heads = num_key_value_heads
111
+
112
+ self.hidden_act = hidden_act
113
+ self.initializer_range = initializer_range
114
+ self.rms_norm_eps = rms_norm_eps
115
+ self.use_cache = use_cache
116
+ self.rope_theta = rope_theta
117
+ self.rope_scaling = rope_scaling
118
+ self._rope_scaling_validation()
119
+
120
+ self.attn_implementation = attn_implementation
121
+ if self.attn_implementation is None:
122
+ self.attn_implementation = 'eager'
123
+ super().__init__(
124
+ pad_token_id=pad_token_id,
125
+ bos_token_id=bos_token_id,
126
+ eos_token_id=eos_token_id,
127
+ tie_word_embeddings=tie_word_embeddings,
128
+ **kwargs,
129
+ )
130
+
131
+ def _rope_scaling_validation(self):
132
+ """
133
+ Validate the `rope_scaling` configuration.
134
+ """
135
+ if self.rope_scaling is None:
136
+ return
137
+
138
+ if not isinstance(self.rope_scaling, dict) or len(self.rope_scaling) != 2:
139
+ raise ValueError(
140
+ '`rope_scaling` must be a dictionary with with two fields, `type` and `factor`, '
141
+ f'got {self.rope_scaling}'
142
+ )
143
+ rope_scaling_type = self.rope_scaling.get('type', None)
144
+ rope_scaling_factor = self.rope_scaling.get('factor', None)
145
+ if rope_scaling_type is None or rope_scaling_type not in ['linear', 'dynamic']:
146
+ raise ValueError(
147
+ f"`rope_scaling`'s type field must be one of ['linear', 'dynamic'], got {rope_scaling_type}"
148
+ )
149
+ if rope_scaling_factor is None or not isinstance(rope_scaling_factor, float) or rope_scaling_factor < 1.0:
150
+ raise ValueError(f"`rope_scaling`'s factor field must be a float >= 1, got {rope_scaling_factor}")
configuration_internvl_chat.py ADDED
@@ -0,0 +1,99 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # --------------------------------------------------------
2
+ # InternVL
3
+ # Copyright (c) 2023 OpenGVLab
4
+ # Licensed under The MIT License [see LICENSE for details]
5
+ # --------------------------------------------------------
6
+
7
+ import copy
8
+
9
+ from transformers import AutoConfig, LlamaConfig
10
+ from transformers.configuration_utils import PretrainedConfig
11
+ from transformers.utils import logging
12
+
13
+ from .configuration_intern_vit import InternVisionConfig
14
+ from .configuration_internlm2 import InternLM2Config
15
+
16
+ logger = logging.get_logger(__name__)
17
+
18
+
19
+ class InternVLChatConfig(PretrainedConfig):
20
+ model_type = 'internvl_chat'
21
+ is_composition = True
22
+
23
+ def __init__(
24
+ self,
25
+ vision_config=None,
26
+ llm_config=None,
27
+ use_backbone_lora=0,
28
+ use_llm_lora=0,
29
+ pad2square=False,
30
+ select_layer=-1,
31
+ force_image_size=None,
32
+ downsample_ratio=0.5,
33
+ template=None,
34
+ dynamic_image_size=False,
35
+ use_thumbnail=False,
36
+ ps_version='v1',
37
+ min_dynamic_patch=1,
38
+ max_dynamic_patch=6,
39
+ **kwargs):
40
+ super().__init__(**kwargs)
41
+
42
+ if vision_config is None:
43
+ vision_config = {}
44
+ logger.info('vision_config is None. Initializing the InternVisionConfig with default values.')
45
+
46
+ if llm_config is None:
47
+ llm_config = {}
48
+ logger.info('llm_config is None. Initializing the LlamaConfig config with default values (`LlamaConfig`).')
49
+
50
+ self.vision_config = InternVisionConfig(**vision_config)
51
+ if llm_config['architectures'][0] == 'LlamaForCausalLM':
52
+ self.llm_config = LlamaConfig(**llm_config)
53
+ elif llm_config['architectures'][0] == 'InternLM2ForCausalLM':
54
+ self.llm_config = InternLM2Config(**llm_config)
55
+ else:
56
+ raise ValueError('Unsupported architecture: {}'.format(llm_config['architectures'][0]))
57
+ self.use_backbone_lora = use_backbone_lora
58
+ self.use_llm_lora = use_llm_lora
59
+ self.pad2square = pad2square
60
+ self.select_layer = select_layer
61
+ self.force_image_size = force_image_size
62
+ self.downsample_ratio = downsample_ratio
63
+ self.template = template
64
+ self.dynamic_image_size = dynamic_image_size
65
+ self.use_thumbnail = use_thumbnail
66
+ self.ps_version = ps_version # pixel shuffle version
67
+ self.min_dynamic_patch = min_dynamic_patch
68
+ self.max_dynamic_patch = max_dynamic_patch
69
+
70
+ logger.info(f'vision_select_layer: {self.select_layer}')
71
+ logger.info(f'ps_version: {self.ps_version}')
72
+ logger.info(f'min_dynamic_patch: {self.min_dynamic_patch}')
73
+ logger.info(f'max_dynamic_patch: {self.max_dynamic_patch}')
74
+
75
+ def to_dict(self):
76
+ """
77
+ Serializes this instance to a Python dictionary. Override the default [`~PretrainedConfig.to_dict`].
78
+
79
+ Returns:
80
+ `Dict[str, any]`: Dictionary of all the attributes that make up this configuration instance,
81
+ """
82
+ output = copy.deepcopy(self.__dict__)
83
+ output['vision_config'] = self.vision_config.to_dict()
84
+ output['llm_config'] = self.llm_config.to_dict()
85
+ output['model_type'] = self.__class__.model_type
86
+ output['use_backbone_lora'] = self.use_backbone_lora
87
+ output['use_llm_lora'] = self.use_llm_lora
88
+ output['pad2square'] = self.pad2square
89
+ output['select_layer'] = self.select_layer
90
+ output['force_image_size'] = self.force_image_size
91
+ output['downsample_ratio'] = self.downsample_ratio
92
+ output['template'] = self.template
93
+ output['dynamic_image_size'] = self.dynamic_image_size
94
+ output['use_thumbnail'] = self.use_thumbnail
95
+ output['ps_version'] = self.ps_version
96
+ output['min_dynamic_patch'] = self.min_dynamic_patch
97
+ output['max_dynamic_patch'] = self.max_dynamic_patch
98
+
99
+ return output
conversation.py ADDED
@@ -0,0 +1,383 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """
2
+ Conversation prompt templates.
3
+
4
+ We kindly request that you import fastchat instead of copying this file if you wish to use it.
5
+ If you have any changes in mind, please contribute back so the community can benefit collectively and continue to maintain these valuable templates.
6
+ """
7
+
8
+ import dataclasses
9
+ from enum import IntEnum, auto
10
+ from typing import Any, Dict, List, Tuple, Union
11
+
12
+
13
+ class SeparatorStyle(IntEnum):
14
+ """Separator styles."""
15
+
16
+ ADD_COLON_SINGLE = auto()
17
+ ADD_COLON_TWO = auto()
18
+ ADD_COLON_SPACE_SINGLE = auto()
19
+ NO_COLON_SINGLE = auto()
20
+ NO_COLON_TWO = auto()
21
+ ADD_NEW_LINE_SINGLE = auto()
22
+ LLAMA2 = auto()
23
+ CHATGLM = auto()
24
+ CHATML = auto()
25
+ CHATINTERN = auto()
26
+ DOLLY = auto()
27
+ RWKV = auto()
28
+ PHOENIX = auto()
29
+ ROBIN = auto()
30
+ FALCON_CHAT = auto()
31
+ CHATGLM3 = auto()
32
+ INTERNVL_ZH = auto()
33
+ MPT = auto()
34
+
35
+
36
+ @dataclasses.dataclass
37
+ class Conversation:
38
+ """A class that manages prompt templates and keeps all conversation history."""
39
+
40
+ # The name of this template
41
+ name: str
42
+ # The template of the system prompt
43
+ system_template: str = '{system_message}'
44
+ # The system message
45
+ system_message: str = ''
46
+ # The names of two roles
47
+ roles: Tuple[str] = ('USER', 'ASSISTANT')
48
+ # All messages. Each item is (role, message).
49
+ messages: List[List[str]] = ()
50
+ # The number of few shot examples
51
+ offset: int = 0
52
+ # The separator style and configurations
53
+ sep_style: SeparatorStyle = SeparatorStyle.ADD_COLON_SINGLE
54
+ sep: str = '\n'
55
+ sep2: str = None
56
+ # Stop criteria (the default one is EOS token)
57
+ stop_str: Union[str, List[str]] = None
58
+ # Stops generation if meeting any token in this list
59
+ stop_token_ids: List[int] = None
60
+
61
+ def get_prompt(self) -> str:
62
+ """Get the prompt for generation."""
63
+ system_prompt = self.system_template.format(system_message=self.system_message)
64
+ if self.sep_style == SeparatorStyle.ADD_COLON_SINGLE:
65
+ ret = system_prompt + self.sep
66
+ for role, message in self.messages:
67
+ if message:
68
+ ret += role + ': ' + message + self.sep
69
+ else:
70
+ ret += role + ':'
71
+ return ret
72
+ elif self.sep_style == SeparatorStyle.ADD_COLON_TWO:
73
+ seps = [self.sep, self.sep2]
74
+ ret = system_prompt + seps[0]
75
+ for i, (role, message) in enumerate(self.messages):
76
+ if message:
77
+ ret += role + ': ' + message + seps[i % 2]
78
+ else:
79
+ ret += role + ':'
80
+ return ret
81
+ elif self.sep_style == SeparatorStyle.ADD_COLON_SPACE_SINGLE:
82
+ ret = system_prompt + self.sep
83
+ for role, message in self.messages:
84
+ if message:
85
+ ret += role + ': ' + message + self.sep
86
+ else:
87
+ ret += role + ': ' # must be end with a space
88
+ return ret
89
+ elif self.sep_style == SeparatorStyle.ADD_NEW_LINE_SINGLE:
90
+ ret = '' if system_prompt == '' else system_prompt + self.sep
91
+ for role, message in self.messages:
92
+ if message:
93
+ ret += role + '\n' + message + self.sep
94
+ else:
95
+ ret += role + '\n'
96
+ return ret
97
+ elif self.sep_style == SeparatorStyle.NO_COLON_SINGLE:
98
+ ret = system_prompt
99
+ for role, message in self.messages:
100
+ if message:
101
+ ret += role + message + self.sep
102
+ else:
103
+ ret += role
104
+ return ret
105
+ elif self.sep_style == SeparatorStyle.NO_COLON_TWO:
106
+ seps = [self.sep, self.sep2]
107
+ ret = system_prompt
108
+ for i, (role, message) in enumerate(self.messages):
109
+ if message:
110
+ ret += role + message + seps[i % 2]
111
+ else:
112
+ ret += role
113
+ return ret
114
+ elif self.sep_style == SeparatorStyle.RWKV:
115
+ ret = system_prompt
116
+ for i, (role, message) in enumerate(self.messages):
117
+ if message:
118
+ ret += (
119
+ role
120
+ + ': '
121
+ + message.replace('\r\n', '\n').replace('\n\n', '\n')
122
+ )
123
+ ret += '\n\n'
124
+ else:
125
+ ret += role + ':'
126
+ return ret
127
+ elif self.sep_style == SeparatorStyle.LLAMA2:
128
+ seps = [self.sep, self.sep2]
129
+ if self.system_message:
130
+ ret = system_prompt
131
+ else:
132
+ ret = '[INST] '
133
+ for i, (role, message) in enumerate(self.messages):
134
+ tag = self.roles[i % 2]
135
+ if message:
136
+ if i == 0:
137
+ ret += message + ' '
138
+ else:
139
+ ret += tag + ' ' + message + seps[i % 2]
140
+ else:
141
+ ret += tag
142
+ return ret
143
+ elif self.sep_style == SeparatorStyle.CHATGLM:
144
+ # source: https://huggingface.co/THUDM/chatglm-6b/blob/1d240ba371910e9282298d4592532d7f0f3e9f3e/modeling_chatglm.py#L1302-L1308
145
+ # source2: https://huggingface.co/THUDM/chatglm2-6b/blob/e186c891cf64310ac66ef10a87e6635fa6c2a579/modeling_chatglm.py#L926
146
+ round_add_n = 1 if self.name == 'chatglm2' else 0
147
+ if system_prompt:
148
+ ret = system_prompt + self.sep
149
+ else:
150
+ ret = ''
151
+
152
+ for i, (role, message) in enumerate(self.messages):
153
+ if i % 2 == 0:
154
+ ret += f'[Round {i//2 + round_add_n}]{self.sep}'
155
+
156
+ if message:
157
+ ret += f'{role}:{message}{self.sep}'
158
+ else:
159
+ ret += f'{role}:'
160
+ return ret
161
+ elif self.sep_style == SeparatorStyle.CHATML:
162
+ ret = '' if system_prompt == '' else system_prompt + self.sep + '\n'
163
+ for role, message in self.messages:
164
+ if message:
165
+ ret += role + '\n' + message + self.sep + '\n'
166
+ else:
167
+ ret += role + '\n'
168
+ return ret
169
+ elif self.sep_style == SeparatorStyle.CHATGLM3:
170
+ ret = ''
171
+ if self.system_message:
172
+ ret += system_prompt
173
+ for role, message in self.messages:
174
+ if message:
175
+ ret += role + '\n' + ' ' + message
176
+ else:
177
+ ret += role
178
+ return ret
179
+ elif self.sep_style == SeparatorStyle.CHATINTERN:
180
+ # source: https://huggingface.co/internlm/internlm-chat-7b-8k/blob/bd546fa984b4b0b86958f56bf37f94aa75ab8831/modeling_internlm.py#L771
181
+ seps = [self.sep, self.sep2]
182
+ ret = system_prompt
183
+ for i, (role, message) in enumerate(self.messages):
184
+ # if i % 2 == 0:
185
+ # ret += "<s>"
186
+ if message:
187
+ ret += role + ':' + message + seps[i % 2] + '\n'
188
+ else:
189
+ ret += role + ':'
190
+ return ret
191
+ elif self.sep_style == SeparatorStyle.DOLLY:
192
+ seps = [self.sep, self.sep2]
193
+ ret = system_prompt
194
+ for i, (role, message) in enumerate(self.messages):
195
+ if message:
196
+ ret += role + ':\n' + message + seps[i % 2]
197
+ if i % 2 == 1:
198
+ ret += '\n\n'
199
+ else:
200
+ ret += role + ':\n'
201
+ return ret
202
+ elif self.sep_style == SeparatorStyle.PHOENIX:
203
+ ret = system_prompt
204
+ for role, message in self.messages:
205
+ if message:
206
+ ret += role + ': ' + '<s>' + message + '</s>'
207
+ else:
208
+ ret += role + ': ' + '<s>'
209
+ return ret
210
+ elif self.sep_style == SeparatorStyle.ROBIN:
211
+ ret = system_prompt + self.sep
212
+ for role, message in self.messages:
213
+ if message:
214
+ ret += role + ':\n' + message + self.sep
215
+ else:
216
+ ret += role + ':\n'
217
+ return ret
218
+ elif self.sep_style == SeparatorStyle.FALCON_CHAT:
219
+ ret = ''
220
+ if self.system_message:
221
+ ret += system_prompt + self.sep
222
+ for role, message in self.messages:
223
+ if message:
224
+ ret += role + ': ' + message + self.sep
225
+ else:
226
+ ret += role + ':'
227
+
228
+ return ret
229
+ elif self.sep_style == SeparatorStyle.INTERNVL_ZH:
230
+ seps = [self.sep, self.sep2]
231
+ ret = self.system_message + seps[0]
232
+ for i, (role, message) in enumerate(self.messages):
233
+ if message:
234
+ ret += role + ': ' + message + seps[i % 2]
235
+ else:
236
+ ret += role + ':'
237
+ return ret
238
+ elif self.sep_style == SeparatorStyle.MPT:
239
+ ret = system_prompt + self.sep
240
+ for role, message in self.messages:
241
+ if message:
242
+ if type(message) is tuple:
243
+ message, _, _ = message
244
+ ret += role + message + self.sep
245
+ else:
246
+ ret += role
247
+ return ret
248
+ else:
249
+ raise ValueError(f'Invalid style: {self.sep_style}')
250
+
251
+ def set_system_message(self, system_message: str):
252
+ """Set the system message."""
253
+ self.system_message = system_message
254
+
255
+ def append_message(self, role: str, message: str):
256
+ """Append a new message."""
257
+ self.messages.append([role, message])
258
+
259
+ def update_last_message(self, message: str):
260
+ """Update the last output.
261
+
262
+ The last message is typically set to be None when constructing the prompt,
263
+ so we need to update it in-place after getting the response from a model.
264
+ """
265
+ self.messages[-1][1] = message
266
+
267
+ def to_gradio_chatbot(self):
268
+ """Convert the conversation to gradio chatbot format."""
269
+ ret = []
270
+ for i, (role, msg) in enumerate(self.messages[self.offset :]):
271
+ if i % 2 == 0:
272
+ ret.append([msg, None])
273
+ else:
274
+ ret[-1][-1] = msg
275
+ return ret
276
+
277
+ def to_openai_api_messages(self):
278
+ """Convert the conversation to OpenAI chat completion format."""
279
+ ret = [{'role': 'system', 'content': self.system_message}]
280
+
281
+ for i, (_, msg) in enumerate(self.messages[self.offset :]):
282
+ if i % 2 == 0:
283
+ ret.append({'role': 'user', 'content': msg})
284
+ else:
285
+ if msg is not None:
286
+ ret.append({'role': 'assistant', 'content': msg})
287
+ return ret
288
+
289
+ def copy(self):
290
+ return Conversation(
291
+ name=self.name,
292
+ system_template=self.system_template,
293
+ system_message=self.system_message,
294
+ roles=self.roles,
295
+ messages=[[x, y] for x, y in self.messages],
296
+ offset=self.offset,
297
+ sep_style=self.sep_style,
298
+ sep=self.sep,
299
+ sep2=self.sep2,
300
+ stop_str=self.stop_str,
301
+ stop_token_ids=self.stop_token_ids,
302
+ )
303
+
304
+ def dict(self):
305
+ return {
306
+ 'template_name': self.name,
307
+ 'system_message': self.system_message,
308
+ 'roles': self.roles,
309
+ 'messages': self.messages,
310
+ 'offset': self.offset,
311
+ }
312
+
313
+
314
+ # A global registry for all conversation templates
315
+ conv_templates: Dict[str, Conversation] = {}
316
+
317
+
318
+ def register_conv_template(template: Conversation, override: bool = False):
319
+ """Register a new conversation template."""
320
+ if not override:
321
+ assert (
322
+ template.name not in conv_templates
323
+ ), f'{template.name} has been registered.'
324
+
325
+ conv_templates[template.name] = template
326
+
327
+
328
+ def get_conv_template(name: str) -> Conversation:
329
+ """Get a conversation template."""
330
+ return conv_templates[name].copy()
331
+
332
+
333
+ register_conv_template(
334
+ Conversation(
335
+ name='Hermes-2',
336
+ system_template='<|im_start|>system\n{system_message}',
337
+ system_message='你是由上海人工智能实验室联合商汤科技开发的书生多模态大模型,英文名叫InternVL, 是一个有用无害的人工智能助手。',
338
+ roles=('<|im_start|>user\n', '<|im_start|>assistant\n'),
339
+ sep_style=SeparatorStyle.MPT,
340
+ sep='<|im_end|>',
341
+ stop_token_ids=[
342
+ 2,
343
+ 6,
344
+ 7,
345
+ 8,
346
+ ], # "<|endoftext|>", "<|im_start|>", "<|im_end|>", "<|im_sep|>"
347
+ stop_str='<|endoftext|>',
348
+ )
349
+ )
350
+
351
+
352
+ register_conv_template(
353
+ Conversation(
354
+ name='internlm2-chat',
355
+ system_template='<|im_start|>system\n{system_message}',
356
+ system_message='你是由上海人工智能实验室联合商汤科技开发的书生多模态大模型,英文名叫InternVL, 是一个有用无害的人工智能助手。',
357
+ roles=('<|im_start|>user\n', '<|im_start|>assistant\n'),
358
+ sep_style=SeparatorStyle.MPT,
359
+ sep='<|im_end|>',
360
+ stop_token_ids=[
361
+ 2,
362
+ 92543,
363
+ 92542
364
+ ]
365
+ )
366
+ )
367
+
368
+
369
+ register_conv_template(
370
+ Conversation(
371
+ name='phi3-chat',
372
+ system_template='<|system|>\n{system_message}',
373
+ system_message='你是由上海人工智能实验室联合商汤科技开发的书生多模态大模型,英文名叫InternVL, 是一个有用无害的人工智能助手。',
374
+ roles=('<|user|>\n', '<|assistant|>\n'),
375
+ sep_style=SeparatorStyle.MPT,
376
+ sep='<|end|>',
377
+ stop_token_ids=[
378
+ 2,
379
+ 32000,
380
+ 32007
381
+ ]
382
+ )
383
+ )
generation_config.json ADDED
@@ -0,0 +1,4 @@
 
 
 
 
 
1
+ {
2
+ "_from_model_config": true,
3
+ "transformers_version": "4.37.2"
4
+ }
model-00001-of-00004.safetensors ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:3a18c6c843dd1c046a7052129ac7ff5d3fa38e95149ea6ee763066dc1cc6579c
3
+ size 4939944336
model-00002-of-00004.safetensors ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:e1967d2442fe5a38aba96e7ad7a18459962171591e5b7438aa0efa15db93b375
3
+ size 4915914584
model-00003-of-00004.safetensors ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:9d31a1bd34e26858251c02741d450f64937b59bf3e45a2efede61a10c2086768
3
+ size 4915914592
model-00004-of-00004.safetensors ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:5f20c98a99d6fcf5c01b70194b80984ad0b49220f365f7c415af7629743a5397
3
+ size 1379026920
model.safetensors.index.json ADDED
@@ -0,0 +1,580 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "metadata": {
3
+ "total_size": 16150730752
4
+ },
5
+ "weight_map": {
6
+ "language_model.model.layers.0.attention.wo.weight": "model-00001-of-00004.safetensors",
7
+ "language_model.model.layers.0.attention.wqkv.weight": "model-00001-of-00004.safetensors",
8
+ "language_model.model.layers.0.attention_norm.weight": "model-00001-of-00004.safetensors",
9
+ "language_model.model.layers.0.feed_forward.w1.weight": "model-00001-of-00004.safetensors",
10
+ "language_model.model.layers.0.feed_forward.w2.weight": "model-00001-of-00004.safetensors",
11
+ "language_model.model.layers.0.feed_forward.w3.weight": "model-00001-of-00004.safetensors",
12
+ "language_model.model.layers.0.ffn_norm.weight": "model-00001-of-00004.safetensors",
13
+ "language_model.model.layers.1.attention.wo.weight": "model-00001-of-00004.safetensors",
14
+ "language_model.model.layers.1.attention.wqkv.weight": "model-00001-of-00004.safetensors",
15
+ "language_model.model.layers.1.attention_norm.weight": "model-00001-of-00004.safetensors",
16
+ "language_model.model.layers.1.feed_forward.w1.weight": "model-00001-of-00004.safetensors",
17
+ "language_model.model.layers.1.feed_forward.w2.weight": "model-00001-of-00004.safetensors",
18
+ "language_model.model.layers.1.feed_forward.w3.weight": "model-00001-of-00004.safetensors",
19
+ "language_model.model.layers.1.ffn_norm.weight": "model-00001-of-00004.safetensors",
20
+ "language_model.model.layers.10.attention.wo.weight": "model-00002-of-00004.safetensors",
21
+ "language_model.model.layers.10.attention.wqkv.weight": "model-00002-of-00004.safetensors",
22
+ "language_model.model.layers.10.attention_norm.weight": "model-00002-of-00004.safetensors",
23
+ "language_model.model.layers.10.feed_forward.w1.weight": "model-00002-of-00004.safetensors",
24
+ "language_model.model.layers.10.feed_forward.w2.weight": "model-00002-of-00004.safetensors",
25
+ "language_model.model.layers.10.feed_forward.w3.weight": "model-00002-of-00004.safetensors",
26
+ "language_model.model.layers.10.ffn_norm.weight": "model-00002-of-00004.safetensors",
27
+ "language_model.model.layers.11.attention.wo.weight": "model-00002-of-00004.safetensors",
28
+ "language_model.model.layers.11.attention.wqkv.weight": "model-00002-of-00004.safetensors",
29
+ "language_model.model.layers.11.attention_norm.weight": "model-00002-of-00004.safetensors",
30
+ "language_model.model.layers.11.feed_forward.w1.weight": "model-00002-of-00004.safetensors",
31
+ "language_model.model.layers.11.feed_forward.w2.weight": "model-00002-of-00004.safetensors",
32
+ "language_model.model.layers.11.feed_forward.w3.weight": "model-00002-of-00004.safetensors",
33
+ "language_model.model.layers.11.ffn_norm.weight": "model-00002-of-00004.safetensors",
34
+ "language_model.model.layers.12.attention.wo.weight": "model-00002-of-00004.safetensors",
35
+ "language_model.model.layers.12.attention.wqkv.weight": "model-00002-of-00004.safetensors",
36
+ "language_model.model.layers.12.attention_norm.weight": "model-00002-of-00004.safetensors",
37
+ "language_model.model.layers.12.feed_forward.w1.weight": "model-00002-of-00004.safetensors",
38
+ "language_model.model.layers.12.feed_forward.w2.weight": "model-00002-of-00004.safetensors",
39
+ "language_model.model.layers.12.feed_forward.w3.weight": "model-00002-of-00004.safetensors",
40
+ "language_model.model.layers.12.ffn_norm.weight": "model-00002-of-00004.safetensors",
41
+ "language_model.model.layers.13.attention.wo.weight": "model-00002-of-00004.safetensors",
42
+ "language_model.model.layers.13.attention.wqkv.weight": "model-00002-of-00004.safetensors",
43
+ "language_model.model.layers.13.attention_norm.weight": "model-00002-of-00004.safetensors",
44
+ "language_model.model.layers.13.feed_forward.w1.weight": "model-00002-of-00004.safetensors",
45
+ "language_model.model.layers.13.feed_forward.w2.weight": "model-00002-of-00004.safetensors",
46
+ "language_model.model.layers.13.feed_forward.w3.weight": "model-00002-of-00004.safetensors",
47
+ "language_model.model.layers.13.ffn_norm.weight": "model-00002-of-00004.safetensors",
48
+ "language_model.model.layers.14.attention.wo.weight": "model-00002-of-00004.safetensors",
49
+ "language_model.model.layers.14.attention.wqkv.weight": "model-00002-of-00004.safetensors",
50
+ "language_model.model.layers.14.attention_norm.weight": "model-00002-of-00004.safetensors",
51
+ "language_model.model.layers.14.feed_forward.w1.weight": "model-00002-of-00004.safetensors",
52
+ "language_model.model.layers.14.feed_forward.w2.weight": "model-00002-of-00004.safetensors",
53
+ "language_model.model.layers.14.feed_forward.w3.weight": "model-00002-of-00004.safetensors",
54
+ "language_model.model.layers.14.ffn_norm.weight": "model-00002-of-00004.safetensors",
55
+ "language_model.model.layers.15.attention.wo.weight": "model-00002-of-00004.safetensors",
56
+ "language_model.model.layers.15.attention.wqkv.weight": "model-00002-of-00004.safetensors",
57
+ "language_model.model.layers.15.attention_norm.weight": "model-00002-of-00004.safetensors",
58
+ "language_model.model.layers.15.feed_forward.w1.weight": "model-00002-of-00004.safetensors",
59
+ "language_model.model.layers.15.feed_forward.w2.weight": "model-00002-of-00004.safetensors",
60
+ "language_model.model.layers.15.feed_forward.w3.weight": "model-00002-of-00004.safetensors",
61
+ "language_model.model.layers.15.ffn_norm.weight": "model-00002-of-00004.safetensors",
62
+ "language_model.model.layers.16.attention.wo.weight": "model-00002-of-00004.safetensors",
63
+ "language_model.model.layers.16.attention.wqkv.weight": "model-00002-of-00004.safetensors",
64
+ "language_model.model.layers.16.attention_norm.weight": "model-00002-of-00004.safetensors",
65
+ "language_model.model.layers.16.feed_forward.w1.weight": "model-00002-of-00004.safetensors",
66
+ "language_model.model.layers.16.feed_forward.w2.weight": "model-00002-of-00004.safetensors",
67
+ "language_model.model.layers.16.feed_forward.w3.weight": "model-00002-of-00004.safetensors",
68
+ "language_model.model.layers.16.ffn_norm.weight": "model-00002-of-00004.safetensors",
69
+ "language_model.model.layers.17.attention.wo.weight": "model-00002-of-00004.safetensors",
70
+ "language_model.model.layers.17.attention.wqkv.weight": "model-00002-of-00004.safetensors",
71
+ "language_model.model.layers.17.attention_norm.weight": "model-00002-of-00004.safetensors",
72
+ "language_model.model.layers.17.feed_forward.w1.weight": "model-00002-of-00004.safetensors",
73
+ "language_model.model.layers.17.feed_forward.w2.weight": "model-00002-of-00004.safetensors",
74
+ "language_model.model.layers.17.feed_forward.w3.weight": "model-00002-of-00004.safetensors",
75
+ "language_model.model.layers.17.ffn_norm.weight": "model-00002-of-00004.safetensors",
76
+ "language_model.model.layers.18.attention.wo.weight": "model-00002-of-00004.safetensors",
77
+ "language_model.model.layers.18.attention.wqkv.weight": "model-00002-of-00004.safetensors",
78
+ "language_model.model.layers.18.attention_norm.weight": "model-00002-of-00004.safetensors",
79
+ "language_model.model.layers.18.feed_forward.w1.weight": "model-00002-of-00004.safetensors",
80
+ "language_model.model.layers.18.feed_forward.w2.weight": "model-00002-of-00004.safetensors",
81
+ "language_model.model.layers.18.feed_forward.w3.weight": "model-00002-of-00004.safetensors",
82
+ "language_model.model.layers.18.ffn_norm.weight": "model-00002-of-00004.safetensors",
83
+ "language_model.model.layers.19.attention.wo.weight": "model-00002-of-00004.safetensors",
84
+ "language_model.model.layers.19.attention.wqkv.weight": "model-00002-of-00004.safetensors",
85
+ "language_model.model.layers.19.attention_norm.weight": "model-00003-of-00004.safetensors",
86
+ "language_model.model.layers.19.feed_forward.w1.weight": "model-00002-of-00004.safetensors",
87
+ "language_model.model.layers.19.feed_forward.w2.weight": "model-00003-of-00004.safetensors",
88
+ "language_model.model.layers.19.feed_forward.w3.weight": "model-00003-of-00004.safetensors",
89
+ "language_model.model.layers.19.ffn_norm.weight": "model-00003-of-00004.safetensors",
90
+ "language_model.model.layers.2.attention.wo.weight": "model-00001-of-00004.safetensors",
91
+ "language_model.model.layers.2.attention.wqkv.weight": "model-00001-of-00004.safetensors",
92
+ "language_model.model.layers.2.attention_norm.weight": "model-00001-of-00004.safetensors",
93
+ "language_model.model.layers.2.feed_forward.w1.weight": "model-00001-of-00004.safetensors",
94
+ "language_model.model.layers.2.feed_forward.w2.weight": "model-00001-of-00004.safetensors",
95
+ "language_model.model.layers.2.feed_forward.w3.weight": "model-00001-of-00004.safetensors",
96
+ "language_model.model.layers.2.ffn_norm.weight": "model-00001-of-00004.safetensors",
97
+ "language_model.model.layers.20.attention.wo.weight": "model-00003-of-00004.safetensors",
98
+ "language_model.model.layers.20.attention.wqkv.weight": "model-00003-of-00004.safetensors",
99
+ "language_model.model.layers.20.attention_norm.weight": "model-00003-of-00004.safetensors",
100
+ "language_model.model.layers.20.feed_forward.w1.weight": "model-00003-of-00004.safetensors",
101
+ "language_model.model.layers.20.feed_forward.w2.weight": "model-00003-of-00004.safetensors",
102
+ "language_model.model.layers.20.feed_forward.w3.weight": "model-00003-of-00004.safetensors",
103
+ "language_model.model.layers.20.ffn_norm.weight": "model-00003-of-00004.safetensors",
104
+ "language_model.model.layers.21.attention.wo.weight": "model-00003-of-00004.safetensors",
105
+ "language_model.model.layers.21.attention.wqkv.weight": "model-00003-of-00004.safetensors",
106
+ "language_model.model.layers.21.attention_norm.weight": "model-00003-of-00004.safetensors",
107
+ "language_model.model.layers.21.feed_forward.w1.weight": "model-00003-of-00004.safetensors",
108
+ "language_model.model.layers.21.feed_forward.w2.weight": "model-00003-of-00004.safetensors",
109
+ "language_model.model.layers.21.feed_forward.w3.weight": "model-00003-of-00004.safetensors",
110
+ "language_model.model.layers.21.ffn_norm.weight": "model-00003-of-00004.safetensors",
111
+ "language_model.model.layers.22.attention.wo.weight": "model-00003-of-00004.safetensors",
112
+ "language_model.model.layers.22.attention.wqkv.weight": "model-00003-of-00004.safetensors",
113
+ "language_model.model.layers.22.attention_norm.weight": "model-00003-of-00004.safetensors",
114
+ "language_model.model.layers.22.feed_forward.w1.weight": "model-00003-of-00004.safetensors",
115
+ "language_model.model.layers.22.feed_forward.w2.weight": "model-00003-of-00004.safetensors",
116
+ "language_model.model.layers.22.feed_forward.w3.weight": "model-00003-of-00004.safetensors",
117
+ "language_model.model.layers.22.ffn_norm.weight": "model-00003-of-00004.safetensors",
118
+ "language_model.model.layers.23.attention.wo.weight": "model-00003-of-00004.safetensors",
119
+ "language_model.model.layers.23.attention.wqkv.weight": "model-00003-of-00004.safetensors",
120
+ "language_model.model.layers.23.attention_norm.weight": "model-00003-of-00004.safetensors",
121
+ "language_model.model.layers.23.feed_forward.w1.weight": "model-00003-of-00004.safetensors",
122
+ "language_model.model.layers.23.feed_forward.w2.weight": "model-00003-of-00004.safetensors",
123
+ "language_model.model.layers.23.feed_forward.w3.weight": "model-00003-of-00004.safetensors",
124
+ "language_model.model.layers.23.ffn_norm.weight": "model-00003-of-00004.safetensors",
125
+ "language_model.model.layers.24.attention.wo.weight": "model-00003-of-00004.safetensors",
126
+ "language_model.model.layers.24.attention.wqkv.weight": "model-00003-of-00004.safetensors",
127
+ "language_model.model.layers.24.attention_norm.weight": "model-00003-of-00004.safetensors",
128
+ "language_model.model.layers.24.feed_forward.w1.weight": "model-00003-of-00004.safetensors",
129
+ "language_model.model.layers.24.feed_forward.w2.weight": "model-00003-of-00004.safetensors",
130
+ "language_model.model.layers.24.feed_forward.w3.weight": "model-00003-of-00004.safetensors",
131
+ "language_model.model.layers.24.ffn_norm.weight": "model-00003-of-00004.safetensors",
132
+ "language_model.model.layers.25.attention.wo.weight": "model-00003-of-00004.safetensors",
133
+ "language_model.model.layers.25.attention.wqkv.weight": "model-00003-of-00004.safetensors",
134
+ "language_model.model.layers.25.attention_norm.weight": "model-00003-of-00004.safetensors",
135
+ "language_model.model.layers.25.feed_forward.w1.weight": "model-00003-of-00004.safetensors",
136
+ "language_model.model.layers.25.feed_forward.w2.weight": "model-00003-of-00004.safetensors",
137
+ "language_model.model.layers.25.feed_forward.w3.weight": "model-00003-of-00004.safetensors",
138
+ "language_model.model.layers.25.ffn_norm.weight": "model-00003-of-00004.safetensors",
139
+ "language_model.model.layers.26.attention.wo.weight": "model-00003-of-00004.safetensors",
140
+ "language_model.model.layers.26.attention.wqkv.weight": "model-00003-of-00004.safetensors",
141
+ "language_model.model.layers.26.attention_norm.weight": "model-00003-of-00004.safetensors",
142
+ "language_model.model.layers.26.feed_forward.w1.weight": "model-00003-of-00004.safetensors",
143
+ "language_model.model.layers.26.feed_forward.w2.weight": "model-00003-of-00004.safetensors",
144
+ "language_model.model.layers.26.feed_forward.w3.weight": "model-00003-of-00004.safetensors",
145
+ "language_model.model.layers.26.ffn_norm.weight": "model-00003-of-00004.safetensors",
146
+ "language_model.model.layers.27.attention.wo.weight": "model-00003-of-00004.safetensors",
147
+ "language_model.model.layers.27.attention.wqkv.weight": "model-00003-of-00004.safetensors",
148
+ "language_model.model.layers.27.attention_norm.weight": "model-00003-of-00004.safetensors",
149
+ "language_model.model.layers.27.feed_forward.w1.weight": "model-00003-of-00004.safetensors",
150
+ "language_model.model.layers.27.feed_forward.w2.weight": "model-00003-of-00004.safetensors",
151
+ "language_model.model.layers.27.feed_forward.w3.weight": "model-00003-of-00004.safetensors",
152
+ "language_model.model.layers.27.ffn_norm.weight": "model-00003-of-00004.safetensors",
153
+ "language_model.model.layers.28.attention.wo.weight": "model-00003-of-00004.safetensors",
154
+ "language_model.model.layers.28.attention.wqkv.weight": "model-00003-of-00004.safetensors",
155
+ "language_model.model.layers.28.attention_norm.weight": "model-00003-of-00004.safetensors",
156
+ "language_model.model.layers.28.feed_forward.w1.weight": "model-00003-of-00004.safetensors",
157
+ "language_model.model.layers.28.feed_forward.w2.weight": "model-00003-of-00004.safetensors",
158
+ "language_model.model.layers.28.feed_forward.w3.weight": "model-00003-of-00004.safetensors",
159
+ "language_model.model.layers.28.ffn_norm.weight": "model-00003-of-00004.safetensors",
160
+ "language_model.model.layers.29.attention.wo.weight": "model-00003-of-00004.safetensors",
161
+ "language_model.model.layers.29.attention.wqkv.weight": "model-00003-of-00004.safetensors",
162
+ "language_model.model.layers.29.attention_norm.weight": "model-00003-of-00004.safetensors",
163
+ "language_model.model.layers.29.feed_forward.w1.weight": "model-00003-of-00004.safetensors",
164
+ "language_model.model.layers.29.feed_forward.w2.weight": "model-00003-of-00004.safetensors",
165
+ "language_model.model.layers.29.feed_forward.w3.weight": "model-00003-of-00004.safetensors",
166
+ "language_model.model.layers.29.ffn_norm.weight": "model-00003-of-00004.safetensors",
167
+ "language_model.model.layers.3.attention.wo.weight": "model-00001-of-00004.safetensors",
168
+ "language_model.model.layers.3.attention.wqkv.weight": "model-00001-of-00004.safetensors",
169
+ "language_model.model.layers.3.attention_norm.weight": "model-00001-of-00004.safetensors",
170
+ "language_model.model.layers.3.feed_forward.w1.weight": "model-00001-of-00004.safetensors",
171
+ "language_model.model.layers.3.feed_forward.w2.weight": "model-00001-of-00004.safetensors",
172
+ "language_model.model.layers.3.feed_forward.w3.weight": "model-00001-of-00004.safetensors",
173
+ "language_model.model.layers.3.ffn_norm.weight": "model-00001-of-00004.safetensors",
174
+ "language_model.model.layers.30.attention.wo.weight": "model-00003-of-00004.safetensors",
175
+ "language_model.model.layers.30.attention.wqkv.weight": "model-00003-of-00004.safetensors",
176
+ "language_model.model.layers.30.attention_norm.weight": "model-00004-of-00004.safetensors",
177
+ "language_model.model.layers.30.feed_forward.w1.weight": "model-00003-of-00004.safetensors",
178
+ "language_model.model.layers.30.feed_forward.w2.weight": "model-00004-of-00004.safetensors",
179
+ "language_model.model.layers.30.feed_forward.w3.weight": "model-00003-of-00004.safetensors",
180
+ "language_model.model.layers.30.ffn_norm.weight": "model-00004-of-00004.safetensors",
181
+ "language_model.model.layers.31.attention.wo.weight": "model-00004-of-00004.safetensors",
182
+ "language_model.model.layers.31.attention.wqkv.weight": "model-00004-of-00004.safetensors",
183
+ "language_model.model.layers.31.attention_norm.weight": "model-00004-of-00004.safetensors",
184
+ "language_model.model.layers.31.feed_forward.w1.weight": "model-00004-of-00004.safetensors",
185
+ "language_model.model.layers.31.feed_forward.w2.weight": "model-00004-of-00004.safetensors",
186
+ "language_model.model.layers.31.feed_forward.w3.weight": "model-00004-of-00004.safetensors",
187
+ "language_model.model.layers.31.ffn_norm.weight": "model-00004-of-00004.safetensors",
188
+ "language_model.model.layers.4.attention.wo.weight": "model-00001-of-00004.safetensors",
189
+ "language_model.model.layers.4.attention.wqkv.weight": "model-00001-of-00004.safetensors",
190
+ "language_model.model.layers.4.attention_norm.weight": "model-00001-of-00004.safetensors",
191
+ "language_model.model.layers.4.feed_forward.w1.weight": "model-00001-of-00004.safetensors",
192
+ "language_model.model.layers.4.feed_forward.w2.weight": "model-00001-of-00004.safetensors",
193
+ "language_model.model.layers.4.feed_forward.w3.weight": "model-00001-of-00004.safetensors",
194
+ "language_model.model.layers.4.ffn_norm.weight": "model-00001-of-00004.safetensors",
195
+ "language_model.model.layers.5.attention.wo.weight": "model-00001-of-00004.safetensors",
196
+ "language_model.model.layers.5.attention.wqkv.weight": "model-00001-of-00004.safetensors",
197
+ "language_model.model.layers.5.attention_norm.weight": "model-00001-of-00004.safetensors",
198
+ "language_model.model.layers.5.feed_forward.w1.weight": "model-00001-of-00004.safetensors",
199
+ "language_model.model.layers.5.feed_forward.w2.weight": "model-00001-of-00004.safetensors",
200
+ "language_model.model.layers.5.feed_forward.w3.weight": "model-00001-of-00004.safetensors",
201
+ "language_model.model.layers.5.ffn_norm.weight": "model-00001-of-00004.safetensors",
202
+ "language_model.model.layers.6.attention.wo.weight": "model-00001-of-00004.safetensors",
203
+ "language_model.model.layers.6.attention.wqkv.weight": "model-00001-of-00004.safetensors",
204
+ "language_model.model.layers.6.attention_norm.weight": "model-00001-of-00004.safetensors",
205
+ "language_model.model.layers.6.feed_forward.w1.weight": "model-00001-of-00004.safetensors",
206
+ "language_model.model.layers.6.feed_forward.w2.weight": "model-00001-of-00004.safetensors",
207
+ "language_model.model.layers.6.feed_forward.w3.weight": "model-00001-of-00004.safetensors",
208
+ "language_model.model.layers.6.ffn_norm.weight": "model-00001-of-00004.safetensors",
209
+ "language_model.model.layers.7.attention.wo.weight": "model-00001-of-00004.safetensors",
210
+ "language_model.model.layers.7.attention.wqkv.weight": "model-00001-of-00004.safetensors",
211
+ "language_model.model.layers.7.attention_norm.weight": "model-00001-of-00004.safetensors",
212
+ "language_model.model.layers.7.feed_forward.w1.weight": "model-00001-of-00004.safetensors",
213
+ "language_model.model.layers.7.feed_forward.w2.weight": "model-00001-of-00004.safetensors",
214
+ "language_model.model.layers.7.feed_forward.w3.weight": "model-00001-of-00004.safetensors",
215
+ "language_model.model.layers.7.ffn_norm.weight": "model-00001-of-00004.safetensors",
216
+ "language_model.model.layers.8.attention.wo.weight": "model-00001-of-00004.safetensors",
217
+ "language_model.model.layers.8.attention.wqkv.weight": "model-00001-of-00004.safetensors",
218
+ "language_model.model.layers.8.attention_norm.weight": "model-00002-of-00004.safetensors",
219
+ "language_model.model.layers.8.feed_forward.w1.weight": "model-00002-of-00004.safetensors",
220
+ "language_model.model.layers.8.feed_forward.w2.weight": "model-00002-of-00004.safetensors",
221
+ "language_model.model.layers.8.feed_forward.w3.weight": "model-00002-of-00004.safetensors",
222
+ "language_model.model.layers.8.ffn_norm.weight": "model-00002-of-00004.safetensors",
223
+ "language_model.model.layers.9.attention.wo.weight": "model-00002-of-00004.safetensors",
224
+ "language_model.model.layers.9.attention.wqkv.weight": "model-00002-of-00004.safetensors",
225
+ "language_model.model.layers.9.attention_norm.weight": "model-00002-of-00004.safetensors",
226
+ "language_model.model.layers.9.feed_forward.w1.weight": "model-00002-of-00004.safetensors",
227
+ "language_model.model.layers.9.feed_forward.w2.weight": "model-00002-of-00004.safetensors",
228
+ "language_model.model.layers.9.feed_forward.w3.weight": "model-00002-of-00004.safetensors",
229
+ "language_model.model.layers.9.ffn_norm.weight": "model-00002-of-00004.safetensors",
230
+ "language_model.model.norm.weight": "model-00004-of-00004.safetensors",
231
+ "language_model.model.tok_embeddings.weight": "model-00001-of-00004.safetensors",
232
+ "language_model.output.weight": "model-00004-of-00004.safetensors",
233
+ "mlp1.0.bias": "model-00004-of-00004.safetensors",
234
+ "mlp1.0.weight": "model-00004-of-00004.safetensors",
235
+ "mlp1.1.bias": "model-00004-of-00004.safetensors",
236
+ "mlp1.1.weight": "model-00004-of-00004.safetensors",
237
+ "mlp1.3.bias": "model-00004-of-00004.safetensors",
238
+ "mlp1.3.weight": "model-00004-of-00004.safetensors",
239
+ "vision_model.embeddings.class_embedding": "model-00001-of-00004.safetensors",
240
+ "vision_model.embeddings.patch_embedding.bias": "model-00001-of-00004.safetensors",
241
+ "vision_model.embeddings.patch_embedding.weight": "model-00001-of-00004.safetensors",
242
+ "vision_model.embeddings.position_embedding": "model-00001-of-00004.safetensors",
243
+ "vision_model.encoder.layers.0.attn.proj.bias": "model-00001-of-00004.safetensors",
244
+ "vision_model.encoder.layers.0.attn.proj.weight": "model-00001-of-00004.safetensors",
245
+ "vision_model.encoder.layers.0.attn.qkv.bias": "model-00001-of-00004.safetensors",
246
+ "vision_model.encoder.layers.0.attn.qkv.weight": "model-00001-of-00004.safetensors",
247
+ "vision_model.encoder.layers.0.ls1": "model-00001-of-00004.safetensors",
248
+ "vision_model.encoder.layers.0.ls2": "model-00001-of-00004.safetensors",
249
+ "vision_model.encoder.layers.0.mlp.fc1.bias": "model-00001-of-00004.safetensors",
250
+ "vision_model.encoder.layers.0.mlp.fc1.weight": "model-00001-of-00004.safetensors",
251
+ "vision_model.encoder.layers.0.mlp.fc2.bias": "model-00001-of-00004.safetensors",
252
+ "vision_model.encoder.layers.0.mlp.fc2.weight": "model-00001-of-00004.safetensors",
253
+ "vision_model.encoder.layers.0.norm1.bias": "model-00001-of-00004.safetensors",
254
+ "vision_model.encoder.layers.0.norm1.weight": "model-00001-of-00004.safetensors",
255
+ "vision_model.encoder.layers.0.norm2.bias": "model-00001-of-00004.safetensors",
256
+ "vision_model.encoder.layers.0.norm2.weight": "model-00001-of-00004.safetensors",
257
+ "vision_model.encoder.layers.1.attn.proj.bias": "model-00001-of-00004.safetensors",
258
+ "vision_model.encoder.layers.1.attn.proj.weight": "model-00001-of-00004.safetensors",
259
+ "vision_model.encoder.layers.1.attn.qkv.bias": "model-00001-of-00004.safetensors",
260
+ "vision_model.encoder.layers.1.attn.qkv.weight": "model-00001-of-00004.safetensors",
261
+ "vision_model.encoder.layers.1.ls1": "model-00001-of-00004.safetensors",
262
+ "vision_model.encoder.layers.1.ls2": "model-00001-of-00004.safetensors",
263
+ "vision_model.encoder.layers.1.mlp.fc1.bias": "model-00001-of-00004.safetensors",
264
+ "vision_model.encoder.layers.1.mlp.fc1.weight": "model-00001-of-00004.safetensors",
265
+ "vision_model.encoder.layers.1.mlp.fc2.bias": "model-00001-of-00004.safetensors",
266
+ "vision_model.encoder.layers.1.mlp.fc2.weight": "model-00001-of-00004.safetensors",
267
+ "vision_model.encoder.layers.1.norm1.bias": "model-00001-of-00004.safetensors",
268
+ "vision_model.encoder.layers.1.norm1.weight": "model-00001-of-00004.safetensors",
269
+ "vision_model.encoder.layers.1.norm2.bias": "model-00001-of-00004.safetensors",
270
+ "vision_model.encoder.layers.1.norm2.weight": "model-00001-of-00004.safetensors",
271
+ "vision_model.encoder.layers.10.attn.proj.bias": "model-00001-of-00004.safetensors",
272
+ "vision_model.encoder.layers.10.attn.proj.weight": "model-00001-of-00004.safetensors",
273
+ "vision_model.encoder.layers.10.attn.qkv.bias": "model-00001-of-00004.safetensors",
274
+ "vision_model.encoder.layers.10.attn.qkv.weight": "model-00001-of-00004.safetensors",
275
+ "vision_model.encoder.layers.10.ls1": "model-00001-of-00004.safetensors",
276
+ "vision_model.encoder.layers.10.ls2": "model-00001-of-00004.safetensors",
277
+ "vision_model.encoder.layers.10.mlp.fc1.bias": "model-00001-of-00004.safetensors",
278
+ "vision_model.encoder.layers.10.mlp.fc1.weight": "model-00001-of-00004.safetensors",
279
+ "vision_model.encoder.layers.10.mlp.fc2.bias": "model-00001-of-00004.safetensors",
280
+ "vision_model.encoder.layers.10.mlp.fc2.weight": "model-00001-of-00004.safetensors",
281
+ "vision_model.encoder.layers.10.norm1.bias": "model-00001-of-00004.safetensors",
282
+ "vision_model.encoder.layers.10.norm1.weight": "model-00001-of-00004.safetensors",
283
+ "vision_model.encoder.layers.10.norm2.bias": "model-00001-of-00004.safetensors",
284
+ "vision_model.encoder.layers.10.norm2.weight": "model-00001-of-00004.safetensors",
285
+ "vision_model.encoder.layers.11.attn.proj.bias": "model-00001-of-00004.safetensors",
286
+ "vision_model.encoder.layers.11.attn.proj.weight": "model-00001-of-00004.safetensors",
287
+ "vision_model.encoder.layers.11.attn.qkv.bias": "model-00001-of-00004.safetensors",
288
+ "vision_model.encoder.layers.11.attn.qkv.weight": "model-00001-of-00004.safetensors",
289
+ "vision_model.encoder.layers.11.ls1": "model-00001-of-00004.safetensors",
290
+ "vision_model.encoder.layers.11.ls2": "model-00001-of-00004.safetensors",
291
+ "vision_model.encoder.layers.11.mlp.fc1.bias": "model-00001-of-00004.safetensors",
292
+ "vision_model.encoder.layers.11.mlp.fc1.weight": "model-00001-of-00004.safetensors",
293
+ "vision_model.encoder.layers.11.mlp.fc2.bias": "model-00001-of-00004.safetensors",
294
+ "vision_model.encoder.layers.11.mlp.fc2.weight": "model-00001-of-00004.safetensors",
295
+ "vision_model.encoder.layers.11.norm1.bias": "model-00001-of-00004.safetensors",
296
+ "vision_model.encoder.layers.11.norm1.weight": "model-00001-of-00004.safetensors",
297
+ "vision_model.encoder.layers.11.norm2.bias": "model-00001-of-00004.safetensors",
298
+ "vision_model.encoder.layers.11.norm2.weight": "model-00001-of-00004.safetensors",
299
+ "vision_model.encoder.layers.12.attn.proj.bias": "model-00001-of-00004.safetensors",
300
+ "vision_model.encoder.layers.12.attn.proj.weight": "model-00001-of-00004.safetensors",
301
+ "vision_model.encoder.layers.12.attn.qkv.bias": "model-00001-of-00004.safetensors",
302
+ "vision_model.encoder.layers.12.attn.qkv.weight": "model-00001-of-00004.safetensors",
303
+ "vision_model.encoder.layers.12.ls1": "model-00001-of-00004.safetensors",
304
+ "vision_model.encoder.layers.12.ls2": "model-00001-of-00004.safetensors",
305
+ "vision_model.encoder.layers.12.mlp.fc1.bias": "model-00001-of-00004.safetensors",
306
+ "vision_model.encoder.layers.12.mlp.fc1.weight": "model-00001-of-00004.safetensors",
307
+ "vision_model.encoder.layers.12.mlp.fc2.bias": "model-00001-of-00004.safetensors",
308
+ "vision_model.encoder.layers.12.mlp.fc2.weight": "model-00001-of-00004.safetensors",
309
+ "vision_model.encoder.layers.12.norm1.bias": "model-00001-of-00004.safetensors",
310
+ "vision_model.encoder.layers.12.norm1.weight": "model-00001-of-00004.safetensors",
311
+ "vision_model.encoder.layers.12.norm2.bias": "model-00001-of-00004.safetensors",
312
+ "vision_model.encoder.layers.12.norm2.weight": "model-00001-of-00004.safetensors",
313
+ "vision_model.encoder.layers.13.attn.proj.bias": "model-00001-of-00004.safetensors",
314
+ "vision_model.encoder.layers.13.attn.proj.weight": "model-00001-of-00004.safetensors",
315
+ "vision_model.encoder.layers.13.attn.qkv.bias": "model-00001-of-00004.safetensors",
316
+ "vision_model.encoder.layers.13.attn.qkv.weight": "model-00001-of-00004.safetensors",
317
+ "vision_model.encoder.layers.13.ls1": "model-00001-of-00004.safetensors",
318
+ "vision_model.encoder.layers.13.ls2": "model-00001-of-00004.safetensors",
319
+ "vision_model.encoder.layers.13.mlp.fc1.bias": "model-00001-of-00004.safetensors",
320
+ "vision_model.encoder.layers.13.mlp.fc1.weight": "model-00001-of-00004.safetensors",
321
+ "vision_model.encoder.layers.13.mlp.fc2.bias": "model-00001-of-00004.safetensors",
322
+ "vision_model.encoder.layers.13.mlp.fc2.weight": "model-00001-of-00004.safetensors",
323
+ "vision_model.encoder.layers.13.norm1.bias": "model-00001-of-00004.safetensors",
324
+ "vision_model.encoder.layers.13.norm1.weight": "model-00001-of-00004.safetensors",
325
+ "vision_model.encoder.layers.13.norm2.bias": "model-00001-of-00004.safetensors",
326
+ "vision_model.encoder.layers.13.norm2.weight": "model-00001-of-00004.safetensors",
327
+ "vision_model.encoder.layers.14.attn.proj.bias": "model-00001-of-00004.safetensors",
328
+ "vision_model.encoder.layers.14.attn.proj.weight": "model-00001-of-00004.safetensors",
329
+ "vision_model.encoder.layers.14.attn.qkv.bias": "model-00001-of-00004.safetensors",
330
+ "vision_model.encoder.layers.14.attn.qkv.weight": "model-00001-of-00004.safetensors",
331
+ "vision_model.encoder.layers.14.ls1": "model-00001-of-00004.safetensors",
332
+ "vision_model.encoder.layers.14.ls2": "model-00001-of-00004.safetensors",
333
+ "vision_model.encoder.layers.14.mlp.fc1.bias": "model-00001-of-00004.safetensors",
334
+ "vision_model.encoder.layers.14.mlp.fc1.weight": "model-00001-of-00004.safetensors",
335
+ "vision_model.encoder.layers.14.mlp.fc2.bias": "model-00001-of-00004.safetensors",
336
+ "vision_model.encoder.layers.14.mlp.fc2.weight": "model-00001-of-00004.safetensors",
337
+ "vision_model.encoder.layers.14.norm1.bias": "model-00001-of-00004.safetensors",
338
+ "vision_model.encoder.layers.14.norm1.weight": "model-00001-of-00004.safetensors",
339
+ "vision_model.encoder.layers.14.norm2.bias": "model-00001-of-00004.safetensors",
340
+ "vision_model.encoder.layers.14.norm2.weight": "model-00001-of-00004.safetensors",
341
+ "vision_model.encoder.layers.15.attn.proj.bias": "model-00001-of-00004.safetensors",
342
+ "vision_model.encoder.layers.15.attn.proj.weight": "model-00001-of-00004.safetensors",
343
+ "vision_model.encoder.layers.15.attn.qkv.bias": "model-00001-of-00004.safetensors",
344
+ "vision_model.encoder.layers.15.attn.qkv.weight": "model-00001-of-00004.safetensors",
345
+ "vision_model.encoder.layers.15.ls1": "model-00001-of-00004.safetensors",
346
+ "vision_model.encoder.layers.15.ls2": "model-00001-of-00004.safetensors",
347
+ "vision_model.encoder.layers.15.mlp.fc1.bias": "model-00001-of-00004.safetensors",
348
+ "vision_model.encoder.layers.15.mlp.fc1.weight": "model-00001-of-00004.safetensors",
349
+ "vision_model.encoder.layers.15.mlp.fc2.bias": "model-00001-of-00004.safetensors",
350
+ "vision_model.encoder.layers.15.mlp.fc2.weight": "model-00001-of-00004.safetensors",
351
+ "vision_model.encoder.layers.15.norm1.bias": "model-00001-of-00004.safetensors",
352
+ "vision_model.encoder.layers.15.norm1.weight": "model-00001-of-00004.safetensors",
353
+ "vision_model.encoder.layers.15.norm2.bias": "model-00001-of-00004.safetensors",
354
+ "vision_model.encoder.layers.15.norm2.weight": "model-00001-of-00004.safetensors",
355
+ "vision_model.encoder.layers.16.attn.proj.bias": "model-00001-of-00004.safetensors",
356
+ "vision_model.encoder.layers.16.attn.proj.weight": "model-00001-of-00004.safetensors",
357
+ "vision_model.encoder.layers.16.attn.qkv.bias": "model-00001-of-00004.safetensors",
358
+ "vision_model.encoder.layers.16.attn.qkv.weight": "model-00001-of-00004.safetensors",
359
+ "vision_model.encoder.layers.16.ls1": "model-00001-of-00004.safetensors",
360
+ "vision_model.encoder.layers.16.ls2": "model-00001-of-00004.safetensors",
361
+ "vision_model.encoder.layers.16.mlp.fc1.bias": "model-00001-of-00004.safetensors",
362
+ "vision_model.encoder.layers.16.mlp.fc1.weight": "model-00001-of-00004.safetensors",
363
+ "vision_model.encoder.layers.16.mlp.fc2.bias": "model-00001-of-00004.safetensors",
364
+ "vision_model.encoder.layers.16.mlp.fc2.weight": "model-00001-of-00004.safetensors",
365
+ "vision_model.encoder.layers.16.norm1.bias": "model-00001-of-00004.safetensors",
366
+ "vision_model.encoder.layers.16.norm1.weight": "model-00001-of-00004.safetensors",
367
+ "vision_model.encoder.layers.16.norm2.bias": "model-00001-of-00004.safetensors",
368
+ "vision_model.encoder.layers.16.norm2.weight": "model-00001-of-00004.safetensors",
369
+ "vision_model.encoder.layers.17.attn.proj.bias": "model-00001-of-00004.safetensors",
370
+ "vision_model.encoder.layers.17.attn.proj.weight": "model-00001-of-00004.safetensors",
371
+ "vision_model.encoder.layers.17.attn.qkv.bias": "model-00001-of-00004.safetensors",
372
+ "vision_model.encoder.layers.17.attn.qkv.weight": "model-00001-of-00004.safetensors",
373
+ "vision_model.encoder.layers.17.ls1": "model-00001-of-00004.safetensors",
374
+ "vision_model.encoder.layers.17.ls2": "model-00001-of-00004.safetensors",
375
+ "vision_model.encoder.layers.17.mlp.fc1.bias": "model-00001-of-00004.safetensors",
376
+ "vision_model.encoder.layers.17.mlp.fc1.weight": "model-00001-of-00004.safetensors",
377
+ "vision_model.encoder.layers.17.mlp.fc2.bias": "model-00001-of-00004.safetensors",
378
+ "vision_model.encoder.layers.17.mlp.fc2.weight": "model-00001-of-00004.safetensors",
379
+ "vision_model.encoder.layers.17.norm1.bias": "model-00001-of-00004.safetensors",
380
+ "vision_model.encoder.layers.17.norm1.weight": "model-00001-of-00004.safetensors",
381
+ "vision_model.encoder.layers.17.norm2.bias": "model-00001-of-00004.safetensors",
382
+ "vision_model.encoder.layers.17.norm2.weight": "model-00001-of-00004.safetensors",
383
+ "vision_model.encoder.layers.18.attn.proj.bias": "model-00001-of-00004.safetensors",
384
+ "vision_model.encoder.layers.18.attn.proj.weight": "model-00001-of-00004.safetensors",
385
+ "vision_model.encoder.layers.18.attn.qkv.bias": "model-00001-of-00004.safetensors",
386
+ "vision_model.encoder.layers.18.attn.qkv.weight": "model-00001-of-00004.safetensors",
387
+ "vision_model.encoder.layers.18.ls1": "model-00001-of-00004.safetensors",
388
+ "vision_model.encoder.layers.18.ls2": "model-00001-of-00004.safetensors",
389
+ "vision_model.encoder.layers.18.mlp.fc1.bias": "model-00001-of-00004.safetensors",
390
+ "vision_model.encoder.layers.18.mlp.fc1.weight": "model-00001-of-00004.safetensors",
391
+ "vision_model.encoder.layers.18.mlp.fc2.bias": "model-00001-of-00004.safetensors",
392
+ "vision_model.encoder.layers.18.mlp.fc2.weight": "model-00001-of-00004.safetensors",
393
+ "vision_model.encoder.layers.18.norm1.bias": "model-00001-of-00004.safetensors",
394
+ "vision_model.encoder.layers.18.norm1.weight": "model-00001-of-00004.safetensors",
395
+ "vision_model.encoder.layers.18.norm2.bias": "model-00001-of-00004.safetensors",
396
+ "vision_model.encoder.layers.18.norm2.weight": "model-00001-of-00004.safetensors",
397
+ "vision_model.encoder.layers.19.attn.proj.bias": "model-00001-of-00004.safetensors",
398
+ "vision_model.encoder.layers.19.attn.proj.weight": "model-00001-of-00004.safetensors",
399
+ "vision_model.encoder.layers.19.attn.qkv.bias": "model-00001-of-00004.safetensors",
400
+ "vision_model.encoder.layers.19.attn.qkv.weight": "model-00001-of-00004.safetensors",
401
+ "vision_model.encoder.layers.19.ls1": "model-00001-of-00004.safetensors",
402
+ "vision_model.encoder.layers.19.ls2": "model-00001-of-00004.safetensors",
403
+ "vision_model.encoder.layers.19.mlp.fc1.bias": "model-00001-of-00004.safetensors",
404
+ "vision_model.encoder.layers.19.mlp.fc1.weight": "model-00001-of-00004.safetensors",
405
+ "vision_model.encoder.layers.19.mlp.fc2.bias": "model-00001-of-00004.safetensors",
406
+ "vision_model.encoder.layers.19.mlp.fc2.weight": "model-00001-of-00004.safetensors",
407
+ "vision_model.encoder.layers.19.norm1.bias": "model-00001-of-00004.safetensors",
408
+ "vision_model.encoder.layers.19.norm1.weight": "model-00001-of-00004.safetensors",
409
+ "vision_model.encoder.layers.19.norm2.bias": "model-00001-of-00004.safetensors",
410
+ "vision_model.encoder.layers.19.norm2.weight": "model-00001-of-00004.safetensors",
411
+ "vision_model.encoder.layers.2.attn.proj.bias": "model-00001-of-00004.safetensors",
412
+ "vision_model.encoder.layers.2.attn.proj.weight": "model-00001-of-00004.safetensors",
413
+ "vision_model.encoder.layers.2.attn.qkv.bias": "model-00001-of-00004.safetensors",
414
+ "vision_model.encoder.layers.2.attn.qkv.weight": "model-00001-of-00004.safetensors",
415
+ "vision_model.encoder.layers.2.ls1": "model-00001-of-00004.safetensors",
416
+ "vision_model.encoder.layers.2.ls2": "model-00001-of-00004.safetensors",
417
+ "vision_model.encoder.layers.2.mlp.fc1.bias": "model-00001-of-00004.safetensors",
418
+ "vision_model.encoder.layers.2.mlp.fc1.weight": "model-00001-of-00004.safetensors",
419
+ "vision_model.encoder.layers.2.mlp.fc2.bias": "model-00001-of-00004.safetensors",
420
+ "vision_model.encoder.layers.2.mlp.fc2.weight": "model-00001-of-00004.safetensors",
421
+ "vision_model.encoder.layers.2.norm1.bias": "model-00001-of-00004.safetensors",
422
+ "vision_model.encoder.layers.2.norm1.weight": "model-00001-of-00004.safetensors",
423
+ "vision_model.encoder.layers.2.norm2.bias": "model-00001-of-00004.safetensors",
424
+ "vision_model.encoder.layers.2.norm2.weight": "model-00001-of-00004.safetensors",
425
+ "vision_model.encoder.layers.20.attn.proj.bias": "model-00001-of-00004.safetensors",
426
+ "vision_model.encoder.layers.20.attn.proj.weight": "model-00001-of-00004.safetensors",
427
+ "vision_model.encoder.layers.20.attn.qkv.bias": "model-00001-of-00004.safetensors",
428
+ "vision_model.encoder.layers.20.attn.qkv.weight": "model-00001-of-00004.safetensors",
429
+ "vision_model.encoder.layers.20.ls1": "model-00001-of-00004.safetensors",
430
+ "vision_model.encoder.layers.20.ls2": "model-00001-of-00004.safetensors",
431
+ "vision_model.encoder.layers.20.mlp.fc1.bias": "model-00001-of-00004.safetensors",
432
+ "vision_model.encoder.layers.20.mlp.fc1.weight": "model-00001-of-00004.safetensors",
433
+ "vision_model.encoder.layers.20.mlp.fc2.bias": "model-00001-of-00004.safetensors",
434
+ "vision_model.encoder.layers.20.mlp.fc2.weight": "model-00001-of-00004.safetensors",
435
+ "vision_model.encoder.layers.20.norm1.bias": "model-00001-of-00004.safetensors",
436
+ "vision_model.encoder.layers.20.norm1.weight": "model-00001-of-00004.safetensors",
437
+ "vision_model.encoder.layers.20.norm2.bias": "model-00001-of-00004.safetensors",
438
+ "vision_model.encoder.layers.20.norm2.weight": "model-00001-of-00004.safetensors",
439
+ "vision_model.encoder.layers.21.attn.proj.bias": "model-00001-of-00004.safetensors",
440
+ "vision_model.encoder.layers.21.attn.proj.weight": "model-00001-of-00004.safetensors",
441
+ "vision_model.encoder.layers.21.attn.qkv.bias": "model-00001-of-00004.safetensors",
442
+ "vision_model.encoder.layers.21.attn.qkv.weight": "model-00001-of-00004.safetensors",
443
+ "vision_model.encoder.layers.21.ls1": "model-00001-of-00004.safetensors",
444
+ "vision_model.encoder.layers.21.ls2": "model-00001-of-00004.safetensors",
445
+ "vision_model.encoder.layers.21.mlp.fc1.bias": "model-00001-of-00004.safetensors",
446
+ "vision_model.encoder.layers.21.mlp.fc1.weight": "model-00001-of-00004.safetensors",
447
+ "vision_model.encoder.layers.21.mlp.fc2.bias": "model-00001-of-00004.safetensors",
448
+ "vision_model.encoder.layers.21.mlp.fc2.weight": "model-00001-of-00004.safetensors",
449
+ "vision_model.encoder.layers.21.norm1.bias": "model-00001-of-00004.safetensors",
450
+ "vision_model.encoder.layers.21.norm1.weight": "model-00001-of-00004.safetensors",
451
+ "vision_model.encoder.layers.21.norm2.bias": "model-00001-of-00004.safetensors",
452
+ "vision_model.encoder.layers.21.norm2.weight": "model-00001-of-00004.safetensors",
453
+ "vision_model.encoder.layers.22.attn.proj.bias": "model-00001-of-00004.safetensors",
454
+ "vision_model.encoder.layers.22.attn.proj.weight": "model-00001-of-00004.safetensors",
455
+ "vision_model.encoder.layers.22.attn.qkv.bias": "model-00001-of-00004.safetensors",
456
+ "vision_model.encoder.layers.22.attn.qkv.weight": "model-00001-of-00004.safetensors",
457
+ "vision_model.encoder.layers.22.ls1": "model-00001-of-00004.safetensors",
458
+ "vision_model.encoder.layers.22.ls2": "model-00001-of-00004.safetensors",
459
+ "vision_model.encoder.layers.22.mlp.fc1.bias": "model-00001-of-00004.safetensors",
460
+ "vision_model.encoder.layers.22.mlp.fc1.weight": "model-00001-of-00004.safetensors",
461
+ "vision_model.encoder.layers.22.mlp.fc2.bias": "model-00001-of-00004.safetensors",
462
+ "vision_model.encoder.layers.22.mlp.fc2.weight": "model-00001-of-00004.safetensors",
463
+ "vision_model.encoder.layers.22.norm1.bias": "model-00001-of-00004.safetensors",
464
+ "vision_model.encoder.layers.22.norm1.weight": "model-00001-of-00004.safetensors",
465
+ "vision_model.encoder.layers.22.norm2.bias": "model-00001-of-00004.safetensors",
466
+ "vision_model.encoder.layers.22.norm2.weight": "model-00001-of-00004.safetensors",
467
+ "vision_model.encoder.layers.23.attn.proj.bias": "model-00001-of-00004.safetensors",
468
+ "vision_model.encoder.layers.23.attn.proj.weight": "model-00001-of-00004.safetensors",
469
+ "vision_model.encoder.layers.23.attn.qkv.bias": "model-00001-of-00004.safetensors",
470
+ "vision_model.encoder.layers.23.attn.qkv.weight": "model-00001-of-00004.safetensors",
471
+ "vision_model.encoder.layers.23.ls1": "model-00001-of-00004.safetensors",
472
+ "vision_model.encoder.layers.23.ls2": "model-00001-of-00004.safetensors",
473
+ "vision_model.encoder.layers.23.mlp.fc1.bias": "model-00001-of-00004.safetensors",
474
+ "vision_model.encoder.layers.23.mlp.fc1.weight": "model-00001-of-00004.safetensors",
475
+ "vision_model.encoder.layers.23.mlp.fc2.bias": "model-00001-of-00004.safetensors",
476
+ "vision_model.encoder.layers.23.mlp.fc2.weight": "model-00001-of-00004.safetensors",
477
+ "vision_model.encoder.layers.23.norm1.bias": "model-00001-of-00004.safetensors",
478
+ "vision_model.encoder.layers.23.norm1.weight": "model-00001-of-00004.safetensors",
479
+ "vision_model.encoder.layers.23.norm2.bias": "model-00001-of-00004.safetensors",
480
+ "vision_model.encoder.layers.23.norm2.weight": "model-00001-of-00004.safetensors",
481
+ "vision_model.encoder.layers.3.attn.proj.bias": "model-00001-of-00004.safetensors",
482
+ "vision_model.encoder.layers.3.attn.proj.weight": "model-00001-of-00004.safetensors",
483
+ "vision_model.encoder.layers.3.attn.qkv.bias": "model-00001-of-00004.safetensors",
484
+ "vision_model.encoder.layers.3.attn.qkv.weight": "model-00001-of-00004.safetensors",
485
+ "vision_model.encoder.layers.3.ls1": "model-00001-of-00004.safetensors",
486
+ "vision_model.encoder.layers.3.ls2": "model-00001-of-00004.safetensors",
487
+ "vision_model.encoder.layers.3.mlp.fc1.bias": "model-00001-of-00004.safetensors",
488
+ "vision_model.encoder.layers.3.mlp.fc1.weight": "model-00001-of-00004.safetensors",
489
+ "vision_model.encoder.layers.3.mlp.fc2.bias": "model-00001-of-00004.safetensors",
490
+ "vision_model.encoder.layers.3.mlp.fc2.weight": "model-00001-of-00004.safetensors",
491
+ "vision_model.encoder.layers.3.norm1.bias": "model-00001-of-00004.safetensors",
492
+ "vision_model.encoder.layers.3.norm1.weight": "model-00001-of-00004.safetensors",
493
+ "vision_model.encoder.layers.3.norm2.bias": "model-00001-of-00004.safetensors",
494
+ "vision_model.encoder.layers.3.norm2.weight": "model-00001-of-00004.safetensors",
495
+ "vision_model.encoder.layers.4.attn.proj.bias": "model-00001-of-00004.safetensors",
496
+ "vision_model.encoder.layers.4.attn.proj.weight": "model-00001-of-00004.safetensors",
497
+ "vision_model.encoder.layers.4.attn.qkv.bias": "model-00001-of-00004.safetensors",
498
+ "vision_model.encoder.layers.4.attn.qkv.weight": "model-00001-of-00004.safetensors",
499
+ "vision_model.encoder.layers.4.ls1": "model-00001-of-00004.safetensors",
500
+ "vision_model.encoder.layers.4.ls2": "model-00001-of-00004.safetensors",
501
+ "vision_model.encoder.layers.4.mlp.fc1.bias": "model-00001-of-00004.safetensors",
502
+ "vision_model.encoder.layers.4.mlp.fc1.weight": "model-00001-of-00004.safetensors",
503
+ "vision_model.encoder.layers.4.mlp.fc2.bias": "model-00001-of-00004.safetensors",
504
+ "vision_model.encoder.layers.4.mlp.fc2.weight": "model-00001-of-00004.safetensors",
505
+ "vision_model.encoder.layers.4.norm1.bias": "model-00001-of-00004.safetensors",
506
+ "vision_model.encoder.layers.4.norm1.weight": "model-00001-of-00004.safetensors",
507
+ "vision_model.encoder.layers.4.norm2.bias": "model-00001-of-00004.safetensors",
508
+ "vision_model.encoder.layers.4.norm2.weight": "model-00001-of-00004.safetensors",
509
+ "vision_model.encoder.layers.5.attn.proj.bias": "model-00001-of-00004.safetensors",
510
+ "vision_model.encoder.layers.5.attn.proj.weight": "model-00001-of-00004.safetensors",
511
+ "vision_model.encoder.layers.5.attn.qkv.bias": "model-00001-of-00004.safetensors",
512
+ "vision_model.encoder.layers.5.attn.qkv.weight": "model-00001-of-00004.safetensors",
513
+ "vision_model.encoder.layers.5.ls1": "model-00001-of-00004.safetensors",
514
+ "vision_model.encoder.layers.5.ls2": "model-00001-of-00004.safetensors",
515
+ "vision_model.encoder.layers.5.mlp.fc1.bias": "model-00001-of-00004.safetensors",
516
+ "vision_model.encoder.layers.5.mlp.fc1.weight": "model-00001-of-00004.safetensors",
517
+ "vision_model.encoder.layers.5.mlp.fc2.bias": "model-00001-of-00004.safetensors",
518
+ "vision_model.encoder.layers.5.mlp.fc2.weight": "model-00001-of-00004.safetensors",
519
+ "vision_model.encoder.layers.5.norm1.bias": "model-00001-of-00004.safetensors",
520
+ "vision_model.encoder.layers.5.norm1.weight": "model-00001-of-00004.safetensors",
521
+ "vision_model.encoder.layers.5.norm2.bias": "model-00001-of-00004.safetensors",
522
+ "vision_model.encoder.layers.5.norm2.weight": "model-00001-of-00004.safetensors",
523
+ "vision_model.encoder.layers.6.attn.proj.bias": "model-00001-of-00004.safetensors",
524
+ "vision_model.encoder.layers.6.attn.proj.weight": "model-00001-of-00004.safetensors",
525
+ "vision_model.encoder.layers.6.attn.qkv.bias": "model-00001-of-00004.safetensors",
526
+ "vision_model.encoder.layers.6.attn.qkv.weight": "model-00001-of-00004.safetensors",
527
+ "vision_model.encoder.layers.6.ls1": "model-00001-of-00004.safetensors",
528
+ "vision_model.encoder.layers.6.ls2": "model-00001-of-00004.safetensors",
529
+ "vision_model.encoder.layers.6.mlp.fc1.bias": "model-00001-of-00004.safetensors",
530
+ "vision_model.encoder.layers.6.mlp.fc1.weight": "model-00001-of-00004.safetensors",
531
+ "vision_model.encoder.layers.6.mlp.fc2.bias": "model-00001-of-00004.safetensors",
532
+ "vision_model.encoder.layers.6.mlp.fc2.weight": "model-00001-of-00004.safetensors",
533
+ "vision_model.encoder.layers.6.norm1.bias": "model-00001-of-00004.safetensors",
534
+ "vision_model.encoder.layers.6.norm1.weight": "model-00001-of-00004.safetensors",
535
+ "vision_model.encoder.layers.6.norm2.bias": "model-00001-of-00004.safetensors",
536
+ "vision_model.encoder.layers.6.norm2.weight": "model-00001-of-00004.safetensors",
537
+ "vision_model.encoder.layers.7.attn.proj.bias": "model-00001-of-00004.safetensors",
538
+ "vision_model.encoder.layers.7.attn.proj.weight": "model-00001-of-00004.safetensors",
539
+ "vision_model.encoder.layers.7.attn.qkv.bias": "model-00001-of-00004.safetensors",
540
+ "vision_model.encoder.layers.7.attn.qkv.weight": "model-00001-of-00004.safetensors",
541
+ "vision_model.encoder.layers.7.ls1": "model-00001-of-00004.safetensors",
542
+ "vision_model.encoder.layers.7.ls2": "model-00001-of-00004.safetensors",
543
+ "vision_model.encoder.layers.7.mlp.fc1.bias": "model-00001-of-00004.safetensors",
544
+ "vision_model.encoder.layers.7.mlp.fc1.weight": "model-00001-of-00004.safetensors",
545
+ "vision_model.encoder.layers.7.mlp.fc2.bias": "model-00001-of-00004.safetensors",
546
+ "vision_model.encoder.layers.7.mlp.fc2.weight": "model-00001-of-00004.safetensors",
547
+ "vision_model.encoder.layers.7.norm1.bias": "model-00001-of-00004.safetensors",
548
+ "vision_model.encoder.layers.7.norm1.weight": "model-00001-of-00004.safetensors",
549
+ "vision_model.encoder.layers.7.norm2.bias": "model-00001-of-00004.safetensors",
550
+ "vision_model.encoder.layers.7.norm2.weight": "model-00001-of-00004.safetensors",
551
+ "vision_model.encoder.layers.8.attn.proj.bias": "model-00001-of-00004.safetensors",
552
+ "vision_model.encoder.layers.8.attn.proj.weight": "model-00001-of-00004.safetensors",
553
+ "vision_model.encoder.layers.8.attn.qkv.bias": "model-00001-of-00004.safetensors",
554
+ "vision_model.encoder.layers.8.attn.qkv.weight": "model-00001-of-00004.safetensors",
555
+ "vision_model.encoder.layers.8.ls1": "model-00001-of-00004.safetensors",
556
+ "vision_model.encoder.layers.8.ls2": "model-00001-of-00004.safetensors",
557
+ "vision_model.encoder.layers.8.mlp.fc1.bias": "model-00001-of-00004.safetensors",
558
+ "vision_model.encoder.layers.8.mlp.fc1.weight": "model-00001-of-00004.safetensors",
559
+ "vision_model.encoder.layers.8.mlp.fc2.bias": "model-00001-of-00004.safetensors",
560
+ "vision_model.encoder.layers.8.mlp.fc2.weight": "model-00001-of-00004.safetensors",
561
+ "vision_model.encoder.layers.8.norm1.bias": "model-00001-of-00004.safetensors",
562
+ "vision_model.encoder.layers.8.norm1.weight": "model-00001-of-00004.safetensors",
563
+ "vision_model.encoder.layers.8.norm2.bias": "model-00001-of-00004.safetensors",
564
+ "vision_model.encoder.layers.8.norm2.weight": "model-00001-of-00004.safetensors",
565
+ "vision_model.encoder.layers.9.attn.proj.bias": "model-00001-of-00004.safetensors",
566
+ "vision_model.encoder.layers.9.attn.proj.weight": "model-00001-of-00004.safetensors",
567
+ "vision_model.encoder.layers.9.attn.qkv.bias": "model-00001-of-00004.safetensors",
568
+ "vision_model.encoder.layers.9.attn.qkv.weight": "model-00001-of-00004.safetensors",
569
+ "vision_model.encoder.layers.9.ls1": "model-00001-of-00004.safetensors",
570
+ "vision_model.encoder.layers.9.ls2": "model-00001-of-00004.safetensors",
571
+ "vision_model.encoder.layers.9.mlp.fc1.bias": "model-00001-of-00004.safetensors",
572
+ "vision_model.encoder.layers.9.mlp.fc1.weight": "model-00001-of-00004.safetensors",
573
+ "vision_model.encoder.layers.9.mlp.fc2.bias": "model-00001-of-00004.safetensors",
574
+ "vision_model.encoder.layers.9.mlp.fc2.weight": "model-00001-of-00004.safetensors",
575
+ "vision_model.encoder.layers.9.norm1.bias": "model-00001-of-00004.safetensors",
576
+ "vision_model.encoder.layers.9.norm1.weight": "model-00001-of-00004.safetensors",
577
+ "vision_model.encoder.layers.9.norm2.bias": "model-00001-of-00004.safetensors",
578
+ "vision_model.encoder.layers.9.norm2.weight": "model-00001-of-00004.safetensors"
579
+ }
580
+ }
modeling_intern_vit.py ADDED
@@ -0,0 +1,434 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # --------------------------------------------------------
2
+ # InternVL
3
+ # Copyright (c) 2023 OpenGVLab
4
+ # Licensed under The MIT License [see LICENSE for details]
5
+ # --------------------------------------------------------
6
+ from typing import Optional, Tuple, Union
7
+
8
+ import torch
9
+ import torch.nn.functional as F
10
+ import torch.utils.checkpoint
11
+ from einops import rearrange
12
+ from timm.models.layers import DropPath
13
+ from torch import nn
14
+ from transformers.activations import ACT2FN
15
+ from transformers.modeling_outputs import (BaseModelOutput,
16
+ BaseModelOutputWithPooling)
17
+ from transformers.modeling_utils import PreTrainedModel
18
+ from transformers.utils import logging
19
+
20
+ from .configuration_intern_vit import InternVisionConfig
21
+
22
+ try:
23
+ try: # v1
24
+ from flash_attn.flash_attn_interface import \
25
+ flash_attn_unpadded_qkvpacked_func
26
+ except: # v2
27
+ from flash_attn.flash_attn_interface import \
28
+ flash_attn_varlen_qkvpacked_func as flash_attn_unpadded_qkvpacked_func
29
+
30
+ from flash_attn.bert_padding import pad_input, unpad_input
31
+
32
+ has_flash_attn = True
33
+ except:
34
+ print('FlashAttention is not installed.')
35
+ has_flash_attn = False
36
+
37
+ logger = logging.get_logger(__name__)
38
+
39
+
40
+ class FlashAttention(nn.Module):
41
+ """Implement the scaled dot product attention with softmax.
42
+ Arguments
43
+ ---------
44
+ softmax_scale: The temperature to use for the softmax attention.
45
+ (default: 1/sqrt(d_keys) where d_keys is computed at
46
+ runtime)
47
+ attention_dropout: The dropout rate to apply to the attention
48
+ (default: 0.0)
49
+ """
50
+
51
+ def __init__(self, softmax_scale=None, attention_dropout=0.0, device=None, dtype=None):
52
+ super().__init__()
53
+ self.softmax_scale = softmax_scale
54
+ self.dropout_p = attention_dropout
55
+
56
+ def forward(self, qkv, key_padding_mask=None, causal=False, cu_seqlens=None,
57
+ max_s=None, need_weights=False):
58
+ """Implements the multihead softmax attention.
59
+ Arguments
60
+ ---------
61
+ qkv: The tensor containing the query, key, and value. (B, S, 3, H, D) if key_padding_mask is None
62
+ if unpadded: (nnz, 3, h, d)
63
+ key_padding_mask: a bool tensor of shape (B, S)
64
+ """
65
+ assert not need_weights
66
+ assert qkv.dtype in [torch.float16, torch.bfloat16]
67
+ assert qkv.is_cuda
68
+
69
+ if cu_seqlens is None:
70
+ batch_size = qkv.shape[0]
71
+ seqlen = qkv.shape[1]
72
+ if key_padding_mask is None:
73
+ qkv = rearrange(qkv, 'b s ... -> (b s) ...')
74
+ max_s = seqlen
75
+ cu_seqlens = torch.arange(0, (batch_size + 1) * seqlen, step=seqlen, dtype=torch.int32,
76
+ device=qkv.device)
77
+ output = flash_attn_unpadded_qkvpacked_func(
78
+ qkv, cu_seqlens, max_s, self.dropout_p if self.training else 0.0,
79
+ softmax_scale=self.softmax_scale, causal=causal
80
+ )
81
+ output = rearrange(output, '(b s) ... -> b s ...', b=batch_size)
82
+ else:
83
+ nheads = qkv.shape[-2]
84
+ x = rearrange(qkv, 'b s three h d -> b s (three h d)')
85
+ x_unpad, indices, cu_seqlens, max_s = unpad_input(x, key_padding_mask)
86
+ x_unpad = rearrange(x_unpad, 'nnz (three h d) -> nnz three h d', three=3, h=nheads)
87
+ output_unpad = flash_attn_unpadded_qkvpacked_func(
88
+ x_unpad, cu_seqlens, max_s, self.dropout_p if self.training else 0.0,
89
+ softmax_scale=self.softmax_scale, causal=causal
90
+ )
91
+ output = rearrange(pad_input(rearrange(output_unpad, 'nnz h d -> nnz (h d)'),
92
+ indices, batch_size, seqlen),
93
+ 'b s (h d) -> b s h d', h=nheads)
94
+ else:
95
+ assert max_s is not None
96
+ output = flash_attn_unpadded_qkvpacked_func(
97
+ qkv, cu_seqlens, max_s, self.dropout_p if self.training else 0.0,
98
+ softmax_scale=self.softmax_scale, causal=causal
99
+ )
100
+
101
+ return output, None
102
+
103
+
104
+ class InternRMSNorm(nn.Module):
105
+ def __init__(self, hidden_size, eps=1e-6):
106
+ super().__init__()
107
+ self.weight = nn.Parameter(torch.ones(hidden_size))
108
+ self.variance_epsilon = eps
109
+
110
+ def forward(self, hidden_states):
111
+ input_dtype = hidden_states.dtype
112
+ hidden_states = hidden_states.to(torch.float32)
113
+ variance = hidden_states.pow(2).mean(-1, keepdim=True)
114
+ hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)
115
+ return self.weight * hidden_states.to(input_dtype)
116
+
117
+
118
+ try:
119
+ from apex.normalization import FusedRMSNorm
120
+
121
+ InternRMSNorm = FusedRMSNorm # noqa
122
+
123
+ logger.info('Discovered apex.normalization.FusedRMSNorm - will use it instead of InternRMSNorm')
124
+ except ImportError:
125
+ # using the normal InternRMSNorm
126
+ pass
127
+ except Exception:
128
+ logger.warning('discovered apex but it failed to load, falling back to InternRMSNorm')
129
+ pass
130
+
131
+
132
+ NORM2FN = {
133
+ 'rms_norm': InternRMSNorm,
134
+ 'layer_norm': nn.LayerNorm,
135
+ }
136
+
137
+
138
+ class InternVisionEmbeddings(nn.Module):
139
+ def __init__(self, config: InternVisionConfig):
140
+ super().__init__()
141
+ self.config = config
142
+ self.embed_dim = config.hidden_size
143
+ self.image_size = config.image_size
144
+ self.patch_size = config.patch_size
145
+
146
+ self.class_embedding = nn.Parameter(
147
+ torch.randn(1, 1, self.embed_dim),
148
+ )
149
+
150
+ self.patch_embedding = nn.Conv2d(
151
+ in_channels=3, out_channels=self.embed_dim, kernel_size=self.patch_size, stride=self.patch_size
152
+ )
153
+
154
+ self.num_patches = (self.image_size // self.patch_size) ** 2
155
+ self.num_positions = self.num_patches + 1
156
+
157
+ self.position_embedding = nn.Parameter(torch.randn(1, self.num_positions, self.embed_dim))
158
+
159
+ def _get_pos_embed(self, pos_embed, H, W):
160
+ target_dtype = pos_embed.dtype
161
+ pos_embed = pos_embed.float().reshape(
162
+ 1, self.image_size // self.patch_size, self.image_size // self.patch_size, -1).permute(0, 3, 1, 2)
163
+ pos_embed = F.interpolate(pos_embed, size=(H, W), mode='bicubic', align_corners=False). \
164
+ reshape(1, -1, H * W).permute(0, 2, 1).to(target_dtype)
165
+ return pos_embed
166
+
167
+ def forward(self, pixel_values: torch.FloatTensor) -> torch.Tensor:
168
+ target_dtype = self.patch_embedding.weight.dtype
169
+ patch_embeds = self.patch_embedding(pixel_values) # shape = [*, channel, width, height]
170
+ batch_size, _, height, width = patch_embeds.shape
171
+ patch_embeds = patch_embeds.flatten(2).transpose(1, 2)
172
+ class_embeds = self.class_embedding.expand(batch_size, 1, -1).to(target_dtype)
173
+ embeddings = torch.cat([class_embeds, patch_embeds], dim=1)
174
+ position_embedding = torch.cat([
175
+ self.position_embedding[:, :1, :],
176
+ self._get_pos_embed(self.position_embedding[:, 1:, :], height, width)
177
+ ], dim=1)
178
+ embeddings = embeddings + position_embedding.to(target_dtype)
179
+ return embeddings
180
+
181
+
182
+ class InternAttention(nn.Module):
183
+ """Multi-headed attention from 'Attention Is All You Need' paper"""
184
+
185
+ def __init__(self, config: InternVisionConfig):
186
+ super().__init__()
187
+ self.config = config
188
+ self.embed_dim = config.hidden_size
189
+ self.num_heads = config.num_attention_heads
190
+ self.use_flash_attn = config.use_flash_attn and has_flash_attn
191
+ if config.use_flash_attn and not has_flash_attn:
192
+ print('Warning: Flash Attention is not available, use_flash_attn is set to False.')
193
+ self.head_dim = self.embed_dim // self.num_heads
194
+ if self.head_dim * self.num_heads != self.embed_dim:
195
+ raise ValueError(
196
+ f'embed_dim must be divisible by num_heads (got `embed_dim`: {self.embed_dim} and `num_heads`:'
197
+ f' {self.num_heads}).'
198
+ )
199
+
200
+ self.scale = self.head_dim ** -0.5
201
+ self.qkv = nn.Linear(self.embed_dim, 3 * self.embed_dim, bias=config.qkv_bias)
202
+ self.attn_drop = nn.Dropout(config.attention_dropout)
203
+ self.proj_drop = nn.Dropout(config.dropout)
204
+
205
+ self.qk_normalization = config.qk_normalization
206
+
207
+ if self.qk_normalization:
208
+ self.q_norm = InternRMSNorm(self.embed_dim, eps=config.layer_norm_eps)
209
+ self.k_norm = InternRMSNorm(self.embed_dim, eps=config.layer_norm_eps)
210
+
211
+ if self.use_flash_attn:
212
+ self.inner_attn = FlashAttention(attention_dropout=config.attention_dropout)
213
+ self.proj = nn.Linear(self.embed_dim, self.embed_dim)
214
+
215
+ def _naive_attn(self, x):
216
+ B, N, C = x.shape
217
+ qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
218
+ q, k, v = qkv.unbind(0) # make torchscript happy (cannot use tensor as tuple)
219
+
220
+ if self.qk_normalization:
221
+ B_, H_, N_, D_ = q.shape
222
+ q = self.q_norm(q.transpose(1, 2).flatten(-2, -1)).view(B_, N_, H_, D_).transpose(1, 2)
223
+ k = self.k_norm(k.transpose(1, 2).flatten(-2, -1)).view(B_, N_, H_, D_).transpose(1, 2)
224
+
225
+ attn = ((q * self.scale) @ k.transpose(-2, -1))
226
+ attn = attn.softmax(dim=-1)
227
+ attn = self.attn_drop(attn)
228
+
229
+ x = (attn @ v).transpose(1, 2).reshape(B, N, C)
230
+ x = self.proj(x)
231
+ x = self.proj_drop(x)
232
+ return x
233
+
234
+ def _flash_attn(self, x, key_padding_mask=None, need_weights=False):
235
+ qkv = self.qkv(x)
236
+ qkv = rearrange(qkv, 'b s (three h d) -> b s three h d', three=3, h=self.num_heads)
237
+
238
+ if self.qk_normalization:
239
+ q, k, v = qkv.unbind(2)
240
+ q = self.q_norm(q.flatten(-2, -1)).view(q.shape)
241
+ k = self.k_norm(k.flatten(-2, -1)).view(k.shape)
242
+ qkv = torch.stack([q, k, v], dim=2)
243
+
244
+ context, _ = self.inner_attn(
245
+ qkv, key_padding_mask=key_padding_mask, need_weights=need_weights, causal=False
246
+ )
247
+ outs = self.proj(rearrange(context, 'b s h d -> b s (h d)'))
248
+ outs = self.proj_drop(outs)
249
+ return outs
250
+
251
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
252
+ x = self._naive_attn(hidden_states) if not self.use_flash_attn else self._flash_attn(hidden_states)
253
+ return x
254
+
255
+
256
+ class InternMLP(nn.Module):
257
+ def __init__(self, config: InternVisionConfig):
258
+ super().__init__()
259
+ self.config = config
260
+ self.act = ACT2FN[config.hidden_act]
261
+ self.fc1 = nn.Linear(config.hidden_size, config.intermediate_size)
262
+ self.fc2 = nn.Linear(config.intermediate_size, config.hidden_size)
263
+
264
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
265
+ hidden_states = self.fc1(hidden_states)
266
+ hidden_states = self.act(hidden_states)
267
+ hidden_states = self.fc2(hidden_states)
268
+ return hidden_states
269
+
270
+
271
+ class InternVisionEncoderLayer(nn.Module):
272
+ def __init__(self, config: InternVisionConfig, drop_path_rate: float):
273
+ super().__init__()
274
+ self.embed_dim = config.hidden_size
275
+ self.intermediate_size = config.intermediate_size
276
+ self.norm_type = config.norm_type
277
+
278
+ self.attn = InternAttention(config)
279
+ self.mlp = InternMLP(config)
280
+ self.norm1 = NORM2FN[self.norm_type](self.embed_dim, eps=config.layer_norm_eps)
281
+ self.norm2 = NORM2FN[self.norm_type](self.embed_dim, eps=config.layer_norm_eps)
282
+
283
+ self.ls1 = nn.Parameter(config.initializer_factor * torch.ones(self.embed_dim))
284
+ self.ls2 = nn.Parameter(config.initializer_factor * torch.ones(self.embed_dim))
285
+ self.drop_path1 = DropPath(drop_path_rate) if drop_path_rate > 0. else nn.Identity()
286
+ self.drop_path2 = DropPath(drop_path_rate) if drop_path_rate > 0. else nn.Identity()
287
+
288
+ def forward(
289
+ self,
290
+ hidden_states: torch.Tensor,
291
+ ) -> Tuple[torch.FloatTensor, Optional[torch.FloatTensor], Optional[Tuple[torch.FloatTensor]]]:
292
+ """
293
+ Args:
294
+ hidden_states (`Tuple[torch.FloatTensor, Optional[torch.FloatTensor]]`): input to the layer of shape `(batch, seq_len, embed_dim)`
295
+ """
296
+ hidden_states = hidden_states + self.drop_path1(self.attn(self.norm1(hidden_states)) * self.ls1)
297
+
298
+ hidden_states = hidden_states + self.drop_path2(self.mlp(self.norm2(hidden_states)) * self.ls2)
299
+
300
+ return hidden_states
301
+
302
+
303
+ class InternVisionEncoder(nn.Module):
304
+ """
305
+ Transformer encoder consisting of `config.num_hidden_layers` self attention layers. Each layer is a
306
+ [`InternEncoderLayer`].
307
+
308
+ Args:
309
+ config (`InternConfig`):
310
+ The corresponding vision configuration for the `InternEncoder`.
311
+ """
312
+
313
+ def __init__(self, config: InternVisionConfig):
314
+ super().__init__()
315
+ self.config = config
316
+ # stochastic depth decay rule
317
+ dpr = [x.item() for x in torch.linspace(0, config.drop_path_rate, config.num_hidden_layers)]
318
+ self.layers = nn.ModuleList([
319
+ InternVisionEncoderLayer(config, dpr[idx]) for idx in range(config.num_hidden_layers)])
320
+ self.gradient_checkpointing = True
321
+
322
+ def forward(
323
+ self,
324
+ inputs_embeds,
325
+ output_hidden_states: Optional[bool] = None,
326
+ return_dict: Optional[bool] = None,
327
+ ) -> Union[Tuple, BaseModelOutput]:
328
+ r"""
329
+ Args:
330
+ inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`):
331
+ Embedded representation of the inputs. Should be float, not int tokens.
332
+ output_hidden_states (`bool`, *optional*):
333
+ Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors
334
+ for more detail.
335
+ return_dict (`bool`, *optional*):
336
+ Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
337
+ """
338
+ output_hidden_states = (
339
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
340
+ )
341
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
342
+
343
+ encoder_states = () if output_hidden_states else None
344
+ hidden_states = inputs_embeds
345
+
346
+ for idx, encoder_layer in enumerate(self.layers):
347
+ if output_hidden_states:
348
+ encoder_states = encoder_states + (hidden_states,)
349
+ if self.gradient_checkpointing and self.training:
350
+ layer_outputs = torch.utils.checkpoint.checkpoint(
351
+ encoder_layer,
352
+ hidden_states)
353
+ else:
354
+ layer_outputs = encoder_layer(
355
+ hidden_states,
356
+ )
357
+ hidden_states = layer_outputs
358
+
359
+ if output_hidden_states:
360
+ encoder_states = encoder_states + (hidden_states,)
361
+
362
+ if not return_dict:
363
+ return tuple(v for v in [hidden_states, encoder_states] if v is not None)
364
+ return BaseModelOutput(
365
+ last_hidden_state=hidden_states, hidden_states=encoder_states
366
+ )
367
+
368
+
369
+ class InternVisionModel(PreTrainedModel):
370
+ main_input_name = 'pixel_values'
371
+ config_class = InternVisionConfig
372
+ _no_split_modules = ['InternVisionEncoderLayer']
373
+
374
+ def __init__(self, config: InternVisionConfig):
375
+ super().__init__(config)
376
+ self.config = config
377
+
378
+ self.embeddings = InternVisionEmbeddings(config)
379
+ self.encoder = InternVisionEncoder(config)
380
+
381
+ def resize_pos_embeddings(self, old_size, new_size, patch_size):
382
+ pos_emb = self.embeddings.position_embedding
383
+ _, num_positions, embed_dim = pos_emb.shape
384
+ cls_emb = pos_emb[:, :1, :]
385
+ pos_emb = pos_emb[:, 1:, :].reshape(1, old_size // patch_size, old_size // patch_size, -1).permute(0, 3, 1, 2)
386
+ pos_emb = F.interpolate(pos_emb.float(), size=new_size // patch_size, mode='bicubic', align_corners=False)
387
+ pos_emb = pos_emb.to(cls_emb.dtype).reshape(1, embed_dim, -1).permute(0, 2, 1)
388
+ pos_emb = torch.cat([cls_emb, pos_emb], dim=1)
389
+ self.embeddings.position_embedding = nn.Parameter(pos_emb)
390
+ self.embeddings.image_size = new_size
391
+ logger.info('Resized position embeddings from {} to {}'.format(old_size, new_size))
392
+
393
+ def get_input_embeddings(self):
394
+ return self.embeddings
395
+
396
+ def forward(
397
+ self,
398
+ pixel_values: Optional[torch.FloatTensor] = None,
399
+ output_hidden_states: Optional[bool] = None,
400
+ return_dict: Optional[bool] = None,
401
+ pixel_embeds: Optional[torch.FloatTensor] = None,
402
+ ) -> Union[Tuple, BaseModelOutputWithPooling]:
403
+ output_hidden_states = (
404
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
405
+ )
406
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
407
+
408
+ if pixel_values is None and pixel_embeds is None:
409
+ raise ValueError('You have to specify pixel_values or pixel_embeds')
410
+
411
+ if pixel_embeds is not None:
412
+ hidden_states = pixel_embeds
413
+ else:
414
+ if len(pixel_values.shape) == 4:
415
+ hidden_states = self.embeddings(pixel_values)
416
+ else:
417
+ raise ValueError(f'wrong pixel_values size: {pixel_values.shape}')
418
+ encoder_outputs = self.encoder(
419
+ inputs_embeds=hidden_states,
420
+ output_hidden_states=output_hidden_states,
421
+ return_dict=return_dict,
422
+ )
423
+ last_hidden_state = encoder_outputs.last_hidden_state
424
+ pooled_output = last_hidden_state[:, 0, :]
425
+
426
+ if not return_dict:
427
+ return (last_hidden_state, pooled_output) + encoder_outputs[1:]
428
+
429
+ return BaseModelOutputWithPooling(
430
+ last_hidden_state=last_hidden_state,
431
+ pooler_output=pooled_output,
432
+ hidden_states=encoder_outputs.hidden_states,
433
+ attentions=encoder_outputs.attentions,
434
+ )
modeling_internlm2.py ADDED
@@ -0,0 +1,1414 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Copyright (c) The InternLM team and The HuggingFace Inc. team. All rights reserved.
2
+ #
3
+ # This code is based on transformers/src/transformers/models/llama/modeling_llama.py
4
+ #
5
+ # Licensed under the Apache License, Version 2.0 (the "License");
6
+ # you may not use this file except in compliance with the License.
7
+ # You may obtain a copy of the License at
8
+ #
9
+ # http://www.apache.org/licenses/LICENSE-2.0
10
+ #
11
+ # Unless required by applicable law or agreed to in writing, software
12
+ # distributed under the License is distributed on an "AS IS" BASIS,
13
+ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14
+ # See the License for the specific language governing permissions and
15
+ # limitations under the License.
16
+ """ PyTorch InternLM2 model."""
17
+ import math
18
+ import queue
19
+ import threading
20
+ import warnings
21
+ from typing import List, Optional, Tuple, Union
22
+
23
+ import torch
24
+ import torch.nn.functional as F
25
+ import torch.utils.checkpoint
26
+ from einops import rearrange
27
+ from torch import nn
28
+ from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss
29
+ from transformers.activations import ACT2FN
30
+ from transformers.modeling_outputs import (BaseModelOutputWithPast,
31
+ CausalLMOutputWithPast,
32
+ SequenceClassifierOutputWithPast)
33
+ from transformers.modeling_utils import PreTrainedModel
34
+ from transformers.utils import (add_start_docstrings,
35
+ add_start_docstrings_to_model_forward, logging,
36
+ replace_return_docstrings)
37
+
38
+ try:
39
+ from transformers.generation.streamers import BaseStreamer
40
+ except: # noqa # pylint: disable=bare-except
41
+ BaseStreamer = None
42
+
43
+ from .configuration_internlm2 import InternLM2Config
44
+
45
+ logger = logging.get_logger(__name__)
46
+
47
+ _CONFIG_FOR_DOC = 'InternLM2Config'
48
+
49
+ flash_attn_func, flash_attn_varlen_func = None, None
50
+ pad_input, index_first_axis, unpad_input = None, None, None
51
+ try:
52
+ from flash_attn import flash_attn_func as _flash_attn_func
53
+ from flash_attn import flash_attn_varlen_func as _flash_attn_varlen_func
54
+ from flash_attn.bert_padding import index_first_axis as _index_first_axis
55
+ from flash_attn.bert_padding import pad_input as _pad_input
56
+ from flash_attn.bert_padding import unpad_input as _unpad_input
57
+
58
+ flash_attn_func, flash_attn_varlen_func = _flash_attn_func, _flash_attn_varlen_func
59
+ pad_input, index_first_axis, unpad_input = _pad_input, _index_first_axis, _unpad_input
60
+ has_flash_attn = True
61
+ except:
62
+ has_flash_attn = False
63
+
64
+
65
+ def _import_flash_attn():
66
+ global flash_attn_func, flash_attn_varlen_func
67
+ global pad_input, index_first_axis, unpad_input
68
+ try:
69
+ from flash_attn import flash_attn_func as _flash_attn_func
70
+ from flash_attn import \
71
+ flash_attn_varlen_func as _flash_attn_varlen_func
72
+ from flash_attn.bert_padding import \
73
+ index_first_axis as _index_first_axis
74
+ from flash_attn.bert_padding import pad_input as _pad_input
75
+ from flash_attn.bert_padding import unpad_input as _unpad_input
76
+ flash_attn_func, flash_attn_varlen_func = _flash_attn_func, _flash_attn_varlen_func
77
+ pad_input, index_first_axis, unpad_input = _pad_input, _index_first_axis, _unpad_input
78
+ except ImportError:
79
+ raise ImportError('flash_attn is not installed.')
80
+
81
+
82
+ # Copied from transformers.models.llama.modeling_llama._get_unpad_data
83
+ def _get_unpad_data(attention_mask):
84
+ seqlens_in_batch = attention_mask.sum(dim=-1, dtype=torch.int32)
85
+ indices = torch.nonzero(attention_mask.flatten(), as_tuple=False).flatten()
86
+ max_seqlen_in_batch = seqlens_in_batch.max().item()
87
+ cu_seqlens = F.pad(torch.cumsum(seqlens_in_batch, dim=0, dtype=torch.torch.int32), (1, 0))
88
+ return (
89
+ indices,
90
+ cu_seqlens,
91
+ max_seqlen_in_batch,
92
+ )
93
+
94
+
95
+ # Copied from transformers.models.bart.modeling_bart._make_causal_mask
96
+ def _make_causal_mask(
97
+ input_ids_shape: torch.Size, dtype: torch.dtype, device: torch.device, past_key_values_length: int = 0
98
+ ):
99
+ """
100
+ Make causal mask used for bi-directional self-attention.
101
+ """
102
+ bsz, tgt_len = input_ids_shape
103
+ mask = torch.full((tgt_len, tgt_len), torch.tensor(torch.finfo(dtype).min, device=device), device=device)
104
+ mask_cond = torch.arange(mask.size(-1), device=device)
105
+ mask.masked_fill_(mask_cond < (mask_cond + 1).view(mask.size(-1), 1), 0)
106
+ mask = mask.to(dtype)
107
+
108
+ if past_key_values_length > 0:
109
+ mask = torch.cat([torch.zeros(tgt_len, past_key_values_length, dtype=dtype, device=device), mask], dim=-1)
110
+ return mask[None, None, :, :].expand(bsz, 1, tgt_len, tgt_len + past_key_values_length)
111
+
112
+
113
+ # Copied from transformers.models.bart.modeling_bart._expand_mask
114
+ def _expand_mask(mask: torch.Tensor, dtype: torch.dtype, tgt_len: Optional[int] = None):
115
+ """
116
+ Expands attention_mask from `[bsz, seq_len]` to `[bsz, 1, tgt_seq_len, src_seq_len]`.
117
+ """
118
+ bsz, src_len = mask.size()
119
+ tgt_len = tgt_len if tgt_len is not None else src_len
120
+
121
+ expanded_mask = mask[:, None, None, :].expand(bsz, 1, tgt_len, src_len).to(dtype)
122
+
123
+ inverted_mask = 1.0 - expanded_mask
124
+
125
+ return inverted_mask.masked_fill(inverted_mask.to(torch.bool), torch.finfo(dtype).min)
126
+
127
+
128
+ # Copied from transformers.models.llama.modeling_llama.LlamaRMSNorm with Llama->InternLM2
129
+ class InternLM2RMSNorm(nn.Module):
130
+ def __init__(self, hidden_size, eps=1e-6):
131
+ """
132
+ InternLM2RMSNorm is equivalent to T5LayerNorm
133
+ """
134
+ super().__init__()
135
+ self.weight = nn.Parameter(torch.ones(hidden_size))
136
+ self.variance_epsilon = eps
137
+
138
+ def forward(self, hidden_states):
139
+ input_dtype = hidden_states.dtype
140
+ hidden_states = hidden_states.to(torch.float32)
141
+ variance = hidden_states.pow(2).mean(-1, keepdim=True)
142
+ hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)
143
+ return self.weight * hidden_states.to(input_dtype)
144
+
145
+
146
+ # Copied from transformers.model.llama.modeling_llama.LlamaRotaryEmbedding with Llama->InternLM2
147
+ class InternLM2RotaryEmbedding(nn.Module):
148
+ def __init__(self, dim, max_position_embeddings=2048, base=10000, device=None):
149
+ super().__init__()
150
+
151
+ self.dim = dim
152
+ self.max_position_embeddings = max_position_embeddings
153
+ self.base = base
154
+ inv_freq = 1.0 / (self.base ** (torch.arange(0, self.dim, 2).float().to(device) / self.dim))
155
+ self.register_buffer('inv_freq', inv_freq, persistent=False)
156
+
157
+ # Build here to make `torch.jit.trace` work.
158
+ self._set_cos_sin_cache(
159
+ seq_len=max_position_embeddings, device=self.inv_freq.device, dtype=torch.get_default_dtype()
160
+ )
161
+
162
+ def _set_cos_sin_cache(self, seq_len, device, dtype):
163
+ self.max_seq_len_cached = seq_len
164
+ t = torch.arange(self.max_seq_len_cached, device=device).to(dtype=self.inv_freq.dtype)
165
+
166
+ freqs = torch.einsum('i,j->ij', t, self.inv_freq)
167
+ # Different from paper, but it uses a different permutation in order to obtain the same calculation
168
+ emb = torch.cat((freqs, freqs), dim=-1)
169
+ self.register_buffer('cos_cached', emb.cos().to(dtype), persistent=False)
170
+ self.register_buffer('sin_cached', emb.sin().to(dtype), persistent=False)
171
+
172
+ def forward(self, x, seq_len=None):
173
+ # x: [bs, num_attention_heads, seq_len, head_size]
174
+ if seq_len > self.max_seq_len_cached:
175
+ self._set_cos_sin_cache(seq_len=seq_len, device=x.device, dtype=torch.float32)
176
+
177
+ return (
178
+ self.cos_cached[:seq_len].to(dtype=x.dtype),
179
+ self.sin_cached[:seq_len].to(dtype=x.dtype),
180
+ )
181
+
182
+
183
+ # Copied from transformers.model.llama.modeling_llama.LlamaLinearScalingRotaryEmbedding with Llama->InternLM2
184
+ class InternLM2LinearScalingRotaryEmbedding(InternLM2RotaryEmbedding):
185
+ """InternLM2RotaryEmbedding extended with linear scaling. Credits to the Reddit user /u/kaiokendev"""
186
+
187
+ def __init__(self, dim, max_position_embeddings=2048, base=10000, device=None, scaling_factor=1.0):
188
+ self.scaling_factor = scaling_factor
189
+ super().__init__(dim, max_position_embeddings, base, device)
190
+
191
+ def _set_cos_sin_cache(self, seq_len, device, dtype):
192
+ self.max_seq_len_cached = seq_len
193
+ t = torch.arange(self.max_seq_len_cached, device=device).to(dtype=self.inv_freq.dtype)
194
+ t = t / self.scaling_factor
195
+
196
+ freqs = torch.einsum('i,j->ij', t, self.inv_freq)
197
+ # Different from paper, but it uses a different permutation in order to obtain the same calculation
198
+ emb = torch.cat((freqs, freqs), dim=-1)
199
+ self.register_buffer('cos_cached', emb.cos().to(dtype), persistent=False)
200
+ self.register_buffer('sin_cached', emb.sin().to(dtype), persistent=False)
201
+
202
+
203
+ # Copied from transformers.model.llama.modeling_llama.LlamaDynamicNTKScalingRotaryEmbedding with Llama->InternLM2
204
+ class InternLM2DynamicNTKScalingRotaryEmbedding(InternLM2RotaryEmbedding):
205
+ """InternLM2RotaryEmbedding extended with Dynamic NTK scaling.
206
+ Credits to the Reddit users /u/bloc97 and /u/emozilla.
207
+ """
208
+
209
+ def __init__(self, dim, max_position_embeddings=2048, base=10000, device=None, scaling_factor=1.0):
210
+ self.scaling_factor = scaling_factor
211
+ super().__init__(dim, max_position_embeddings, base, device)
212
+
213
+ def _set_cos_sin_cache(self, seq_len, device, dtype):
214
+ self.max_seq_len_cached = seq_len
215
+
216
+ if seq_len > self.max_position_embeddings:
217
+ base = self.base * (
218
+ (self.scaling_factor * seq_len / self.max_position_embeddings) - (self.scaling_factor - 1)
219
+ ) ** (self.dim / (self.dim - 2))
220
+ inv_freq = 1.0 / (base ** (torch.arange(0, self.dim, 2).float().to(device) / self.dim))
221
+ self.register_buffer('inv_freq', inv_freq, persistent=False)
222
+
223
+ t = torch.arange(self.max_seq_len_cached, device=device).to(dtype=self.inv_freq.dtype)
224
+
225
+ freqs = torch.einsum('i,j->ij', t, self.inv_freq)
226
+ # Different from paper, but it uses a different permutation in order to obtain the same calculation
227
+ emb = torch.cat((freqs, freqs), dim=-1)
228
+ self.register_buffer('cos_cached', emb.cos().to(dtype), persistent=False)
229
+ self.register_buffer('sin_cached', emb.sin().to(dtype), persistent=False)
230
+
231
+
232
+ # Copied from transformers.model.llama.modeling_llama.rotate_half
233
+ def rotate_half(x):
234
+ """Rotates half the hidden dims of the input."""
235
+ x1 = x[..., : x.shape[-1] // 2]
236
+ x2 = x[..., x.shape[-1] // 2 :]
237
+ return torch.cat((-x2, x1), dim=-1)
238
+
239
+
240
+ # Copied from transformers.model.llama.modeling_llama.apply_rotary_pos_emb
241
+ def apply_rotary_pos_emb(q, k, cos, sin, position_ids, unsqueeze_dim=1):
242
+ """Applies Rotary Position Embedding to the query and key tensors."""
243
+ cos = cos[position_ids].unsqueeze(unsqueeze_dim)
244
+ sin = sin[position_ids].unsqueeze(unsqueeze_dim)
245
+ q_embed = (q * cos) + (rotate_half(q) * sin)
246
+ k_embed = (k * cos) + (rotate_half(k) * sin)
247
+ return q_embed, k_embed
248
+
249
+
250
+ class InternLM2MLP(nn.Module):
251
+ def __init__(self, config):
252
+ super().__init__()
253
+ self.config = config
254
+ self.hidden_size = config.hidden_size
255
+ self.intermediate_size = config.intermediate_size
256
+ self.w1 = nn.Linear(self.hidden_size, self.intermediate_size, bias=False)
257
+ self.w3 = nn.Linear(self.hidden_size, self.intermediate_size, bias=False)
258
+ self.w2 = nn.Linear(self.intermediate_size, self.hidden_size, bias=False)
259
+ self.act_fn = ACT2FN[config.hidden_act]
260
+
261
+ def forward(self, x):
262
+ down_proj = self.w2(self.act_fn(self.w1(x)) * self.w3(x))
263
+
264
+ return down_proj
265
+
266
+
267
+ # Copied from transformers.model.llama.modeling_llama.repeat_kv
268
+ def repeat_kv(hidden_states: torch.Tensor, n_rep: int) -> torch.Tensor:
269
+ """
270
+ This is the equivalent of torch.repeat_interleave(x, dim=1, repeats=n_rep). The hidden states go from (batch,
271
+ num_key_value_heads, seqlen, head_dim) to (batch, num_attention_heads, seqlen, head_dim)
272
+ """
273
+ batch, num_key_value_heads, slen, head_dim = hidden_states.shape
274
+ if n_rep == 1:
275
+ return hidden_states
276
+ hidden_states = hidden_states[:, :, None, :, :].expand(batch, num_key_value_heads, n_rep, slen, head_dim)
277
+ return hidden_states.reshape(batch, num_key_value_heads * n_rep, slen, head_dim)
278
+
279
+
280
+ # Modified from transformers.model.llama.modeling_llama.LlamaAttention
281
+ class InternLM2Attention(nn.Module):
282
+ """Multi-headed attention from 'Attention Is All You Need' paper"""
283
+
284
+ def __init__(self, config: InternLM2Config):
285
+ super().__init__()
286
+ self.config = config
287
+ self.hidden_size = config.hidden_size
288
+ self.num_heads = config.num_attention_heads
289
+ self.head_dim = self.hidden_size // self.num_heads
290
+ self.num_key_value_heads = config.num_key_value_heads
291
+ self.num_key_value_groups = self.num_heads // self.num_key_value_heads
292
+ self.max_position_embeddings = config.max_position_embeddings
293
+ self.is_causal = True
294
+
295
+ if (self.head_dim * self.num_heads) != self.hidden_size:
296
+ raise ValueError(
297
+ f'hidden_size must be divisible by num_heads (got `hidden_size`: {self.hidden_size}'
298
+ f' and `num_heads`: {self.num_heads}).'
299
+ )
300
+
301
+ self.wqkv = nn.Linear(
302
+ self.hidden_size,
303
+ (self.num_heads + 2 * self.num_key_value_heads) * self.head_dim,
304
+ bias=config.bias,
305
+ )
306
+
307
+ self.wo = nn.Linear(self.num_heads * self.head_dim, self.hidden_size, bias=config.bias)
308
+ self._init_rope()
309
+
310
+ def _init_rope(self):
311
+ if self.config.rope_scaling is None:
312
+ self.rotary_emb = InternLM2RotaryEmbedding(
313
+ self.head_dim,
314
+ max_position_embeddings=self.max_position_embeddings,
315
+ base=self.config.rope_theta,
316
+ )
317
+ else:
318
+ scaling_type = self.config.rope_scaling['type']
319
+ scaling_factor = self.config.rope_scaling['factor']
320
+ if scaling_type == 'dynamic':
321
+ self.rotary_emb = InternLM2DynamicNTKScalingRotaryEmbedding(
322
+ self.head_dim,
323
+ max_position_embeddings=self.max_position_embeddings,
324
+ base=self.config.rope_theta,
325
+ scaling_factor=scaling_factor,
326
+ )
327
+ elif scaling_type == 'linear':
328
+ self.rotary_emb = InternLM2LinearScalingRotaryEmbedding(
329
+ self.head_dim,
330
+ max_position_embeddings=self.max_position_embeddings,
331
+ base=self.config.rope_theta,
332
+ scaling_factor=scaling_factor,
333
+ )
334
+ else:
335
+ raise ValueError("Currently we only support rotary embedding's type being 'dynamic' or 'linear'.")
336
+ return self.rotary_emb
337
+
338
+ def _shape(self, tensor: torch.Tensor, seq_len: int, bsz: int):
339
+ return tensor.view(bsz, seq_len, self.num_heads, self.head_dim).transpose(1, 2).contiguous()
340
+
341
+ def forward(
342
+ self,
343
+ hidden_states: torch.Tensor,
344
+ attention_mask: Optional[torch.Tensor] = None,
345
+ position_ids: Optional[torch.LongTensor] = None,
346
+ past_key_value: Optional[Tuple[torch.Tensor]] = None,
347
+ output_attentions: bool = False,
348
+ use_cache: bool = False,
349
+ **kwargs,
350
+ ) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[Tuple[torch.Tensor]]]:
351
+ if 'padding_mask' in kwargs:
352
+ warnings.warn(
353
+ 'Passing `padding_mask` is deprecated and will be removed in v4.37. '
354
+ 'Please make sure use `attention_mask` instead.`'
355
+ )
356
+
357
+ bsz, q_len, _ = hidden_states.size()
358
+
359
+ qkv_states = self.wqkv(hidden_states)
360
+
361
+ qkv_states = rearrange(
362
+ qkv_states,
363
+ 'b q (h gs d) -> b q h gs d',
364
+ gs=2 + self.num_key_value_groups,
365
+ d=self.head_dim,
366
+ )
367
+
368
+ query_states = qkv_states[..., : self.num_key_value_groups, :]
369
+ query_states = rearrange(query_states, 'b q h gs d -> b q (h gs) d')
370
+ key_states = qkv_states[..., -2, :]
371
+ value_states = qkv_states[..., -1, :]
372
+
373
+ query_states = query_states.transpose(1, 2)
374
+ key_states = key_states.transpose(1, 2)
375
+ value_states = value_states.transpose(1, 2)
376
+
377
+ kv_seq_len = key_states.shape[-2]
378
+ if past_key_value is not None:
379
+ kv_seq_len += past_key_value[0].shape[-2]
380
+ cos, sin = self.rotary_emb(value_states, seq_len=kv_seq_len)
381
+ query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin, position_ids)
382
+
383
+ if past_key_value is not None:
384
+ # reuse k, v, self_attention
385
+ key_states = torch.cat([past_key_value[0], key_states], dim=2)
386
+ value_states = torch.cat([past_key_value[1], value_states], dim=2)
387
+
388
+ past_key_value = (key_states, value_states) if use_cache else None
389
+
390
+ key_states = repeat_kv(key_states, self.num_key_value_groups)
391
+ value_states = repeat_kv(value_states, self.num_key_value_groups)
392
+
393
+ attn_weights = torch.matmul(query_states, key_states.transpose(2, 3)) / math.sqrt(self.head_dim)
394
+
395
+ if attn_weights.size() != (bsz, self.num_heads, q_len, kv_seq_len):
396
+ raise ValueError(
397
+ f'Attention weights should be of size {(bsz, self.num_heads, q_len, kv_seq_len)}, but is'
398
+ f' {attn_weights.size()}'
399
+ )
400
+
401
+ if attention_mask is not None:
402
+ if attention_mask.size() != (bsz, 1, q_len, kv_seq_len):
403
+ raise ValueError(
404
+ f'Attention mask should be of size {(bsz, 1, q_len, kv_seq_len)}, but is {attention_mask.size()}'
405
+ )
406
+ attn_weights = attn_weights + attention_mask
407
+
408
+ # upcast attention to fp32
409
+ attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query_states.dtype)
410
+ attn_output = torch.matmul(attn_weights, value_states)
411
+
412
+ if attn_output.size() != (bsz, self.num_heads, q_len, self.head_dim):
413
+ raise ValueError(
414
+ f'`attn_output` should be of size {(bsz, self.num_heads, q_len, self.head_dim)}, but is'
415
+ f' {attn_output.size()}'
416
+ )
417
+
418
+ attn_output = attn_output.transpose(1, 2).contiguous()
419
+ attn_output = attn_output.reshape(bsz, q_len, self.hidden_size)
420
+
421
+ attn_output = self.wo(attn_output)
422
+
423
+ if not output_attentions:
424
+ attn_weights = None
425
+
426
+ return attn_output, attn_weights, past_key_value
427
+
428
+
429
+ # Modified from transformers.model.llama.modeling_llama.InternLM2FlashAttention2
430
+ class InternLM2FlashAttention2(InternLM2Attention):
431
+ """
432
+ InternLM2 flash attention module. This module inherits from `InternLM2Attention` as the weights of the module stays
433
+ untouched. The only required change would be on the forward pass where it needs to correctly call the public API of
434
+ flash attention and deal with padding tokens in case the input contains any of them.
435
+ """
436
+
437
+ def forward(
438
+ self,
439
+ hidden_states: torch.Tensor,
440
+ attention_mask: Optional[torch.LongTensor] = None,
441
+ position_ids: Optional[torch.LongTensor] = None,
442
+ past_key_value: Optional[Tuple[torch.Tensor]] = None,
443
+ output_attentions: bool = False,
444
+ use_cache: bool = False,
445
+ **kwargs,
446
+ ) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[Tuple[torch.Tensor]]]:
447
+ # InternLM2FlashAttention2 attention does not support output_attentions
448
+ if 'padding_mask' in kwargs:
449
+ warnings.warn(
450
+ 'Passing `padding_mask` is deprecated and will be removed in v4.37. '
451
+ 'Please make sure use `attention_mask` instead.`'
452
+ )
453
+
454
+ # overwrite attention_mask with padding_mask
455
+ attention_mask = kwargs.pop('padding_mask')
456
+
457
+ output_attentions = False
458
+
459
+ bsz, q_len, _ = hidden_states.size()
460
+
461
+ qkv_states = self.wqkv(hidden_states)
462
+
463
+ qkv_states = rearrange(
464
+ qkv_states,
465
+ 'b q (h gs d) -> b q h gs d',
466
+ gs=2 + self.num_key_value_groups,
467
+ d=self.head_dim,
468
+ )
469
+
470
+ query_states = qkv_states[..., : self.num_key_value_groups, :]
471
+ query_states = rearrange(query_states, 'b q h gs d -> b q (h gs) d')
472
+ key_states = qkv_states[..., -2, :]
473
+ value_states = qkv_states[..., -1, :]
474
+
475
+ query_states = query_states.transpose(1, 2)
476
+ key_states = key_states.transpose(1, 2)
477
+ value_states = value_states.transpose(1, 2)
478
+
479
+ kv_seq_len = key_states.shape[-2]
480
+ if past_key_value is not None:
481
+ kv_seq_len += past_key_value[0].shape[-2]
482
+
483
+ cos, sin = self.rotary_emb(value_states, seq_len=kv_seq_len)
484
+
485
+ query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin, position_ids)
486
+
487
+ if past_key_value is not None:
488
+ # reuse k, v, self_attention
489
+ key_states = torch.cat([past_key_value[0], key_states], dim=2)
490
+ value_states = torch.cat([past_key_value[1], value_states], dim=2)
491
+
492
+ past_key_value = (key_states, value_states) if use_cache else None
493
+
494
+ query_states = query_states.transpose(1, 2)
495
+ key_states = key_states.transpose(1, 2)
496
+ value_states = value_states.transpose(1, 2)
497
+
498
+ attn_output = self._flash_attention_forward(
499
+ query_states, key_states, value_states, attention_mask, q_len
500
+ )
501
+ attn_output = attn_output.reshape(bsz, q_len, self.hidden_size).contiguous()
502
+ attn_output = self.wo(attn_output)
503
+
504
+ if not output_attentions:
505
+ attn_weights = None
506
+
507
+ return attn_output, attn_weights, past_key_value
508
+
509
+ def _flash_attention_forward(
510
+ self, query_states, key_states, value_states, attention_mask, query_length, dropout=0.0, softmax_scale=None
511
+ ):
512
+ """
513
+ Calls the forward method of Flash Attention - if the input hidden states contain at least one padding token
514
+ first unpad the input, then computes the attention scores and pad the final attention scores.
515
+
516
+ Args:
517
+ query_states (`torch.Tensor`):
518
+ Input query states to be passed to Flash Attention API
519
+ key_states (`torch.Tensor`):
520
+ Input key states to be passed to Flash Attention API
521
+ value_states (`torch.Tensor`):
522
+ Input value states to be passed to Flash Attention API
523
+ attention_mask (`torch.Tensor`):
524
+ The padding mask - corresponds to a tensor of size `(batch_size, seq_len)` where 0 stands for the
525
+ position of padding tokens and 1 for the position of non-padding tokens.
526
+ dropout (`int`, *optional*):
527
+ Attention dropout
528
+ softmax_scale (`float`, *optional*):
529
+ The scaling of QK^T before applying softmax. Default to 1 / sqrt(head_dim)
530
+ """
531
+ # Contains at least one padding token in the sequence
532
+ causal = self.is_causal and query_length != 1
533
+ if attention_mask is not None:
534
+ batch_size = query_states.shape[0]
535
+ query_states, key_states, value_states, indices_q, cu_seq_lens, max_seq_lens = self._unpad_input(
536
+ query_states, key_states, value_states, attention_mask, query_length
537
+ )
538
+
539
+ cu_seqlens_q, cu_seqlens_k = cu_seq_lens
540
+ max_seqlen_in_batch_q, max_seqlen_in_batch_k = max_seq_lens
541
+
542
+ attn_output_unpad = flash_attn_varlen_func(
543
+ query_states,
544
+ key_states,
545
+ value_states,
546
+ cu_seqlens_q=cu_seqlens_q,
547
+ cu_seqlens_k=cu_seqlens_k,
548
+ max_seqlen_q=max_seqlen_in_batch_q,
549
+ max_seqlen_k=max_seqlen_in_batch_k,
550
+ dropout_p=dropout,
551
+ softmax_scale=softmax_scale,
552
+ causal=causal,
553
+ )
554
+
555
+ attn_output = pad_input(attn_output_unpad, indices_q, batch_size, query_length)
556
+ else:
557
+ attn_output = flash_attn_func(
558
+ query_states, key_states, value_states, dropout, softmax_scale=softmax_scale, causal=causal
559
+ )
560
+
561
+ return attn_output
562
+
563
+ def _unpad_input(self, query_layer, key_layer, value_layer, attention_mask, query_length):
564
+ indices_k, cu_seqlens_k, max_seqlen_in_batch_k = _get_unpad_data(attention_mask)
565
+ batch_size, kv_seq_len, num_key_value_heads, head_dim = key_layer.shape
566
+
567
+ key_layer = index_first_axis(
568
+ key_layer.reshape(batch_size * kv_seq_len, num_key_value_heads, head_dim), indices_k
569
+ )
570
+ value_layer = index_first_axis(
571
+ value_layer.reshape(batch_size * kv_seq_len, num_key_value_heads, head_dim), indices_k
572
+ )
573
+
574
+ if query_length == kv_seq_len:
575
+ query_layer = index_first_axis(
576
+ query_layer.reshape(batch_size * kv_seq_len, self.num_heads, head_dim), indices_k
577
+ )
578
+ cu_seqlens_q = cu_seqlens_k
579
+ max_seqlen_in_batch_q = max_seqlen_in_batch_k
580
+ indices_q = indices_k
581
+ elif query_length == 1:
582
+ max_seqlen_in_batch_q = 1
583
+ cu_seqlens_q = torch.arange(
584
+ batch_size + 1, dtype=torch.int32, device=query_layer.device
585
+ ) # There is a memcpy here, that is very bad.
586
+ indices_q = cu_seqlens_q[:-1]
587
+ query_layer = query_layer.squeeze(1)
588
+ else:
589
+ # The -q_len: slice assumes left padding.
590
+ attention_mask = attention_mask[:, -query_length:]
591
+ query_layer, indices_q, cu_seqlens_q, max_seqlen_in_batch_q = unpad_input(query_layer, attention_mask)
592
+
593
+ return (
594
+ query_layer,
595
+ key_layer,
596
+ value_layer,
597
+ indices_q.to(torch.int64),
598
+ (cu_seqlens_q, cu_seqlens_k),
599
+ (max_seqlen_in_batch_q, max_seqlen_in_batch_k),
600
+ )
601
+
602
+
603
+ INTERNLM2_ATTENTION_CLASSES = {
604
+ 'eager': InternLM2Attention,
605
+ 'flash_attention_2': InternLM2FlashAttention2,
606
+ }
607
+
608
+
609
+ # Modified from transformers.model.llama.modeling_llama.LlamaDecoderLayer
610
+ class InternLM2DecoderLayer(nn.Module):
611
+ def __init__(self, config: InternLM2Config):
612
+ super().__init__()
613
+ self.hidden_size = config.hidden_size
614
+
615
+ self.attention = INTERNLM2_ATTENTION_CLASSES[config.attn_implementation](config=config)
616
+
617
+ self.feed_forward = InternLM2MLP(config)
618
+ self.attention_norm = InternLM2RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
619
+ self.ffn_norm = InternLM2RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
620
+
621
+ def forward(
622
+ self,
623
+ hidden_states: torch.Tensor,
624
+ attention_mask: Optional[torch.Tensor] = None,
625
+ position_ids: Optional[torch.LongTensor] = None,
626
+ past_key_value: Optional[Tuple[torch.Tensor]] = None,
627
+ output_attentions: Optional[bool] = False,
628
+ use_cache: Optional[bool] = False,
629
+ **kwargs,
630
+ ) -> Tuple[torch.FloatTensor, Optional[Tuple[torch.FloatTensor, torch.FloatTensor]]]:
631
+ """
632
+ Args:
633
+ hidden_states (`torch.FloatTensor`): input to the layer of shape `(batch, seq_len, embed_dim)`
634
+ attention_mask (`torch.FloatTensor`, *optional*):
635
+ attention mask of size `(batch_size, sequence_length)` if flash attention is used or `(batch_size, 1,
636
+ query_sequence_length, key_sequence_length)` if default attention is used.
637
+ output_attentions (`bool`, *optional*):
638
+ Whether or not to return the attentions tensors of all attention layers. See `attentions` under
639
+ returned tensors for more detail.
640
+ use_cache (`bool`, *optional*):
641
+ If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding
642
+ (see `past_key_values`).
643
+ past_key_value (`Tuple(torch.FloatTensor)`, *optional*): cached past key and value projection states
644
+ """
645
+ if 'padding_mask' in kwargs:
646
+ warnings.warn(
647
+ 'Passing `padding_mask` is deprecated and will be removed in v4.37. '
648
+ 'Please make sure use `attention_mask` instead.`'
649
+ )
650
+
651
+ residual = hidden_states
652
+
653
+ hidden_states = self.attention_norm(hidden_states)
654
+
655
+ # Self Attention
656
+ hidden_states, self_attn_weights, present_key_value = self.attention(
657
+ hidden_states=hidden_states,
658
+ attention_mask=attention_mask,
659
+ position_ids=position_ids,
660
+ past_key_value=past_key_value,
661
+ output_attentions=output_attentions,
662
+ use_cache=use_cache,
663
+ **kwargs,
664
+ )
665
+ hidden_states = residual + hidden_states
666
+
667
+ # Fully Connected
668
+ residual = hidden_states
669
+ hidden_states = self.ffn_norm(hidden_states)
670
+ hidden_states = self.feed_forward(hidden_states)
671
+ hidden_states = residual + hidden_states
672
+
673
+ outputs = (hidden_states,)
674
+
675
+ if output_attentions:
676
+ outputs += (self_attn_weights,)
677
+
678
+ if use_cache:
679
+ outputs += (present_key_value,)
680
+
681
+ return outputs
682
+
683
+
684
+ InternLM2_START_DOCSTRING = r"""
685
+ This model inherits from [`PreTrainedModel`]. Check the superclass documentation for the generic methods the
686
+ library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads
687
+ etc.)
688
+
689
+ This model is also a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass.
690
+ Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
691
+ and behavior.
692
+
693
+ Parameters:
694
+ config ([`InternLM2Config`]):
695
+ Model configuration class with all the parameters of the model. Initializing with a config file does not
696
+ load the weights associated with the model, only the configuration. Check out the
697
+ [`~PreTrainedModel.from_pretrained`] method to load the model weights.
698
+ """
699
+
700
+
701
+ # Copied from transformers.models.llama.modeling_llama.LlamaPreTrainedModel with Llama->InternLM2
702
+ @add_start_docstrings(
703
+ 'The bare InternLM2 Model outputting raw hidden-states without any specific head on top.',
704
+ InternLM2_START_DOCSTRING,
705
+ )
706
+ class InternLM2PreTrainedModel(PreTrainedModel):
707
+ config_class = InternLM2Config
708
+ base_model_prefix = 'model'
709
+ supports_gradient_checkpointing = True
710
+ _no_split_modules = ['InternLM2DecoderLayer']
711
+ _skip_keys_device_placement = 'past_key_values'
712
+
713
+ def _init_weights(self, module):
714
+ std = self.config.initializer_range
715
+ if isinstance(module, nn.Linear):
716
+ module.weight.data.normal_(mean=0.0, std=std)
717
+ if module.bias is not None:
718
+ module.bias.data.zero_()
719
+ elif isinstance(module, nn.Embedding):
720
+ module.weight.data.normal_(mean=0.0, std=std)
721
+ if module.padding_idx is not None:
722
+ module.weight.data[module.padding_idx].zero_()
723
+
724
+
725
+ InternLM2_INPUTS_DOCSTRING = r"""
726
+ Args:
727
+ input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
728
+ Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you provide
729
+ it.
730
+
731
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
732
+ [`PreTrainedTokenizer.__call__`] for details.
733
+
734
+ [What are input IDs?](../glossary#input-ids)
735
+ attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
736
+ Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:
737
+
738
+ - 1 for tokens that are **not masked**,
739
+ - 0 for tokens that are **masked**.
740
+
741
+ [What are attention masks?](../glossary#attention-mask)
742
+
743
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
744
+ [`PreTrainedTokenizer.__call__`] for details.
745
+
746
+ If `past_key_values` is used, optionally only the last `input_ids` have to be input (see
747
+ `past_key_values`).
748
+
749
+ If you want to change padding behavior, you should read [`modeling_opt._prepare_decoder_attention_mask`]
750
+ and modify to your needs. See diagram 1 in [the paper](https://arxiv.org/abs/1910.13461) for more
751
+ information on the default strategy.
752
+
753
+ - 1 indicates the head is **not masked**,
754
+ - 0 indicates the head is **masked**.
755
+ position_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
756
+ Indices of positions of each input sequence tokens in the position embeddings. Selected in the range `[0,
757
+ config.n_positions - 1]`.
758
+
759
+ [What are position IDs?](../glossary#position-ids)
760
+ past_key_values (`tuple(tuple(torch.FloatTensor))`, *optional*, returned when `use_cache=True` is passed or
761
+ when `config.use_cache=True`):
762
+ Tuple of `tuple(torch.FloatTensor)` of length `config.n_layers`, with each tuple having 2 tensors of shape
763
+ `(batch_size, num_heads, sequence_length, embed_size_per_head)`) and 2 additional tensors of shape
764
+ `(batch_size, num_heads, decoder_sequence_length, embed_size_per_head)`.
765
+
766
+ Contains pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention
767
+ blocks) that can be used (see `past_key_values` input) to speed up sequential decoding.
768
+
769
+ If `past_key_values` are used, the user can optionally input only the last `input_ids` (those that don't
770
+ have their past key value states given to this model) of shape `(batch_size, 1)` instead of all `input_ids`
771
+ of shape `(batch_size, sequence_length)`.
772
+ inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
773
+ Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation. This
774
+ is useful if you want more control over how to convert `input_ids` indices into associated vectors than the
775
+ model's internal embedding lookup matrix.
776
+ use_cache (`bool`, *optional*):
777
+ If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see
778
+ `past_key_values`).
779
+ output_attentions (`bool`, *optional*):
780
+ Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned
781
+ tensors for more detail.
782
+ output_hidden_states (`bool`, *optional*):
783
+ Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
784
+ more detail.
785
+ return_dict (`bool`, *optional*):
786
+ Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
787
+ """
788
+
789
+
790
+ # Modified from transformers.model.llama.modeling_llama.LlamaModel
791
+ @add_start_docstrings(
792
+ 'The bare InternLM2 Model outputting raw hidden-states without any specific head on top.',
793
+ InternLM2_START_DOCSTRING,
794
+ )
795
+ class InternLM2Model(InternLM2PreTrainedModel):
796
+ """
797
+ Transformer decoder consisting of *config.num_hidden_layers* layers. Each layer is a [`InternLM2DecoderLayer`]
798
+
799
+ Args:
800
+ config: InternLM2Config
801
+ """
802
+
803
+ _auto_class = 'AutoModel'
804
+
805
+ def __init__(self, config: InternLM2Config):
806
+ super().__init__(config)
807
+ self.padding_idx = config.pad_token_id
808
+ self.vocab_size = config.vocab_size
809
+ self.config = config
810
+ if not has_flash_attn:
811
+ self.config.attn_implementation = 'eager'
812
+ print('Warning: Flash attention is not available, using eager attention instead.')
813
+
814
+ self.tok_embeddings = nn.Embedding(config.vocab_size, config.hidden_size, self.padding_idx)
815
+
816
+ self.layers = nn.ModuleList([InternLM2DecoderLayer(config) for _ in range(config.num_hidden_layers)])
817
+ self.norm = InternLM2RMSNorm(config.hidden_size, eps=config.rms_norm_eps)
818
+
819
+ self.gradient_checkpointing = False
820
+ # Initialize weights and apply final processing
821
+ self.post_init()
822
+
823
+ def get_input_embeddings(self):
824
+ return self.tok_embeddings
825
+
826
+ def set_input_embeddings(self, value):
827
+ self.tok_embeddings = value
828
+
829
+ def _prepare_decoder_attention_mask(self, attention_mask, input_shape, inputs_embeds, past_key_values_length):
830
+ # create causal mask
831
+ # [bsz, seq_len] -> [bsz, 1, tgt_seq_len, src_seq_len]
832
+ combined_attention_mask = None
833
+ if input_shape[-1] > 1:
834
+ combined_attention_mask = _make_causal_mask(
835
+ input_shape,
836
+ inputs_embeds.dtype,
837
+ device=inputs_embeds.device,
838
+ past_key_values_length=past_key_values_length,
839
+ )
840
+
841
+ if attention_mask is not None:
842
+ # [bsz, seq_len] -> [bsz, 1, tgt_seq_len, src_seq_len]
843
+ expanded_attn_mask = _expand_mask(attention_mask, inputs_embeds.dtype, tgt_len=input_shape[-1]).to(
844
+ inputs_embeds.device
845
+ )
846
+ combined_attention_mask = (
847
+ expanded_attn_mask if combined_attention_mask is None else expanded_attn_mask + combined_attention_mask
848
+ )
849
+
850
+ return combined_attention_mask
851
+
852
+ @add_start_docstrings_to_model_forward(InternLM2_INPUTS_DOCSTRING)
853
+ def forward(
854
+ self,
855
+ input_ids: torch.LongTensor = None,
856
+ attention_mask: Optional[torch.Tensor] = None,
857
+ position_ids: Optional[torch.LongTensor] = None,
858
+ past_key_values: Optional[List[torch.FloatTensor]] = None,
859
+ inputs_embeds: Optional[torch.FloatTensor] = None,
860
+ use_cache: Optional[bool] = None,
861
+ output_attentions: Optional[bool] = None,
862
+ output_hidden_states: Optional[bool] = None,
863
+ return_dict: Optional[bool] = None,
864
+ ) -> Union[Tuple, BaseModelOutputWithPast]:
865
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
866
+ output_hidden_states = (
867
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
868
+ )
869
+ use_cache = use_cache if use_cache is not None else self.config.use_cache
870
+
871
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
872
+
873
+ if self.config.attn_implementation == 'flash_attention_2':
874
+ _import_flash_attn()
875
+
876
+ # retrieve input_ids and inputs_embeds
877
+ if input_ids is not None and inputs_embeds is not None:
878
+ raise ValueError('You cannot specify both input_ids and inputs_embeds at the same time')
879
+ elif input_ids is not None:
880
+ batch_size, seq_length = input_ids.shape[:2]
881
+ elif inputs_embeds is not None:
882
+ batch_size, seq_length = inputs_embeds.shape[:2]
883
+ else:
884
+ raise ValueError('You have to specify either input_ids or inputs_embeds')
885
+
886
+ seq_length_with_past = seq_length
887
+ past_key_values_length = 0
888
+ if past_key_values is not None:
889
+ past_key_values_length = past_key_values[0][0].shape[2]
890
+ seq_length_with_past = seq_length_with_past + past_key_values_length
891
+
892
+ if position_ids is None:
893
+ device = input_ids.device if input_ids is not None else inputs_embeds.device
894
+ position_ids = torch.arange(
895
+ past_key_values_length, seq_length + past_key_values_length, dtype=torch.long, device=device
896
+ )
897
+ position_ids = position_ids.unsqueeze(0)
898
+
899
+ if inputs_embeds is None:
900
+ inputs_embeds = self.tok_embeddings(input_ids)
901
+
902
+ if self.config.attn_implementation == 'flash_attention_2':
903
+ # 2d mask is passed through the layers
904
+ attention_mask = attention_mask if (attention_mask is not None and 0 in attention_mask) else None
905
+ else:
906
+ if attention_mask is None:
907
+ attention_mask = torch.ones(
908
+ (batch_size, seq_length_with_past), dtype=torch.bool, device=inputs_embeds.device
909
+ )
910
+ attention_mask = self._prepare_decoder_attention_mask(
911
+ attention_mask, (batch_size, seq_length), inputs_embeds, past_key_values_length
912
+ )
913
+
914
+ # embed positions
915
+ hidden_states = inputs_embeds
916
+
917
+ if self.gradient_checkpointing and self.training:
918
+ if use_cache:
919
+ logger.warning_once(
920
+ '`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`...'
921
+ )
922
+ use_cache = False
923
+
924
+ # decoder layers
925
+ all_hidden_states = () if output_hidden_states else None
926
+ all_self_attns = () if output_attentions else None
927
+ next_decoder_cache = () if use_cache else None
928
+
929
+ for idx, decoder_layer in enumerate(self.layers):
930
+ if output_hidden_states:
931
+ all_hidden_states += (hidden_states,)
932
+
933
+ past_key_value = past_key_values[idx] if past_key_values is not None else None
934
+
935
+ if self.gradient_checkpointing and self.training:
936
+
937
+ def create_custom_forward(module):
938
+ def custom_forward(*inputs):
939
+ # None for past_key_value
940
+ return module(*inputs, output_attentions, None)
941
+
942
+ return custom_forward
943
+
944
+ layer_outputs = torch.utils.checkpoint.checkpoint(
945
+ create_custom_forward(decoder_layer),
946
+ hidden_states,
947
+ attention_mask,
948
+ position_ids,
949
+ None,
950
+ )
951
+ else:
952
+ layer_outputs = decoder_layer(
953
+ hidden_states,
954
+ attention_mask=attention_mask,
955
+ position_ids=position_ids,
956
+ past_key_value=past_key_value,
957
+ output_attentions=output_attentions,
958
+ use_cache=use_cache,
959
+ )
960
+
961
+ hidden_states = layer_outputs[0]
962
+
963
+ if use_cache:
964
+ next_decoder_cache += (layer_outputs[2 if output_attentions else 1],)
965
+
966
+ if output_attentions:
967
+ all_self_attns += (layer_outputs[1],)
968
+
969
+ hidden_states = self.norm(hidden_states)
970
+
971
+ # add hidden states from the last decoder layer
972
+ if output_hidden_states:
973
+ all_hidden_states += (hidden_states,)
974
+
975
+ next_cache = next_decoder_cache if use_cache else None
976
+ if not return_dict:
977
+ return tuple(v for v in [hidden_states, next_cache, all_hidden_states, all_self_attns] if v is not None)
978
+ return BaseModelOutputWithPast(
979
+ last_hidden_state=hidden_states,
980
+ past_key_values=next_cache,
981
+ hidden_states=all_hidden_states,
982
+ attentions=all_self_attns,
983
+ )
984
+
985
+
986
+ # Modified from transformers.model.llama.modeling_llama.LlamaForCausalLM
987
+ class InternLM2ForCausalLM(InternLM2PreTrainedModel):
988
+ _auto_class = 'AutoModelForCausalLM'
989
+
990
+ _tied_weights_keys = ['output.weight']
991
+
992
+ def __init__(self, config):
993
+ super().__init__(config)
994
+ self.model = InternLM2Model(config)
995
+ self.vocab_size = config.vocab_size
996
+ self.output = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
997
+
998
+ # Initialize weights and apply final processing
999
+ self.post_init()
1000
+
1001
+ def get_input_embeddings(self):
1002
+ return self.model.tok_embeddings
1003
+
1004
+ def set_input_embeddings(self, value):
1005
+ self.model.tok_embeddings = value
1006
+
1007
+ def get_output_embeddings(self):
1008
+ return self.output
1009
+
1010
+ def set_output_embeddings(self, new_embeddings):
1011
+ self.output = new_embeddings
1012
+
1013
+ def set_decoder(self, decoder):
1014
+ self.model = decoder
1015
+
1016
+ def get_decoder(self):
1017
+ return self.model
1018
+
1019
+ @add_start_docstrings_to_model_forward(InternLM2_INPUTS_DOCSTRING)
1020
+ @replace_return_docstrings(output_type=CausalLMOutputWithPast, config_class=_CONFIG_FOR_DOC)
1021
+ def forward(
1022
+ self,
1023
+ input_ids: torch.LongTensor = None,
1024
+ attention_mask: Optional[torch.Tensor] = None,
1025
+ position_ids: Optional[torch.LongTensor] = None,
1026
+ past_key_values: Optional[List[torch.FloatTensor]] = None,
1027
+ inputs_embeds: Optional[torch.FloatTensor] = None,
1028
+ labels: Optional[torch.LongTensor] = None,
1029
+ use_cache: Optional[bool] = None,
1030
+ output_attentions: Optional[bool] = None,
1031
+ output_hidden_states: Optional[bool] = None,
1032
+ return_dict: Optional[bool] = None,
1033
+ ) -> Union[Tuple, CausalLMOutputWithPast]:
1034
+ r"""
1035
+ Args:
1036
+ labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
1037
+ Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,
1038
+ config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored
1039
+ (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`.
1040
+
1041
+ Returns:
1042
+
1043
+ Example:
1044
+
1045
+ ```python
1046
+ >>> from transformers import AutoTokenizer, InternLM2ForCausalLM
1047
+
1048
+ >>> model = InternLM2ForCausalLM.from_pretrained(PATH_TO_CONVERTED_WEIGHTS)
1049
+ >>> tokenizer = AutoTokenizer.from_pretrained(PATH_TO_CONVERTED_TOKENIZER)
1050
+
1051
+ >>> prompt = "Hey, are you conscious? Can you talk to me?"
1052
+ >>> inputs = tokenizer(prompt, return_tensors="pt")
1053
+
1054
+ >>> # Generate
1055
+ >>> generate_ids = model.generate(inputs.input_ids, max_length=30)
1056
+ >>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
1057
+ "Hey, are you conscious? Can you talk to me?\nI'm not conscious, but I can talk to you."
1058
+ ```"""
1059
+
1060
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
1061
+ output_hidden_states = (
1062
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
1063
+ )
1064
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
1065
+
1066
+ # decoder outputs consists of (dec_features, layer_state, dec_hidden, dec_attn)
1067
+ outputs = self.model(
1068
+ input_ids=input_ids,
1069
+ attention_mask=attention_mask,
1070
+ position_ids=position_ids,
1071
+ past_key_values=past_key_values,
1072
+ inputs_embeds=inputs_embeds,
1073
+ use_cache=use_cache,
1074
+ output_attentions=output_attentions,
1075
+ output_hidden_states=output_hidden_states,
1076
+ return_dict=return_dict,
1077
+ )
1078
+
1079
+ hidden_states = outputs[0]
1080
+ logits = self.output(hidden_states)
1081
+ logits = logits.float()
1082
+
1083
+ loss = None
1084
+ if labels is not None:
1085
+ # Shift so that tokens < n predict n
1086
+ shift_logits = logits[..., :-1, :].contiguous()
1087
+ shift_labels = labels[..., 1:].contiguous()
1088
+ # Flatten the tokens
1089
+ loss_fct = CrossEntropyLoss()
1090
+ shift_logits = shift_logits.view(-1, self.config.vocab_size)
1091
+ shift_labels = shift_labels.view(-1)
1092
+ # Enable model parallelism
1093
+ shift_labels = shift_labels.to(shift_logits.device)
1094
+ loss = loss_fct(shift_logits, shift_labels)
1095
+
1096
+ if not return_dict:
1097
+ output = (logits,) + outputs[1:]
1098
+ return (loss,) + output if loss is not None else output
1099
+
1100
+ device = input_ids.device if input_ids is not None else inputs_embeds.device
1101
+ output = CausalLMOutputWithPast(
1102
+ loss=loss,
1103
+ logits=logits,
1104
+ past_key_values=outputs.past_key_values,
1105
+ hidden_states=outputs.hidden_states,
1106
+ attentions=outputs.attentions,
1107
+ )
1108
+ output['logits'] = output['logits'].to(device)
1109
+ return output
1110
+
1111
+ def prepare_inputs_for_generation(
1112
+ self, input_ids, past_key_values=None, attention_mask=None, inputs_embeds=None, **kwargs
1113
+ ):
1114
+ if past_key_values is not None:
1115
+ past_length = past_key_values[0][0].shape[2]
1116
+
1117
+ # Some generation methods already pass only the last input ID
1118
+ if input_ids.shape[1] > past_length:
1119
+ remove_prefix_length = past_length
1120
+ else:
1121
+ # Default to old behavior: keep only final ID
1122
+ remove_prefix_length = input_ids.shape[1] - 1
1123
+
1124
+ input_ids = input_ids[:, remove_prefix_length:]
1125
+
1126
+ position_ids = kwargs.get('position_ids', None)
1127
+ if attention_mask is not None and position_ids is None:
1128
+ # create position_ids on the fly for batch generation
1129
+ position_ids = attention_mask.long().cumsum(-1) - 1
1130
+ position_ids.masked_fill_(attention_mask == 0, 1)
1131
+ if past_key_values:
1132
+ position_ids = position_ids[:, -input_ids.shape[1] :]
1133
+
1134
+ # if `inputs_embeds` are passed, we only want to use them in the 1st generation step
1135
+ if inputs_embeds is not None and past_key_values is None:
1136
+ model_inputs = {'inputs_embeds': inputs_embeds}
1137
+ else:
1138
+ model_inputs = {'input_ids': input_ids}
1139
+
1140
+ model_inputs.update(
1141
+ {
1142
+ 'position_ids': position_ids,
1143
+ 'past_key_values': past_key_values,
1144
+ 'use_cache': kwargs.get('use_cache'),
1145
+ 'attention_mask': attention_mask,
1146
+ }
1147
+ )
1148
+ return model_inputs
1149
+
1150
+ @staticmethod
1151
+ def _reorder_cache(past_key_values, beam_idx):
1152
+ reordered_past = ()
1153
+ for layer_past in past_key_values:
1154
+ reordered_past += (
1155
+ tuple(past_state.index_select(0, beam_idx.to(past_state.device)) for past_state in layer_past),
1156
+ )
1157
+ return reordered_past
1158
+
1159
+ def build_inputs(self, tokenizer, query: str, history: List[Tuple[str, str]] = [], meta_instruction=''):
1160
+ if tokenizer.add_bos_token:
1161
+ prompt = ''
1162
+ else:
1163
+ prompt = tokenizer.bos_token
1164
+ if meta_instruction:
1165
+ prompt += f"""<|im_start|>system\n{meta_instruction}<|im_end|>\n"""
1166
+ for record in history:
1167
+ prompt += f"""<|im_start|>user\n{record[0]}<|im_end|>\n<|im_start|>assistant\n{record[1]}<|im_end|>\n"""
1168
+ prompt += f"""<|im_start|>user\n{query}<|im_end|>\n<|im_start|>assistant\n"""
1169
+ return tokenizer([prompt], return_tensors='pt')
1170
+
1171
+ @torch.no_grad()
1172
+ def chat(
1173
+ self,
1174
+ tokenizer,
1175
+ query: str,
1176
+ history: List[Tuple[str, str]] = [],
1177
+ streamer: Optional[BaseStreamer] = None,
1178
+ max_new_tokens: int = 1024,
1179
+ do_sample: bool = True,
1180
+ temperature: float = 0.8,
1181
+ top_p: float = 0.8,
1182
+ meta_instruction: str = 'You are an AI assistant whose name is InternLM (书生·浦语).\n'
1183
+ '- InternLM (书生·浦语) is a conversational language model that is developed by Shanghai AI Laboratory (上海人工智能实验室). It is designed to be helpful, honest, and harmless.\n'
1184
+ '- InternLM (书生·浦语) can understand and communicate fluently in the language chosen by the user such as English and 中文.',
1185
+ **kwargs,
1186
+ ):
1187
+ inputs = self.build_inputs(tokenizer, query, history, meta_instruction)
1188
+ inputs = {k: v.to(self.device) for k, v in inputs.items() if torch.is_tensor(v)}
1189
+ # also add end-of-assistant token in eos token id to avoid unnecessary generation
1190
+ eos_token_id = [tokenizer.eos_token_id, tokenizer.convert_tokens_to_ids(['<|im_end|>'])[0]]
1191
+ outputs = self.generate(
1192
+ **inputs,
1193
+ streamer=streamer,
1194
+ max_new_tokens=max_new_tokens,
1195
+ do_sample=do_sample,
1196
+ temperature=temperature,
1197
+ top_p=top_p,
1198
+ eos_token_id=eos_token_id,
1199
+ **kwargs,
1200
+ )
1201
+ outputs = outputs[0].cpu().tolist()[len(inputs['input_ids'][0]) :]
1202
+ response = tokenizer.decode(outputs, skip_special_tokens=True)
1203
+ response = response.split('<|im_end|>')[0]
1204
+ history = history + [(query, response)]
1205
+ return response, history
1206
+
1207
+ @torch.no_grad()
1208
+ def stream_chat(
1209
+ self,
1210
+ tokenizer,
1211
+ query: str,
1212
+ history: List[Tuple[str, str]] = [],
1213
+ max_new_tokens: int = 1024,
1214
+ do_sample: bool = True,
1215
+ temperature: float = 0.8,
1216
+ top_p: float = 0.8,
1217
+ **kwargs,
1218
+ ):
1219
+ """
1220
+ Return a generator in format: (response, history)
1221
+ Eg.
1222
+ ('你好,有什么可以帮助您的吗', [('你好', '你好,有什么可以帮助您的吗')])
1223
+ ('你好,有什么可以帮助您的吗?', [('你好', '你好,有什么可以帮助您的吗?')])
1224
+ """
1225
+ if BaseStreamer is None:
1226
+ raise ModuleNotFoundError(
1227
+ 'The version of `transformers` is too low. Please make sure '
1228
+ 'that you have installed `transformers>=4.28.0`.'
1229
+ )
1230
+
1231
+ response_queue = queue.Queue(maxsize=20)
1232
+
1233
+ class ChatStreamer(BaseStreamer):
1234
+ def __init__(self, tokenizer) -> None:
1235
+ super().__init__()
1236
+ self.tokenizer = tokenizer
1237
+ self.queue = response_queue
1238
+ self.query = query
1239
+ self.history = history
1240
+ self.response = ''
1241
+ self.cache = []
1242
+ self.received_inputs = False
1243
+ self.queue.put((self.response, history + [(self.query, self.response)]))
1244
+
1245
+ def put(self, value):
1246
+ if len(value.shape) > 1 and value.shape[0] > 1:
1247
+ raise ValueError('ChatStreamer only supports batch size 1')
1248
+ elif len(value.shape) > 1:
1249
+ value = value[0]
1250
+
1251
+ if not self.received_inputs:
1252
+ # The first received value is input_ids, ignore here
1253
+ self.received_inputs = True
1254
+ return
1255
+
1256
+ self.cache.extend(value.tolist())
1257
+ token = self.tokenizer.decode(self.cache, skip_special_tokens=True)
1258
+ if token.strip() != '<|im_end|>':
1259
+ self.response = self.response + token
1260
+ history = self.history + [(self.query, self.response)]
1261
+ self.queue.put((self.response, history))
1262
+ self.cache = []
1263
+ else:
1264
+ self.end()
1265
+
1266
+ def end(self):
1267
+ self.queue.put(None)
1268
+
1269
+ def stream_producer():
1270
+ return self.chat(
1271
+ tokenizer=tokenizer,
1272
+ query=query,
1273
+ streamer=ChatStreamer(tokenizer=tokenizer),
1274
+ history=history,
1275
+ max_new_tokens=max_new_tokens,
1276
+ do_sample=do_sample,
1277
+ temperature=temperature,
1278
+ top_p=top_p,
1279
+ **kwargs,
1280
+ )
1281
+
1282
+ def consumer():
1283
+ producer = threading.Thread(target=stream_producer)
1284
+ producer.start()
1285
+ while True:
1286
+ res = response_queue.get()
1287
+ if res is None:
1288
+ return
1289
+ yield res
1290
+
1291
+ return consumer()
1292
+
1293
+
1294
+ # Copied from transformers.model.llama.modeling_llama.LlamaForSequenceClassification with Llama->InternLM2
1295
+ @add_start_docstrings(
1296
+ """
1297
+ The InternLM2 Model transformer with a sequence classification head on top (linear layer).
1298
+
1299
+ [`InternLM2ForSequenceClassification`] uses the last token in order to do the classification,
1300
+ as other causal models (e.g. GPT-2) do.
1301
+
1302
+ Since it does classification on the last token, it requires to know the position of the last token. If a
1303
+ `pad_token_id` is defined in the configuration, it finds the last token that is not a padding token in each row. If
1304
+ no `pad_token_id` is defined, it simply takes the last value in each row of the batch. Since it cannot guess the
1305
+ padding tokens when `inputs_embeds` are passed instead of `input_ids`, it does the same (take the last value in
1306
+ each row of the batch).
1307
+ """,
1308
+ InternLM2_START_DOCSTRING,
1309
+ )
1310
+ class InternLM2ForSequenceClassification(InternLM2PreTrainedModel):
1311
+ def __init__(self, config):
1312
+ super().__init__(config)
1313
+ self.num_labels = config.num_labels
1314
+ self.model = InternLM2Model(config)
1315
+ self.score = nn.Linear(config.hidden_size, self.num_labels, bias=False)
1316
+
1317
+ # Initialize weights and apply final processing
1318
+ self.post_init()
1319
+
1320
+ def get_input_embeddings(self):
1321
+ return self.model.tok_embeddings
1322
+
1323
+ def set_input_embeddings(self, value):
1324
+ self.model.tok_embeddings = value
1325
+
1326
+ @add_start_docstrings_to_model_forward(InternLM2_INPUTS_DOCSTRING)
1327
+ def forward(
1328
+ self,
1329
+ input_ids: torch.LongTensor = None,
1330
+ attention_mask: Optional[torch.Tensor] = None,
1331
+ position_ids: Optional[torch.LongTensor] = None,
1332
+ past_key_values: Optional[List[torch.FloatTensor]] = None,
1333
+ inputs_embeds: Optional[torch.FloatTensor] = None,
1334
+ labels: Optional[torch.LongTensor] = None,
1335
+ use_cache: Optional[bool] = None,
1336
+ output_attentions: Optional[bool] = None,
1337
+ output_hidden_states: Optional[bool] = None,
1338
+ return_dict: Optional[bool] = None,
1339
+ ) -> Union[Tuple, SequenceClassifierOutputWithPast]:
1340
+ r"""
1341
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
1342
+ Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
1343
+ config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
1344
+ `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
1345
+ """
1346
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
1347
+
1348
+ transformer_outputs = self.model(
1349
+ input_ids,
1350
+ attention_mask=attention_mask,
1351
+ position_ids=position_ids,
1352
+ past_key_values=past_key_values,
1353
+ inputs_embeds=inputs_embeds,
1354
+ use_cache=use_cache,
1355
+ output_attentions=output_attentions,
1356
+ output_hidden_states=output_hidden_states,
1357
+ return_dict=return_dict,
1358
+ )
1359
+ hidden_states = transformer_outputs[0]
1360
+ logits = self.score(hidden_states)
1361
+
1362
+ if input_ids is not None:
1363
+ batch_size = input_ids.shape[0]
1364
+ else:
1365
+ batch_size = inputs_embeds.shape[0]
1366
+
1367
+ if self.config.pad_token_id is None and batch_size != 1:
1368
+ raise ValueError('Cannot handle batch sizes > 1 if no padding token is defined.')
1369
+ if self.config.pad_token_id is None:
1370
+ sequence_lengths = -1
1371
+ else:
1372
+ if input_ids is not None:
1373
+ sequence_lengths = (torch.eq(input_ids, self.config.pad_token_id).int().argmax(-1) - 1).to(
1374
+ logits.device
1375
+ )
1376
+ else:
1377
+ sequence_lengths = -1
1378
+
1379
+ pooled_logits = logits[torch.arange(batch_size, device=logits.device), sequence_lengths]
1380
+
1381
+ loss = None
1382
+ if labels is not None:
1383
+ labels = labels.to(logits.device)
1384
+ if self.config.problem_type is None:
1385
+ if self.num_labels == 1:
1386
+ self.config.problem_type = 'regression'
1387
+ elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
1388
+ self.config.problem_type = 'single_label_classification'
1389
+ else:
1390
+ self.config.problem_type = 'multi_label_classification'
1391
+
1392
+ if self.config.problem_type == 'regression':
1393
+ loss_fct = MSELoss()
1394
+ if self.num_labels == 1:
1395
+ loss = loss_fct(pooled_logits.squeeze(), labels.squeeze())
1396
+ else:
1397
+ loss = loss_fct(pooled_logits, labels)
1398
+ elif self.config.problem_type == 'single_label_classification':
1399
+ loss_fct = CrossEntropyLoss()
1400
+ loss = loss_fct(pooled_logits.view(-1, self.num_labels), labels.view(-1))
1401
+ elif self.config.problem_type == 'multi_label_classification':
1402
+ loss_fct = BCEWithLogitsLoss()
1403
+ loss = loss_fct(pooled_logits, labels)
1404
+ if not return_dict:
1405
+ output = (pooled_logits,) + transformer_outputs[1:]
1406
+ return ((loss,) + output) if loss is not None else output
1407
+
1408
+ return SequenceClassifierOutputWithPast(
1409
+ loss=loss,
1410
+ logits=pooled_logits,
1411
+ past_key_values=transformer_outputs.past_key_values,
1412
+ hidden_states=transformer_outputs.hidden_states,
1413
+ attentions=transformer_outputs.attentions,
1414
+ )
modeling_internvl_chat.py ADDED
@@ -0,0 +1,323 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # --------------------------------------------------------
2
+ # InternVL
3
+ # Copyright (c) 2024 OpenGVLab
4
+ # Licensed under The MIT License [see LICENSE for details]
5
+ # --------------------------------------------------------
6
+ import warnings
7
+ from typing import Any, List, Optional, Tuple, Union
8
+
9
+ import torch.utils.checkpoint
10
+ from torch import nn
11
+ from torch.nn import CrossEntropyLoss
12
+ from transformers import (AutoModel, GenerationConfig, LlamaForCausalLM,
13
+ LlamaTokenizer)
14
+ from transformers.modeling_outputs import CausalLMOutputWithPast
15
+ from transformers.modeling_utils import PreTrainedModel
16
+ from transformers.utils import ModelOutput, logging
17
+
18
+ from .configuration_internvl_chat import InternVLChatConfig
19
+ from .conversation import get_conv_template
20
+ from .modeling_intern_vit import InternVisionModel
21
+ from .modeling_internlm2 import InternLM2ForCausalLM
22
+
23
+ logger = logging.get_logger(__name__)
24
+
25
+
26
+ class InternVLChatModel(PreTrainedModel):
27
+ config_class = InternVLChatConfig
28
+ main_input_name = 'pixel_values'
29
+ _no_split_modules = ['InternVisionModel', 'LlamaDecoderLayer', 'InternLM2DecoderLayer']
30
+
31
+ def __init__(self, config: InternVLChatConfig, vision_model=None, language_model=None):
32
+ super().__init__(config)
33
+
34
+ image_size = config.force_image_size or config.vision_config.image_size
35
+ patch_size = config.vision_config.patch_size
36
+ self.patch_size = patch_size
37
+ self.select_layer = config.select_layer
38
+ self.template = config.template
39
+ self.num_image_token = int((image_size // patch_size) ** 2 * (config.downsample_ratio ** 2))
40
+ self.downsample_ratio = config.downsample_ratio
41
+ self.ps_version = config.ps_version
42
+
43
+ logger.info(f'num_image_token: {self.num_image_token}')
44
+ logger.info(f'ps_version: {self.ps_version}')
45
+ if vision_model is not None:
46
+ self.vision_model = vision_model
47
+ else:
48
+ self.vision_model = InternVisionModel(config.vision_config)
49
+ if language_model is not None:
50
+ self.language_model = language_model
51
+ else:
52
+ if config.llm_config.architectures[0] == 'LlamaForCausalLM':
53
+ self.language_model = LlamaForCausalLM(config.llm_config)
54
+ elif config.llm_config.architectures[0] == 'InternLM2ForCausalLM':
55
+ self.language_model = InternLM2ForCausalLM(config.llm_config)
56
+ else:
57
+ raise NotImplementedError(f'{config.llm_config.architectures[0]} is not implemented.')
58
+
59
+ vit_hidden_size = config.vision_config.hidden_size
60
+ llm_hidden_size = config.llm_config.hidden_size
61
+
62
+ self.mlp1 = nn.Sequential(
63
+ nn.LayerNorm(vit_hidden_size * int(1 / self.downsample_ratio) ** 2),
64
+ nn.Linear(vit_hidden_size * int(1 / self.downsample_ratio) ** 2, llm_hidden_size),
65
+ nn.GELU(),
66
+ nn.Linear(llm_hidden_size, llm_hidden_size)
67
+ )
68
+
69
+ self.img_context_token_id = None
70
+
71
+ def forward(
72
+ self,
73
+ pixel_values: torch.FloatTensor,
74
+ input_ids: torch.LongTensor = None,
75
+ attention_mask: Optional[torch.Tensor] = None,
76
+ position_ids: Optional[torch.LongTensor] = None,
77
+ image_flags: Optional[torch.LongTensor] = None,
78
+ past_key_values: Optional[List[torch.FloatTensor]] = None,
79
+ labels: Optional[torch.LongTensor] = None,
80
+ use_cache: Optional[bool] = None,
81
+ output_attentions: Optional[bool] = None,
82
+ output_hidden_states: Optional[bool] = None,
83
+ return_dict: Optional[bool] = None,
84
+ ) -> Union[Tuple, CausalLMOutputWithPast]:
85
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
86
+
87
+ image_flags = image_flags.squeeze(-1)
88
+ input_embeds = self.language_model.get_input_embeddings()(input_ids)
89
+
90
+ vit_embeds = self.extract_feature(pixel_values)
91
+ vit_embeds = vit_embeds[image_flags == 1]
92
+ vit_batch_size = pixel_values.shape[0]
93
+
94
+ B, N, C = input_embeds.shape
95
+ input_embeds = input_embeds.reshape(B * N, C)
96
+
97
+ if torch.distributed.get_rank() == 0:
98
+ print(f'dynamic ViT batch size: {vit_batch_size}, images per sample: {vit_batch_size / B}, dynamic token length: {N}')
99
+
100
+ input_ids = input_ids.reshape(B * N)
101
+ selected = (input_ids == self.img_context_token_id)
102
+ try:
103
+ input_embeds[selected] = input_embeds[selected] * 0.0 + vit_embeds.reshape(-1, C)
104
+ except Exception as e:
105
+ vit_embeds = vit_embeds.reshape(-1, C)
106
+ print(f'warning: {e}, input_embeds[selected].shape={input_embeds[selected].shape}, '
107
+ f'vit_embeds.shape={vit_embeds.shape}')
108
+ n_token = selected.sum()
109
+ input_embeds[selected] = input_embeds[selected] * 0.0 + vit_embeds[:n_token]
110
+
111
+ input_embeds = input_embeds.reshape(B, N, C)
112
+
113
+ outputs = self.language_model(
114
+ inputs_embeds=input_embeds,
115
+ attention_mask=attention_mask,
116
+ position_ids=position_ids,
117
+ past_key_values=past_key_values,
118
+ use_cache=use_cache,
119
+ output_attentions=output_attentions,
120
+ output_hidden_states=output_hidden_states,
121
+ return_dict=return_dict,
122
+ )
123
+ logits = outputs.logits
124
+
125
+ loss = None
126
+ if labels is not None:
127
+ # Shift so that tokens < n predict n
128
+ shift_logits = logits[..., :-1, :].contiguous()
129
+ shift_labels = labels[..., 1:].contiguous()
130
+ # Flatten the tokens
131
+ loss_fct = CrossEntropyLoss()
132
+ shift_logits = shift_logits.view(-1, self.language_model.config.vocab_size)
133
+ shift_labels = shift_labels.view(-1)
134
+ # Enable model parallelism
135
+ shift_labels = shift_labels.to(shift_logits.device)
136
+ loss = loss_fct(shift_logits, shift_labels)
137
+
138
+ if not return_dict:
139
+ output = (logits,) + outputs[1:]
140
+ return (loss,) + output if loss is not None else output
141
+
142
+ return CausalLMOutputWithPast(
143
+ loss=loss,
144
+ logits=logits,
145
+ past_key_values=outputs.past_key_values,
146
+ hidden_states=outputs.hidden_states,
147
+ attentions=outputs.attentions,
148
+ )
149
+
150
+ def pixel_shuffle(self, x, scale_factor=0.5):
151
+ n, w, h, c = x.size()
152
+ # N, W, H, C --> N, W, H * scale, C // scale
153
+ x = x.view(n, w, int(h * scale_factor), int(c / scale_factor))
154
+ # N, W, H * scale, C // scale --> N, H * scale, W, C // scale
155
+ x = x.permute(0, 2, 1, 3).contiguous()
156
+ # N, H * scale, W, C // scale --> N, H * scale, W * scale, C // (scale ** 2)
157
+ x = x.view(n, int(h * scale_factor), int(w * scale_factor),
158
+ int(c / (scale_factor * scale_factor)))
159
+ if self.ps_version == 'v1':
160
+ warnings.warn("In ps_version 'v1', the height and width have not been swapped back, "
161
+ 'which results in a transposed image.')
162
+ else:
163
+ x = x.permute(0, 2, 1, 3).contiguous()
164
+ return x
165
+
166
+ def extract_feature(self, pixel_values):
167
+ if self.select_layer == -1:
168
+ vit_embeds = self.vision_model(
169
+ pixel_values=pixel_values,
170
+ output_hidden_states=False,
171
+ return_dict=True).last_hidden_state
172
+ else:
173
+ vit_embeds = self.vision_model(
174
+ pixel_values=pixel_values,
175
+ output_hidden_states=True,
176
+ return_dict=True).hidden_states[self.select_layer]
177
+ vit_embeds = vit_embeds[:, 1:, :]
178
+
179
+ h = w = int(vit_embeds.shape[1] ** 0.5)
180
+ vit_embeds = vit_embeds.reshape(vit_embeds.shape[0], h, w, -1)
181
+ vit_embeds = self.pixel_shuffle(vit_embeds, scale_factor=self.downsample_ratio)
182
+ vit_embeds = vit_embeds.reshape(vit_embeds.shape[0], -1, vit_embeds.shape[-1])
183
+ vit_embeds = self.mlp1(vit_embeds)
184
+ return vit_embeds
185
+
186
+ def batch_chat(self, tokenizer, pixel_values, num_patches_list, questions, generation_config, history=None,
187
+ return_history=False, IMG_START_TOKEN='<img>', IMG_END_TOKEN='</img>',
188
+ IMG_CONTEXT_TOKEN='<IMG_CONTEXT>', verbose=False):
189
+ if history is not None or return_history:
190
+ print('Now multi-turn chat is not supported in batch_chat.')
191
+ raise NotImplementedError
192
+ img_context_token_id = tokenizer.convert_tokens_to_ids(IMG_CONTEXT_TOKEN)
193
+ self.img_context_token_id = img_context_token_id
194
+
195
+ from .conversation import get_conv_template
196
+
197
+ queries = []
198
+ if verbose:
199
+ image_bs = pixel_values.shape[0]
200
+ print(f'dynamic ViT batch size: {image_bs}, num_patches_list: {num_patches_list}')
201
+ for idx, num_patches in enumerate(num_patches_list):
202
+ image_token = IMG_START_TOKEN + IMG_CONTEXT_TOKEN * self.num_image_token * num_patches + IMG_END_TOKEN
203
+ question = image_token + '\n' + questions[idx]
204
+ template = get_conv_template(self.template)
205
+ template.append_message(template.roles[0], question)
206
+ template.append_message(template.roles[1], None)
207
+ query = template.get_prompt()
208
+ queries.append(query)
209
+ tokenizer.padding_side = 'left'
210
+ model_inputs = tokenizer(queries, return_tensors='pt', padding=True)
211
+ input_ids = model_inputs['input_ids'].cuda()
212
+ attention_mask = model_inputs['attention_mask'].cuda()
213
+ eos_token_id = tokenizer.convert_tokens_to_ids(template.sep)
214
+ generation_config['eos_token_id'] = eos_token_id
215
+
216
+ generation_output = self.generate(
217
+ pixel_values=pixel_values,
218
+ input_ids=input_ids,
219
+ attention_mask=attention_mask,
220
+ **generation_config
221
+ )
222
+ responses = tokenizer.batch_decode(generation_output, skip_special_tokens=True)
223
+ responses = [response.split(template.sep)[0].strip() for response in responses]
224
+ return responses
225
+
226
+ def chat(self, tokenizer, pixel_values, question, generation_config, history=None, return_history=False,
227
+ num_patches_list=None, IMG_START_TOKEN='<img>', IMG_END_TOKEN='</img>', IMG_CONTEXT_TOKEN='<IMG_CONTEXT>',
228
+ verbose=False):
229
+
230
+ if history is None and pixel_values is not None and '<image>' not in question:
231
+ question = '<image>\n' + question
232
+
233
+ if num_patches_list is None:
234
+ num_patches_list = [pixel_values.shape[0]] if pixel_values is not None else []
235
+ assert pixel_values is None or len(pixel_values) == sum(num_patches_list)
236
+
237
+ img_context_token_id = tokenizer.convert_tokens_to_ids(IMG_CONTEXT_TOKEN)
238
+ self.img_context_token_id = img_context_token_id
239
+
240
+ template = get_conv_template(self.template)
241
+ eos_token_id = tokenizer.convert_tokens_to_ids(template.sep)
242
+
243
+ history = [] if history is None else history
244
+ for (old_question, old_answer) in history:
245
+ template.append_message(template.roles[0], old_question)
246
+ template.append_message(template.roles[1], old_answer)
247
+ template.append_message(template.roles[0], question)
248
+ template.append_message(template.roles[1], None)
249
+ query = template.get_prompt()
250
+
251
+ if verbose and pixel_values is not None:
252
+ image_bs = pixel_values.shape[0]
253
+ print(f'dynamic ViT batch size: {image_bs}')
254
+
255
+ for num_patches in num_patches_list:
256
+ image_tokens = IMG_START_TOKEN + IMG_CONTEXT_TOKEN * self.num_image_token * num_patches + IMG_END_TOKEN
257
+ query = query.replace('<image>', image_tokens, 1)
258
+
259
+ model_inputs = tokenizer(query, return_tensors='pt')
260
+ input_ids = model_inputs['input_ids'].cuda()
261
+ attention_mask = model_inputs['attention_mask'].cuda()
262
+ generation_config['eos_token_id'] = eos_token_id
263
+ generation_output = self.generate(
264
+ pixel_values=pixel_values,
265
+ input_ids=input_ids,
266
+ attention_mask=attention_mask,
267
+ **generation_config
268
+ )
269
+ response = tokenizer.batch_decode(generation_output, skip_special_tokens=True)[0]
270
+ response = response.split(template.sep)[0].strip()
271
+ history.append((question, response))
272
+ if return_history:
273
+ return response, history
274
+ else:
275
+ query_to_print = query.replace(IMG_CONTEXT_TOKEN, '')
276
+ query_to_print = query_to_print.replace(f'{IMG_START_TOKEN}{IMG_END_TOKEN}', '<image>')
277
+ if verbose:
278
+ print(query_to_print, response)
279
+ return response
280
+
281
+ @torch.no_grad()
282
+ def generate(
283
+ self,
284
+ pixel_values: Optional[torch.FloatTensor] = None,
285
+ input_ids: Optional[torch.FloatTensor] = None,
286
+ attention_mask: Optional[torch.LongTensor] = None,
287
+ visual_features: Optional[torch.FloatTensor] = None,
288
+ generation_config: Optional[GenerationConfig] = None,
289
+ output_hidden_states: Optional[bool] = None,
290
+ return_dict: Optional[bool] = None,
291
+ **generate_kwargs,
292
+ ) -> torch.LongTensor:
293
+
294
+ assert self.img_context_token_id is not None
295
+ if pixel_values is not None:
296
+ if visual_features is not None:
297
+ vit_embeds = visual_features
298
+ else:
299
+ vit_embeds = self.extract_feature(pixel_values)
300
+ input_embeds = self.language_model.get_input_embeddings()(input_ids)
301
+ B, N, C = input_embeds.shape
302
+ input_embeds = input_embeds.reshape(B * N, C)
303
+
304
+ input_ids = input_ids.reshape(B * N)
305
+ selected = (input_ids == self.img_context_token_id)
306
+ assert selected.sum() != 0
307
+ input_embeds[selected] = vit_embeds.reshape(-1, C).to(input_embeds.device)
308
+
309
+ input_embeds = input_embeds.reshape(B, N, C)
310
+ else:
311
+ input_embeds = self.language_model.get_input_embeddings()(input_ids)
312
+
313
+ outputs = self.language_model.generate(
314
+ inputs_embeds=input_embeds,
315
+ attention_mask=attention_mask,
316
+ generation_config=generation_config,
317
+ output_hidden_states=output_hidden_states,
318
+ return_dict=return_dict,
319
+ use_cache=True,
320
+ **generate_kwargs,
321
+ )
322
+
323
+ return outputs
special_tokens_map.json ADDED
@@ -0,0 +1,47 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "additional_special_tokens": [
3
+ "<|im_start|>",
4
+ "<|im_end|>",
5
+ "<|action_start|>",
6
+ "<|action_end|>",
7
+ "<|interpreter|>",
8
+ "<|plugin|>",
9
+ "<img>",
10
+ "</img>",
11
+ "<IMG_CONTEXT>",
12
+ "<quad>",
13
+ "</quad>",
14
+ "<ref>",
15
+ "</ref>",
16
+ "<box>",
17
+ "</box>"
18
+ ],
19
+ "bos_token": {
20
+ "content": "<s>",
21
+ "lstrip": false,
22
+ "normalized": false,
23
+ "rstrip": false,
24
+ "single_word": false
25
+ },
26
+ "eos_token": {
27
+ "content": "</s>",
28
+ "lstrip": false,
29
+ "normalized": false,
30
+ "rstrip": false,
31
+ "single_word": false
32
+ },
33
+ "pad_token": {
34
+ "content": "</s>",
35
+ "lstrip": false,
36
+ "normalized": false,
37
+ "rstrip": false,
38
+ "single_word": false
39
+ },
40
+ "unk_token": {
41
+ "content": "<unk>",
42
+ "lstrip": false,
43
+ "normalized": false,
44
+ "rstrip": false,
45
+ "single_word": false
46
+ }
47
+ }
tokenization_internlm2.py ADDED
@@ -0,0 +1,235 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Copyright (c) The InternLM team and The HuggingFace Inc. team. All rights reserved.
2
+ #
3
+ # This code is based on transformers/src/transformers/models/llama/tokenization_llama.py
4
+ #
5
+ # Licensed under the Apache License, Version 2.0 (the "License");
6
+ # you may not use this file except in compliance with the License.
7
+ # You may obtain a copy of the License at
8
+ #
9
+ # http://www.apache.org/licenses/LICENSE-2.0
10
+ #
11
+ # Unless required by applicable law or agreed to in writing, software
12
+ # distributed under the License is distributed on an "AS IS" BASIS,
13
+ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14
+ # See the License for the specific language governing permissions and
15
+ # limitations under the License.
16
+
17
+ """Tokenization classes for InternLM."""
18
+ import os
19
+ from shutil import copyfile
20
+ from typing import Any, Dict, List, Optional, Tuple
21
+
22
+ import sentencepiece as spm
23
+ from transformers.tokenization_utils import PreTrainedTokenizer
24
+ from transformers.utils import logging
25
+
26
+ logger = logging.get_logger(__name__)
27
+
28
+ VOCAB_FILES_NAMES = {'vocab_file': './tokenizer.model'}
29
+
30
+ PRETRAINED_VOCAB_FILES_MAP = {}
31
+
32
+
33
+ # Modified from transformers.model.llama.tokenization_llama.LlamaTokenizer
34
+ class InternLM2Tokenizer(PreTrainedTokenizer):
35
+ """
36
+ Construct a InternLM2 tokenizer. Based on byte-level Byte-Pair-Encoding.
37
+
38
+ Args:
39
+ vocab_file (`str`):
40
+ Path to the vocabulary file.
41
+ """
42
+
43
+ vocab_files_names = VOCAB_FILES_NAMES
44
+ pretrained_vocab_files_map = PRETRAINED_VOCAB_FILES_MAP
45
+ model_input_names = ['input_ids', 'attention_mask']
46
+ _auto_class = 'AutoTokenizer'
47
+
48
+ def __init__(
49
+ self,
50
+ vocab_file,
51
+ unk_token='<unk>',
52
+ bos_token='<s>',
53
+ eos_token='</s>',
54
+ pad_token='</s>',
55
+ sp_model_kwargs: Optional[Dict[str, Any]] = None,
56
+ add_bos_token=True,
57
+ add_eos_token=False,
58
+ decode_with_prefix_space=False,
59
+ clean_up_tokenization_spaces=False,
60
+ **kwargs,
61
+ ):
62
+ self.sp_model_kwargs = {} if sp_model_kwargs is None else sp_model_kwargs
63
+ self.vocab_file = vocab_file
64
+ self.add_bos_token = add_bos_token
65
+ self.add_eos_token = add_eos_token
66
+ self.decode_with_prefix_space = decode_with_prefix_space
67
+ self.sp_model = spm.SentencePieceProcessor(**self.sp_model_kwargs)
68
+ self.sp_model.Load(vocab_file)
69
+ self._no_prefix_space_tokens = None
70
+ super().__init__(
71
+ bos_token=bos_token,
72
+ eos_token=eos_token,
73
+ unk_token=unk_token,
74
+ pad_token=pad_token,
75
+ clean_up_tokenization_spaces=clean_up_tokenization_spaces,
76
+ **kwargs,
77
+ )
78
+
79
+ @property
80
+ def no_prefix_space_tokens(self):
81
+ if self._no_prefix_space_tokens is None:
82
+ vocab = self.convert_ids_to_tokens(list(range(self.vocab_size)))
83
+ self._no_prefix_space_tokens = {i for i, tok in enumerate(vocab) if not tok.startswith('▁')}
84
+ return self._no_prefix_space_tokens
85
+
86
+ @property
87
+ def vocab_size(self):
88
+ """Returns vocab size"""
89
+ return self.sp_model.get_piece_size()
90
+
91
+ @property
92
+ def bos_token_id(self) -> Optional[int]:
93
+ return self.sp_model.bos_id()
94
+
95
+ @property
96
+ def eos_token_id(self) -> Optional[int]:
97
+ return self.sp_model.eos_id()
98
+
99
+ def get_vocab(self):
100
+ """Returns vocab as a dict"""
101
+ vocab = {self.convert_ids_to_tokens(i): i for i in range(self.vocab_size)}
102
+ vocab.update(self.added_tokens_encoder)
103
+ return vocab
104
+
105
+ def _tokenize(self, text):
106
+ """Returns a tokenized string."""
107
+ return self.sp_model.encode(text, out_type=str)
108
+
109
+ def _convert_token_to_id(self, token):
110
+ """Converts a token (str) in an id using the vocab."""
111
+ return self.sp_model.piece_to_id(token)
112
+
113
+ def _convert_id_to_token(self, index):
114
+ """Converts an index (integer) in a token (str) using the vocab."""
115
+ token = self.sp_model.IdToPiece(index)
116
+ return token
117
+
118
+ def _maybe_add_prefix_space(self, tokens, decoded):
119
+ if tokens and tokens[0] not in self.no_prefix_space_tokens:
120
+ return ' ' + decoded
121
+ else:
122
+ return decoded
123
+
124
+ def convert_tokens_to_string(self, tokens):
125
+ """Converts a sequence of tokens (string) in a single string."""
126
+ current_sub_tokens = []
127
+ out_string = ''
128
+ prev_is_special = False
129
+ for token in tokens:
130
+ # make sure that special tokens are not decoded using sentencepiece model
131
+ if token in self.all_special_tokens:
132
+ if not prev_is_special:
133
+ out_string += ' '
134
+ out_string += self.sp_model.decode(current_sub_tokens) + token
135
+ prev_is_special = True
136
+ current_sub_tokens = []
137
+ else:
138
+ current_sub_tokens.append(token)
139
+ prev_is_special = False
140
+ out_string += self.sp_model.decode(current_sub_tokens)
141
+ out_string = self.clean_up_tokenization(out_string)
142
+ out_string = self._maybe_add_prefix_space(tokens=tokens, decoded=out_string)
143
+ return out_string[1:]
144
+
145
+ def save_vocabulary(self, save_directory, filename_prefix: Optional[str] = None) -> Tuple[str]:
146
+ """
147
+ Save the vocabulary and special tokens file to a directory.
148
+
149
+ Args:
150
+ save_directory (`str`):
151
+ The directory in which to save the vocabulary.
152
+
153
+ Returns:
154
+ `Tuple(str)`: Paths to the files saved.
155
+ """
156
+ if not os.path.isdir(save_directory):
157
+ logger.error(f'Vocabulary path ({save_directory}) should be a directory')
158
+ return
159
+ out_vocab_file = os.path.join(
160
+ save_directory, (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file']
161
+ )
162
+
163
+ if os.path.abspath(self.vocab_file) != os.path.abspath(out_vocab_file) and os.path.isfile(self.vocab_file):
164
+ copyfile(self.vocab_file, out_vocab_file)
165
+ elif not os.path.isfile(self.vocab_file):
166
+ with open(out_vocab_file, 'wb') as fi:
167
+ content_spiece_model = self.sp_model.serialized_model_proto()
168
+ fi.write(content_spiece_model)
169
+
170
+ return (out_vocab_file,)
171
+
172
+ def build_inputs_with_special_tokens(self, token_ids_0, token_ids_1=None):
173
+ if self.add_bos_token:
174
+ bos_token_ids = [self.bos_token_id]
175
+ else:
176
+ bos_token_ids = []
177
+
178
+ output = bos_token_ids + token_ids_0
179
+
180
+ if token_ids_1 is not None:
181
+ output = output + token_ids_1
182
+
183
+ if self.add_eos_token:
184
+ output = output + [self.eos_token_id]
185
+
186
+ return output
187
+
188
+ def get_special_tokens_mask(
189
+ self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None, already_has_special_tokens: bool = False
190
+ ) -> List[int]:
191
+ """
192
+ Retrieve sequence ids from a token list that has no special tokens added. This method is called when adding
193
+ special tokens using the tokenizer `prepare_for_model` method.
194
+
195
+ Args:
196
+ token_ids_0 (`List[int]`):
197
+ List of IDs.
198
+ token_ids_1 (`List[int]`, *optional*):
199
+ Optional second list of IDs for sequence pairs.
200
+ already_has_special_tokens (`bool`, *optional*, defaults to `False`):
201
+ Whether or not the token list is already formatted with special tokens for the model.
202
+
203
+ Returns:
204
+ `List[int]`: A list of integers in the range [0, 1]: 1 for a special token, 0 for a sequence token.
205
+ """
206
+ if already_has_special_tokens:
207
+ return super().get_special_tokens_mask(
208
+ token_ids_0=token_ids_0, token_ids_1=token_ids_1, already_has_special_tokens=True
209
+ )
210
+
211
+ if token_ids_1 is None:
212
+ return [1] + ([0] * len(token_ids_0)) + [1]
213
+ return [1] + ([0] * len(token_ids_0)) + [1, 1] + ([0] * len(token_ids_1)) + [1]
214
+
215
+ def create_token_type_ids_from_sequences(
216
+ self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None
217
+ ) -> List[int]:
218
+ """
219
+ Create a mask from the two sequences passed to be used in a sequence-pair classification task. T5 does not make
220
+ use of token type ids, therefore a list of zeros is returned.
221
+
222
+ Args:
223
+ token_ids_0 (`List[int]`):
224
+ List of IDs.
225
+ token_ids_1 (`List[int]`, *optional*):
226
+ Optional second list of IDs for sequence pairs.
227
+
228
+ Returns:
229
+ `List[int]`: List of zeros.
230
+ """
231
+ eos = [self.eos_token_id]
232
+
233
+ if token_ids_1 is None:
234
+ return len(token_ids_0 + eos) * [0]
235
+ return len(token_ids_0 + eos + token_ids_1 + eos) * [0]
tokenizer.model ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:f868398fc4e05ee1e8aeba95ddf18ddcc45b8bce55d5093bead5bbf80429b48b
3
+ size 1477754
tokenizer_config.json ADDED
@@ -0,0 +1,179 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "added_tokens_decoder": {
3
+ "0": {
4
+ "content": "<unk>",
5
+ "lstrip": false,
6
+ "normalized": false,
7
+ "rstrip": false,
8
+ "single_word": false,
9
+ "special": true
10
+ },
11
+ "1": {
12
+ "content": "<s>",
13
+ "lstrip": false,
14
+ "normalized": false,
15
+ "rstrip": false,
16
+ "single_word": false,
17
+ "special": true
18
+ },
19
+ "2": {
20
+ "content": "</s>",
21
+ "lstrip": false,
22
+ "normalized": false,
23
+ "rstrip": false,
24
+ "single_word": false,
25
+ "special": true
26
+ },
27
+ "92538": {
28
+ "content": "<|plugin|>",
29
+ "lstrip": false,
30
+ "normalized": false,
31
+ "rstrip": false,
32
+ "single_word": false,
33
+ "special": true
34
+ },
35
+ "92539": {
36
+ "content": "<|interpreter|>",
37
+ "lstrip": false,
38
+ "normalized": false,
39
+ "rstrip": false,
40
+ "single_word": false,
41
+ "special": true
42
+ },
43
+ "92540": {
44
+ "content": "<|action_end|>",
45
+ "lstrip": false,
46
+ "normalized": false,
47
+ "rstrip": false,
48
+ "single_word": false,
49
+ "special": true
50
+ },
51
+ "92541": {
52
+ "content": "<|action_start|>",
53
+ "lstrip": false,
54
+ "normalized": false,
55
+ "rstrip": false,
56
+ "single_word": false,
57
+ "special": true
58
+ },
59
+ "92542": {
60
+ "content": "<|im_end|>",
61
+ "lstrip": false,
62
+ "normalized": false,
63
+ "rstrip": false,
64
+ "single_word": false,
65
+ "special": true
66
+ },
67
+ "92543": {
68
+ "content": "<|im_start|>",
69
+ "lstrip": false,
70
+ "normalized": false,
71
+ "rstrip": false,
72
+ "single_word": false,
73
+ "special": true
74
+ },
75
+ "92544": {
76
+ "content": "<img>",
77
+ "lstrip": false,
78
+ "normalized": false,
79
+ "rstrip": false,
80
+ "single_word": false,
81
+ "special": true
82
+ },
83
+ "92545": {
84
+ "content": "</img>",
85
+ "lstrip": false,
86
+ "normalized": false,
87
+ "rstrip": false,
88
+ "single_word": false,
89
+ "special": true
90
+ },
91
+ "92546": {
92
+ "content": "<IMG_CONTEXT>",
93
+ "lstrip": false,
94
+ "normalized": false,
95
+ "rstrip": false,
96
+ "single_word": false,
97
+ "special": true
98
+ },
99
+ "92547": {
100
+ "content": "<quad>",
101
+ "lstrip": false,
102
+ "normalized": false,
103
+ "rstrip": false,
104
+ "single_word": false,
105
+ "special": true
106
+ },
107
+ "92548": {
108
+ "content": "</quad>",
109
+ "lstrip": false,
110
+ "normalized": false,
111
+ "rstrip": false,
112
+ "single_word": false,
113
+ "special": true
114
+ },
115
+ "92549": {
116
+ "content": "<ref>",
117
+ "lstrip": false,
118
+ "normalized": false,
119
+ "rstrip": false,
120
+ "single_word": false,
121
+ "special": true
122
+ },
123
+ "92550": {
124
+ "content": "</ref>",
125
+ "lstrip": false,
126
+ "normalized": false,
127
+ "rstrip": false,
128
+ "single_word": false,
129
+ "special": true
130
+ },
131
+ "92551": {
132
+ "content": "<box>",
133
+ "lstrip": false,
134
+ "normalized": false,
135
+ "rstrip": false,
136
+ "single_word": false,
137
+ "special": true
138
+ },
139
+ "92552": {
140
+ "content": "</box>",
141
+ "lstrip": false,
142
+ "normalized": false,
143
+ "rstrip": false,
144
+ "single_word": false,
145
+ "special": true
146
+ }
147
+ },
148
+ "additional_special_tokens": [
149
+ "<|im_start|>",
150
+ "<|im_end|>",
151
+ "<|action_start|>",
152
+ "<|action_end|>",
153
+ "<|interpreter|>",
154
+ "<|plugin|>",
155
+ "<img>",
156
+ "</img>",
157
+ "<IMG_CONTEXT>",
158
+ "<quad>",
159
+ "</quad>",
160
+ "<ref>",
161
+ "</ref>",
162
+ "<box>",
163
+ "</box>"
164
+ ],
165
+ "auto_map": {
166
+ "AutoTokenizer": [
167
+ "tokenization_internlm2.InternLM2Tokenizer",
168
+ null
169
+ ]
170
+ },
171
+ "bos_token": "<s>",
172
+ "chat_template": "{{ bos_token }}{% for message in messages %}{{'<|im_start|>' + message['role'] + '\n' + message['content'] + '<|im_end|>' + '\n'}}{% endfor %}{% if add_generation_prompt %}{{ '<|im_start|>assistant\n' }}{% endif %}",
173
+ "clean_up_tokenization_spaces": false,
174
+ "eos_token": "</s>",
175
+ "model_max_length": 8192,
176
+ "pad_token": "</s>",
177
+ "tokenizer_class": "InternLM2Tokenizer",
178
+ "unk_token": "<unk>"
179
+ }