yuewang-sf commited on
Commit
6a9207a
1 Parent(s): 61acd92

Upload model files

Browse files
added_tokens.json ADDED
@@ -0,0 +1,40 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "\t\t": 50294,
3
+ "\t\t\t": 50293,
4
+ "\t\t\t\t": 50292,
5
+ "\t\t\t\t\t": 50291,
6
+ "\t\t\t\t\t\t": 50290,
7
+ "\t\t\t\t\t\t\t": 50289,
8
+ "\t\t\t\t\t\t\t\t": 50288,
9
+ "\t\t\t\t\t\t\t\t\t": 50287,
10
+ " ": 50286,
11
+ " ": 50285,
12
+ " ": 50284,
13
+ " ": 50283,
14
+ " ": 50282,
15
+ " ": 50281,
16
+ " ": 50280,
17
+ " ": 50279,
18
+ " ": 50278,
19
+ " ": 50277,
20
+ " ": 50276,
21
+ " ": 50275,
22
+ " ": 50274,
23
+ " ": 50273,
24
+ " ": 50272,
25
+ " ": 50271,
26
+ " ": 50270,
27
+ " ": 50269,
28
+ " ": 50268,
29
+ " ": 50267,
30
+ " ": 50266,
31
+ " ": 50265,
32
+ " ": 50264,
33
+ " ": 50263,
34
+ " ": 50262,
35
+ " ": 50261,
36
+ " ": 50260,
37
+ " ": 50259,
38
+ " ": 50258,
39
+ " ": 50257
40
+ }
config.json ADDED
@@ -0,0 +1,182 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "_name_or_path": "codet5p-6b",
3
+ "architectures": [
4
+ "CodeT5pEncoderDecoderModel"
5
+ ],
6
+ "decoder": {
7
+ "_name_or_path": "codet5p-6b-decoder",
8
+ "activation_function": "gelu_new",
9
+ "add_cross_attention": true,
10
+ "architectures": [
11
+ "CodeT5pForCausalLM"
12
+ ],
13
+ "attn_pdrop": 0.0,
14
+ "bad_words_ids": null,
15
+ "bos_token_id": 1,
16
+ "chunk_size_feed_forward": 0,
17
+ "cross_attention_hidden_size": null,
18
+ "decoder_start_token_id": null,
19
+ "diversity_penalty": 0.0,
20
+ "do_sample": false,
21
+ "early_stopping": false,
22
+ "embd_pdrop": 0.0,
23
+ "encoder_no_repeat_ngram_size": 0,
24
+ "eos_token_id": 50256,
25
+ "exponential_decay_length_penalty": null,
26
+ "finetuning_task": null,
27
+ "forced_bos_token_id": null,
28
+ "forced_eos_token_id": null,
29
+ "gradient_checkpointing": false,
30
+ "id2label": {
31
+ "0": "LABEL_0",
32
+ "1": "LABEL_1"
33
+ },
34
+ "initializer_range": 0.02,
35
+ "is_decoder": true,
36
+ "is_encoder_decoder": false,
37
+ "label2id": {
38
+ "LABEL_0": 0,
39
+ "LABEL_1": 1
40
+ },
41
+ "layer_norm_epsilon": 1e-05,
42
+ "length_penalty": 1.0,
43
+ "max_length": 20,
44
+ "min_length": 0,
45
+ "model_type": "codet5p_module",
46
+ "n_ctx": 2048,
47
+ "n_embd": 4096,
48
+ "n_head": 16,
49
+ "n_inner": null,
50
+ "n_layer": 33,
51
+ "n_positions": 2048,
52
+ "no_repeat_ngram_size": 0,
53
+ "num_beam_groups": 1,
54
+ "num_beams": 1,
55
+ "num_return_sequences": 1,
56
+ "output_attentions": false,
57
+ "output_hidden_states": false,
58
+ "output_scores": false,
59
+ "pad_token_id": null,
60
+ "prefix": null,
61
+ "problem_type": null,
62
+ "pruned_heads": {},
63
+ "remove_invalid_values": false,
64
+ "repetition_penalty": 1.0,
65
+ "resid_pdrop": 0.0,
66
+ "return_dict": true,
67
+ "return_dict_in_generate": false,
68
+ "rotary_dim": 64,
69
+ "scale_attn_weights": true,
70
+ "sep_token_id": null,
71
+ "summary_activation": null,
72
+ "summary_first_dropout": 0.1,
73
+ "summary_proj_to_labels": true,
74
+ "summary_type": "cls_index",
75
+ "summary_use_proj": true,
76
+ "task_specific_params": null,
77
+ "temperature": 1.0,
78
+ "tf_legacy_loss": false,
79
+ "tie_encoder_decoder": false,
80
+ "tie_word_embeddings": false,
81
+ "tokenizer_class": "GPT2Tokenizer",
82
+ "top_k": 50,
83
+ "top_p": 1.0,
84
+ "torch_dtype": "float16",
85
+ "torchscript": false,
86
+ "transformers_version": "4.21.3",
87
+ "typical_p": 1.0,
88
+ "use_bfloat16": false,
89
+ "use_cache": true,
90
+ "vocab_size": 51200
91
+ },
92
+ "encoder": {
93
+ "_name_or_path": "codet5p-350m-encoder",
94
+ "activation_function": "gelu_new",
95
+ "add_cross_attention": false,
96
+ "architectures": [
97
+ "CodeT5pModel"
98
+ ],
99
+ "attn_pdrop": 0.0,
100
+ "bad_words_ids": null,
101
+ "bos_token_id": 1,
102
+ "chunk_size_feed_forward": 0,
103
+ "cross_attention_hidden_size": null,
104
+ "decoder_start_token_id": null,
105
+ "diversity_penalty": 0.0,
106
+ "do_sample": false,
107
+ "early_stopping": false,
108
+ "embd_pdrop": 0.0,
109
+ "encoder_no_repeat_ngram_size": 0,
110
+ "eos_token_id": 50256,
111
+ "exponential_decay_length_penalty": null,
112
+ "finetuning_task": null,
113
+ "forced_bos_token_id": null,
114
+ "forced_eos_token_id": null,
115
+ "gradient_checkpointing": false,
116
+ "id2label": {
117
+ "0": "LABEL_0",
118
+ "1": "LABEL_1"
119
+ },
120
+ "initializer_range": 0.02,
121
+ "is_decoder": false,
122
+ "is_encoder_decoder": false,
123
+ "label2id": {
124
+ "LABEL_0": 0,
125
+ "LABEL_1": 1
126
+ },
127
+ "layer_norm_epsilon": 1e-05,
128
+ "length_penalty": 1.0,
129
+ "max_length": 20,
130
+ "min_length": 0,
131
+ "model_type": "codet5p_module",
132
+ "n_ctx": 2048,
133
+ "n_embd": 1024,
134
+ "n_head": 16,
135
+ "n_inner": null,
136
+ "n_layer": 20,
137
+ "n_positions": 2048,
138
+ "no_repeat_ngram_size": 0,
139
+ "num_beam_groups": 1,
140
+ "num_beams": 1,
141
+ "num_return_sequences": 1,
142
+ "output_attentions": false,
143
+ "output_hidden_states": false,
144
+ "output_scores": false,
145
+ "pad_token_id": null,
146
+ "prefix": null,
147
+ "problem_type": null,
148
+ "pruned_heads": {},
149
+ "remove_invalid_values": false,
150
+ "repetition_penalty": 1.0,
151
+ "resid_pdrop": 0.0,
152
+ "return_dict": true,
153
+ "return_dict_in_generate": false,
154
+ "rotary_dim": 32,
155
+ "scale_attn_weights": true,
156
+ "sep_token_id": null,
157
+ "summary_activation": null,
158
+ "summary_first_dropout": 0.1,
159
+ "summary_proj_to_labels": true,
160
+ "summary_type": "cls_index",
161
+ "summary_use_proj": true,
162
+ "task_specific_params": null,
163
+ "temperature": 1.0,
164
+ "tf_legacy_loss": false,
165
+ "tie_encoder_decoder": false,
166
+ "tie_word_embeddings": false,
167
+ "tokenizer_class": "GPT2Tokenizer",
168
+ "top_k": 50,
169
+ "top_p": 1.0,
170
+ "torch_dtype": "float16",
171
+ "torchscript": false,
172
+ "transformers_version": "4.21.3",
173
+ "typical_p": 1.0,
174
+ "use_bfloat16": false,
175
+ "use_cache": true,
176
+ "vocab_size": 51200
177
+ },
178
+ "is_encoder_decoder": true,
179
+ "model_type": "codet5p",
180
+ "torch_dtype": "float16",
181
+ "transformers_version": null
182
+ }
configuration_codet5p.py ADDED
@@ -0,0 +1,113 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # coding=utf-8
2
+ # Copyright 2023 Salesforce authors, The EleutherAI, and HuggingFace Teams. All rights reserved.
3
+
4
+ """ CodeT5+ model configuration"""
5
+ from transformers.configuration_utils import PretrainedConfig
6
+ from transformers.utils import logging
7
+ import copy
8
+
9
+ logger = logging.get_logger(__name__)
10
+
11
+
12
+ # Adapted from transformers.models.codegen.configuration_codegen.CodeGenConfig
13
+ class CodeT5pModuleConfig(PretrainedConfig):
14
+ model_type = "codet5p_module"
15
+ attribute_map = {
16
+ "max_position_embeddings": "n_positions",
17
+ "hidden_size": "n_embd",
18
+ "num_attention_heads": "n_head",
19
+ "num_hidden_layers": "n_layer",
20
+ }
21
+
22
+ def __init__(
23
+ self,
24
+ vocab_size=50400,
25
+ n_positions=2048,
26
+ n_ctx=2048,
27
+ n_embd=4096,
28
+ n_layer=28,
29
+ n_head=16,
30
+ rotary_dim=64,
31
+ n_inner=None,
32
+ activation_function="gelu_new",
33
+ resid_pdrop=0.0,
34
+ embd_pdrop=0.0,
35
+ attn_pdrop=0.0,
36
+ layer_norm_epsilon=1e-5,
37
+ initializer_range=0.02,
38
+ scale_attn_weights=True,
39
+ use_cache=True,
40
+ bos_token_id=50256,
41
+ eos_token_id=50256,
42
+ tie_word_embeddings=False,
43
+ **kwargs
44
+ ):
45
+ self.vocab_size = vocab_size
46
+ self.n_ctx = n_ctx
47
+ self.n_positions = n_positions
48
+ self.n_embd = n_embd
49
+ self.n_layer = n_layer
50
+ self.n_head = n_head
51
+ self.n_inner = n_inner
52
+ self.rotary_dim = rotary_dim
53
+ self.activation_function = activation_function
54
+ self.resid_pdrop = resid_pdrop
55
+ self.embd_pdrop = embd_pdrop
56
+ self.attn_pdrop = attn_pdrop
57
+ self.layer_norm_epsilon = layer_norm_epsilon
58
+ self.initializer_range = initializer_range
59
+ self.scale_attn_weights = scale_attn_weights
60
+ self.use_cache = use_cache
61
+
62
+ self.bos_token_id = bos_token_id
63
+ self.eos_token_id = eos_token_id
64
+
65
+ super().__init__(
66
+ bos_token_id=bos_token_id, eos_token_id=eos_token_id, tie_word_embeddings=tie_word_embeddings, **kwargs
67
+ )
68
+
69
+
70
+ # Adapted from transformers.models.encoder_decoder.configuration_encoder_decoder.EncoderDecoderConfig
71
+ class CodeT5pConfig(PretrainedConfig):
72
+ model_type = "codet5p"
73
+ is_composition = True
74
+
75
+ def __init__(self, **kwargs):
76
+ super().__init__(**kwargs)
77
+ assert (
78
+ "encoder" in kwargs and "decoder" in kwargs
79
+ ), "Config has to be initialized with encoder and decoder config"
80
+ encoder_config = kwargs.pop("encoder")
81
+ decoder_config = kwargs.pop("decoder")
82
+ encoder_model_type = encoder_config.pop("model_type")
83
+ decoder_model_type = decoder_config.pop("model_type")
84
+
85
+ if encoder_model_type != decoder_model_type:
86
+ logger.warning("Encoder and decoder model types are different")
87
+
88
+ self.encoder = CodeT5pModuleConfig(**encoder_config)
89
+ self.decoder = CodeT5pModuleConfig(**decoder_config)
90
+ self.is_encoder_decoder = True
91
+
92
+ @classmethod
93
+ def from_encoder_decoder_configs(
94
+ cls, encoder_config: PretrainedConfig, decoder_config: PretrainedConfig, **kwargs
95
+ ) -> PretrainedConfig:
96
+ logger.info("Set `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config")
97
+ decoder_config.is_decoder = True
98
+ decoder_config.add_cross_attention = True
99
+
100
+ return cls(encoder=encoder_config.to_dict(), decoder=decoder_config.to_dict(), **kwargs)
101
+
102
+ def to_dict(self):
103
+ """
104
+ Serializes this instance to a Python dictionary. Override the default *to_dict()* from *PretrainedConfig*.
105
+
106
+ Returns:
107
+ `Dict[str, any]`: Dictionary of all the attributes that make up this configuration instance,
108
+ """
109
+ output = copy.deepcopy(self.__dict__)
110
+ output["encoder"] = self.encoder.to_dict()
111
+ output["decoder"] = self.decoder.to_dict()
112
+ output["model_type"] = self.__class__.model_type
113
+ return output
merges.txt ADDED
The diff for this file is too large to render. See raw diff
 
modeling_codet5p.py ADDED
@@ -0,0 +1,982 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # coding=utf-8
2
+ # Copyright 2023 Salesforce authors, The EleutherAI, and HuggingFace Teams. All rights reserved.
3
+ """ PyTorch CodeT5+ 2B 6B 16B models.
4
+ The implementation is mainly based on transformers.models.codegen.modeling_codegen by adding cross-attention
5
+ and transformers.models.encoder_decoder.modeling_encoder_decoder.EncoderDecoderModel.
6
+ """
7
+ from typing import Optional, Tuple, Union
8
+ import torch
9
+ import torch.utils.checkpoint
10
+ from torch import nn
11
+ from torch.nn import CrossEntropyLoss
12
+
13
+ from transformers.activations import ACT2FN
14
+ from transformers.modeling_outputs import BaseModelOutput, Seq2SeqLMOutput, \
15
+ BaseModelOutputWithPast, CausalLMOutputWithPast, \
16
+ BaseModelOutputWithPastAndCrossAttentions, CausalLMOutputWithCrossAttentions
17
+ from transformers.modeling_utils import PreTrainedModel
18
+ from transformers.configuration_utils import PretrainedConfig
19
+ from transformers.utils import add_code_sample_docstrings, add_start_docstrings, logging
20
+ from configuration_codet5p import CodeT5pConfig, CodeT5pModuleConfig
21
+
22
+ logger = logging.get_logger(__name__)
23
+
24
+ CODET5P_PRETRAINED_MODEL_ARCHIVE_LIST = [
25
+ "Salesforce/codet5p-220m",
26
+ "Salesforce/codet5p-770m",
27
+ "Salesforce/codet5p-220m-py",
28
+ "Salesforce/codet5p-770m-py",
29
+ "Salesforce/codet5p-2b",
30
+ "Salesforce/codet5p-6b",
31
+ "Salesforce/codet5p-16b",
32
+ "Salesforce/instructcodet5p-16b",
33
+ # See all CodeT5+ models at https://huggingface.co/models?filter=codet5p
34
+ ]
35
+
36
+
37
+ # Copied from transformers.models.gptj.modeling_gptj.fixed_pos_embedding
38
+ def fixed_pos_embedding(x, seq_dim=1, seq_len=None):
39
+ dim = x.shape[-1]
40
+ if seq_len is None:
41
+ seq_len = x.shape[seq_dim]
42
+ inv_freq = 1.0 / (10000 ** (torch.arange(0, dim, 2) / dim))
43
+ sinusoid_inp = (
44
+ torch.einsum("i , j -> i j", torch.arange(seq_len, dtype=torch.float), inv_freq).to(x.device).float()
45
+ )
46
+ return torch.sin(sinusoid_inp), torch.cos(sinusoid_inp)
47
+
48
+
49
+ # Copied from transformers.models.gptj.modeling_gptj.rotate_every_two
50
+ def rotate_every_two(x):
51
+ x1 = x[:, :, :, ::2]
52
+ x2 = x[:, :, :, 1::2]
53
+ x = torch.stack((-x2, x1), dim=-1)
54
+ return x.flatten(-2) # in einsum notation: rearrange(x, '... d j -> ... (d j)')
55
+
56
+
57
+ # Copied from transformers.models.gptj.modeling_gptj.duplicate_interleave
58
+ def duplicate_interleave(m):
59
+ """
60
+ A simple version of `torch.repeat_interleave` for duplicating a matrix while interleaving the copy.
61
+ """
62
+ dim0 = m.shape[0]
63
+ m = m.view(-1, 1) # flatten the matrix
64
+ m = m.repeat(1, 2) # repeat all elements into the 2nd dimension
65
+ m = m.view(dim0, -1) # reshape into a matrix, interleaving the copy
66
+ return m
67
+
68
+
69
+ # Copied from transformers.models.gptj.modeling_gptj.apply_rotary_pos_emb
70
+ def apply_rotary_pos_emb(x, sincos, offset=0):
71
+ sin, cos = (duplicate_interleave(t)[None, offset: x.shape[1] + offset, None, :] for t in sincos)
72
+ # einsum notation for lambda t: repeat(t[offset:x.shape[1]+offset,:], "n d -> () n () (d j)", j=2)
73
+ return (x * cos) + (rotate_every_two(x) * sin)
74
+
75
+
76
+ # Adapted from transformers.models.codegen.modeling_codegen.CodeGenAttention
77
+ class CodeT5pAttention(nn.Module):
78
+ def __init__(self, config, is_cross_attention=False, is_decoder=True):
79
+ super().__init__()
80
+
81
+ max_positions = config.max_position_embeddings
82
+ self.register_buffer(
83
+ "causal_mask",
84
+ torch.tril(torch.ones((max_positions, max_positions), dtype=torch.uint8)).view(
85
+ 1, 1, max_positions, max_positions
86
+ ),
87
+ )
88
+
89
+ self.attn_dropout = nn.Dropout(config.attn_pdrop)
90
+ self.resid_dropout = nn.Dropout(config.resid_pdrop)
91
+
92
+ self.embed_dim = config.hidden_size
93
+ self.num_attention_heads = config.num_attention_heads
94
+ self.head_dim = self.embed_dim // self.num_attention_heads
95
+ if self.head_dim * self.num_attention_heads != self.embed_dim:
96
+ raise ValueError(
97
+ f"embed_dim must be divisible by num_attention_heads (got `embed_dim`: {self.embed_dim} and"
98
+ f" `num_attention_heads`: {self.num_attention_heads})."
99
+ )
100
+
101
+ self.scale_attn = torch.sqrt(torch.tensor(self.head_dim, dtype=torch.float32)).to(torch.get_default_dtype())
102
+ self.is_decoder = is_decoder
103
+ self.is_cross_attention = is_cross_attention
104
+ if self.is_cross_attention:
105
+ self.qkv_proj = nn.Linear(self.embed_dim, self.embed_dim * 2, bias=False)
106
+ self.q_attn = nn.Linear(self.embed_dim, self.embed_dim, bias=False)
107
+ else:
108
+ self.qkv_proj = nn.Linear(self.embed_dim, self.embed_dim * 3, bias=False)
109
+
110
+ self.out_proj = nn.Linear(self.embed_dim, self.embed_dim, bias=False)
111
+ self.rotary_dim = None
112
+ if config.rotary_dim is not None:
113
+ self.rotary_dim = config.rotary_dim
114
+
115
+ def _split_heads(self, x, n_head, dim_head, mp_num):
116
+ reshaped = x.reshape(x.shape[:-1] + (n_head // mp_num, dim_head))
117
+ reshaped = reshaped.reshape(x.shape[:-2] + (-1,) + reshaped.shape[-1:])
118
+ return reshaped
119
+
120
+ def _merge_heads(self, tensor, num_attention_heads, attn_head_size):
121
+ """
122
+ Merges attn_head_size dim and num_attn_heads dim into n_ctx
123
+ """
124
+ if len(tensor.shape) == 5:
125
+ tensor = tensor.permute(0, 1, 3, 2, 4).contiguous()
126
+ elif len(tensor.shape) == 4:
127
+ tensor = tensor.permute(0, 2, 1, 3).contiguous()
128
+ else:
129
+ raise ValueError(f"Input tensor rank should be one of [4, 5], but is: {len(tensor.shape)}")
130
+ new_shape = tensor.size()[:-2] + (num_attention_heads * attn_head_size,)
131
+ return tensor.view(new_shape)
132
+
133
+ def _attn(
134
+ self,
135
+ query,
136
+ key,
137
+ value,
138
+ attention_mask=None,
139
+ head_mask=None,
140
+ ):
141
+ # Keep the attention weights computation in fp32 to avoid overflow issues
142
+ query = query.to(torch.float32)
143
+ key = key.to(torch.float32)
144
+
145
+ attn_weights = torch.matmul(query, key.transpose(-1, -2))
146
+ attn_weights = attn_weights / self.scale_attn
147
+
148
+ if not self.is_cross_attention and self.is_decoder:
149
+ # compute causal mask from causal mask buffer
150
+ query_length, key_length = query.size(-2), key.size(-2)
151
+ causal_mask = self.causal_mask[:, :, key_length - query_length: key_length, :key_length]
152
+ mask_value = torch.finfo(attn_weights.dtype).min
153
+ # Need to be a tensor, otherwise we get error: `RuntimeError: expected scalar type float but found double`.
154
+ # Need to be on the same device, otherwise `RuntimeError: ..., x and y to be on the same device`
155
+ mask_value = torch.tensor(mask_value, dtype=attn_weights.dtype).to(attn_weights.device)
156
+ attn_weights = torch.where(causal_mask.bool(), attn_weights, mask_value)
157
+
158
+ if attention_mask is not None:
159
+ # Apply the attention mask
160
+ attn_weights = attn_weights + attention_mask
161
+
162
+ attn_weights = nn.Softmax(dim=-1)(attn_weights)
163
+ attn_weights = attn_weights.to(value.dtype)
164
+ attn_weights = self.attn_dropout(attn_weights)
165
+
166
+ # Mask heads if we want to
167
+ if head_mask is not None:
168
+ attn_weights = attn_weights * head_mask
169
+
170
+ attn_output = torch.matmul(attn_weights, value)
171
+
172
+ return attn_output, attn_weights
173
+
174
+ def forward(
175
+ self,
176
+ hidden_states: Optional[torch.FloatTensor],
177
+ attention_mask: Optional[torch.FloatTensor] = None,
178
+ layer_past: Optional[Tuple[torch.Tensor]] = None,
179
+ head_mask: Optional[torch.FloatTensor] = None,
180
+ encoder_hidden_states: Optional[torch.Tensor] = None,
181
+ encoder_attention_mask: Optional[torch.FloatTensor] = None,
182
+ use_cache: Optional[bool] = False,
183
+ output_attentions: Optional[bool] = False,
184
+ ) -> Union[
185
+ Tuple[torch.Tensor, Tuple[torch.Tensor]],
186
+ Optional[Tuple[torch.Tensor, Tuple[torch.Tensor], Tuple[torch.Tensor, ...]]],
187
+ ]:
188
+
189
+ if encoder_hidden_states is not None:
190
+ if not hasattr(self, "q_attn"):
191
+ raise ValueError(
192
+ "If class is used as cross attention, the weights `q_attn` have to be defined. "
193
+ "Please make sure to instantiate class with `GPT2Attention(..., is_cross_attention=True)`."
194
+ )
195
+
196
+ mp_num = 4
197
+ local_dim = self.head_dim * self.num_attention_heads // mp_num
198
+ q = self.q_attn(hidden_states)
199
+ q_split = q.reshape(q.shape[:-1] + (mp_num, -1))
200
+ query = torch.split(q_split, local_dim, dim=-1)[0]
201
+
202
+ qkv = self.qkv_proj(encoder_hidden_states)
203
+ qkv_split = qkv.reshape(qkv.shape[:-1] + (mp_num, -1))
204
+ value, key = torch.split(qkv_split, local_dim, dim=-1)
205
+
206
+ attention_mask = encoder_attention_mask
207
+ else:
208
+ qkv = self.qkv_proj(hidden_states)
209
+ mp_num = 4
210
+ qkv_split = qkv.reshape(qkv.shape[:-1] + (mp_num, -1))
211
+
212
+ local_dim = self.head_dim * self.num_attention_heads // mp_num
213
+ query, value, key = torch.split(qkv_split, local_dim, dim=-1)
214
+
215
+ query = self._split_heads(query, self.num_attention_heads, self.head_dim, mp_num=mp_num)
216
+ key = self._split_heads(key, self.num_attention_heads, self.head_dim, mp_num=mp_num)
217
+
218
+ value = self._split_heads(value, self.num_attention_heads, self.head_dim, mp_num=mp_num)
219
+ value = value.permute(0, 2, 1, 3)
220
+
221
+ seq_len = key.shape[1]
222
+ offset = 0
223
+
224
+ if layer_past is not None:
225
+ offset = layer_past[0].shape[-2]
226
+ seq_len += offset
227
+
228
+ if self.rotary_dim is not None:
229
+ k_rot = key[:, :, :, : self.rotary_dim]
230
+ k_pass = key[:, :, :, self.rotary_dim:]
231
+
232
+ q_rot = query[:, :, :, : self.rotary_dim]
233
+ q_pass = query[:, :, :, self.rotary_dim:]
234
+
235
+ sincos = fixed_pos_embedding(k_rot, 1, seq_len=seq_len)
236
+ k_rot = apply_rotary_pos_emb(k_rot, sincos, offset=offset)
237
+ seq_len_q = query.shape[1]
238
+ sincos_q = fixed_pos_embedding(q_rot, 1, seq_len=seq_len_q)
239
+ q_rot = apply_rotary_pos_emb(q_rot, sincos_q, offset=offset)
240
+
241
+ key = torch.cat([k_rot, k_pass], dim=-1)
242
+ query = torch.cat([q_rot, q_pass], dim=-1)
243
+ else:
244
+ sincos = fixed_pos_embedding(key, 1, seq_len=seq_len)
245
+ key = apply_rotary_pos_emb(key, sincos, offset=offset)
246
+ query = apply_rotary_pos_emb(query, sincos, offset=offset)
247
+
248
+ key = key.permute(0, 2, 1, 3)
249
+ query = query.permute(0, 2, 1, 3)
250
+
251
+ if layer_past is not None:
252
+ past_key = layer_past[0]
253
+ past_value = layer_past[1]
254
+ key = torch.cat((past_key, key), dim=-2)
255
+ value = torch.cat((past_value, value), dim=-2)
256
+
257
+ if use_cache is True:
258
+ present = (key, value)
259
+ else:
260
+ present = None
261
+
262
+ # compute self-attention: V x Softmax(QK^T)
263
+ attn_output, attn_weights = self._attn(query, key, value, attention_mask, head_mask)
264
+
265
+ attn_output = self._merge_heads(attn_output, self.num_attention_heads, self.head_dim)
266
+ attn_output = self.out_proj(attn_output)
267
+ attn_output = self.resid_dropout(attn_output)
268
+
269
+ outputs = (attn_output, present)
270
+ if output_attentions:
271
+ outputs += (attn_weights,)
272
+
273
+ return outputs # a, present, (attentions)
274
+
275
+
276
+ # Adapted from transformers.models.codegen.modeling_codegen.CodeGenMLP
277
+ class CodeT5pMLP(nn.Module):
278
+ def __init__(self, intermediate_size, config): # in MLP: intermediate_size= 4 * embed_dim
279
+ super().__init__()
280
+ embed_dim = config.n_embd
281
+
282
+ self.fc_in = nn.Linear(embed_dim, intermediate_size)
283
+ self.fc_out = nn.Linear(intermediate_size, embed_dim)
284
+
285
+ self.act = ACT2FN[config.activation_function]
286
+ self.dropout = nn.Dropout(config.resid_pdrop)
287
+
288
+ def forward(self, hidden_states: Optional[torch.FloatTensor]) -> torch.FloatTensor:
289
+ hidden_states = self.fc_in(hidden_states)
290
+ hidden_states = self.act(hidden_states)
291
+ hidden_states = self.fc_out(hidden_states)
292
+ hidden_states = self.dropout(hidden_states)
293
+ return hidden_states
294
+
295
+
296
+ # Adapted from transformers.models.codegen.modeling_codegen.CodeGenBlock
297
+ class CodeT5pBlock(nn.Module):
298
+ def __init__(self, config, layer_idx=None):
299
+ super().__init__()
300
+ inner_dim = config.n_inner if config.n_inner is not None else 4 * config.n_embd
301
+ self.ln_1 = nn.LayerNorm(config.n_embd, eps=config.layer_norm_epsilon)
302
+
303
+ if config.is_decoder is False:
304
+ self.attn = CodeT5pAttention(config, is_cross_attention=False, is_decoder=False)
305
+ else:
306
+ self.attn = CodeT5pAttention(config)
307
+ self.mlp = CodeT5pMLP(inner_dim, config)
308
+
309
+ # Adding 1 cross-attention layer at the final decoder layer
310
+ self.add_cross_attention_by_layer = True \
311
+ if config.add_cross_attention and layer_idx == config.n_layer - 1 else False
312
+
313
+ if config.add_cross_attention and self.add_cross_attention_by_layer:
314
+ self.crossattention = CodeT5pAttention(config, is_cross_attention=True)
315
+
316
+ def forward(
317
+ self,
318
+ hidden_states: Optional[torch.FloatTensor],
319
+ layer_past: Optional[Tuple[torch.Tensor]] = None,
320
+ attention_mask: Optional[torch.FloatTensor] = None,
321
+ head_mask: Optional[torch.FloatTensor] = None,
322
+ encoder_hidden_states: Optional[torch.Tensor] = None,
323
+ encoder_attention_mask: Optional[torch.FloatTensor] = None,
324
+ use_cache: Optional[bool] = False,
325
+ output_attentions: Optional[bool] = False,
326
+ ) -> Union[Tuple[torch.Tensor], Optional[Tuple[torch.Tensor, Tuple[torch.FloatTensor, ...]]]]:
327
+ residual = hidden_states
328
+ hidden_states = self.ln_1(hidden_states)
329
+ attn_outputs = self.attn(
330
+ hidden_states,
331
+ layer_past=layer_past,
332
+ attention_mask=attention_mask,
333
+ head_mask=head_mask,
334
+ use_cache=use_cache,
335
+ output_attentions=output_attentions,
336
+ )
337
+ attn_output = attn_outputs[0] # output_attn: a, present, (attentions)
338
+ outputs = attn_outputs[1:]
339
+ feed_forward_hidden_states = self.mlp(hidden_states)
340
+
341
+ if encoder_hidden_states is not None and self.add_cross_attention_by_layer:
342
+ # add one self-attention block for cross-attention
343
+ if not hasattr(self, "crossattention"):
344
+ raise ValueError(
345
+ f"If `encoder_hidden_states` are passed, {self} has to be instantiated with "
346
+ "cross-attention layers by setting `config.add_cross_attention=True`"
347
+ )
348
+ # residual = hidden_states
349
+ # hidden_states = self.ln_cross_attn(residual)
350
+ cross_attn_outputs = self.crossattention(
351
+ hidden_states,
352
+ attention_mask=attention_mask,
353
+ head_mask=head_mask,
354
+ encoder_hidden_states=encoder_hidden_states,
355
+ encoder_attention_mask=encoder_attention_mask,
356
+ output_attentions=output_attentions,
357
+ )
358
+ xattn_output = cross_attn_outputs[0]
359
+ attn_output = attn_output + xattn_output
360
+ outputs = outputs + cross_attn_outputs[2:] # add cross attentions if we output attention weights
361
+
362
+ hidden_states = attn_output + feed_forward_hidden_states + residual
363
+
364
+ if use_cache:
365
+ outputs = (hidden_states,) + outputs
366
+ else:
367
+ outputs = (hidden_states,) + outputs[1:]
368
+
369
+ return outputs # hidden_states, present, (attentions)
370
+
371
+
372
+ # Adapted from transformers.models.codegen.modeling_codegen.CodeGenPreTrainedModel
373
+ class CodeT5pPreTrainedModel(PreTrainedModel):
374
+ """
375
+ An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
376
+ models.
377
+ """
378
+ config_class = CodeT5pModuleConfig
379
+ base_model_prefix = "transformer"
380
+ supports_gradient_checkpointing = True
381
+ _no_split_modules = ["CodeT5pBlock"]
382
+
383
+ def __init__(self, *inputs, **kwargs):
384
+ super().__init__(*inputs, **kwargs)
385
+
386
+ def _init_weights(self, module):
387
+ """Initialize the weights."""
388
+ if isinstance(module, (nn.Linear,)):
389
+ # Slightly different from Mesh Transformer JAX which uses truncated_normal for initialization
390
+ # cf https://github.com/pytorch/pytorch/pull/5617
391
+ module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
392
+ if module.bias is not None:
393
+ module.bias.data.zero_()
394
+ elif isinstance(module, nn.Embedding):
395
+ module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
396
+ if module.padding_idx is not None:
397
+ module.weight.data[module.padding_idx].zero_()
398
+ elif isinstance(module, nn.LayerNorm):
399
+ module.bias.data.zero_()
400
+ module.weight.data.fill_(1.0)
401
+
402
+ def _set_gradient_checkpointing(self, module, value=False):
403
+ if isinstance(module, CodeT5pModel):
404
+ module.gradient_checkpointing = value
405
+
406
+
407
+ # Adapted from transformers.models.codegen.modeling_codegen.CodeGenModel
408
+ class CodeT5pModel(CodeT5pPreTrainedModel):
409
+ def __init__(self, config):
410
+ super().__init__(config)
411
+
412
+ self.embed_dim = config.n_embd
413
+ self.vocab_size = config.vocab_size
414
+ self.wte = nn.Embedding(config.vocab_size, self.embed_dim)
415
+ self.drop = nn.Dropout(config.embd_pdrop)
416
+ self.h = nn.ModuleList([CodeT5pBlock(config, idx) for idx in range(config.n_layer)])
417
+ self.ln_f = nn.LayerNorm(self.embed_dim, eps=config.layer_norm_epsilon)
418
+ self.rotary_dim = min(config.rotary_dim, config.n_ctx // config.num_attention_heads)
419
+
420
+ self.gradient_checkpointing = False
421
+
422
+ # Initialize weights and apply final processing
423
+ self.post_init()
424
+
425
+ def get_input_embeddings(self):
426
+ return self.wte
427
+
428
+ def set_input_embeddings(self, new_embeddings):
429
+ self.wte = new_embeddings
430
+
431
+ def forward(
432
+ self,
433
+ input_ids: Optional[torch.LongTensor] = None,
434
+ past_key_values: Optional[Tuple[Tuple[torch.Tensor]]] = None,
435
+ attention_mask: Optional[torch.FloatTensor] = None,
436
+ token_type_ids: Optional[torch.LongTensor] = None,
437
+ position_ids: Optional[torch.LongTensor] = None,
438
+ head_mask: Optional[torch.FloatTensor] = None,
439
+ inputs_embeds: Optional[torch.FloatTensor] = None,
440
+ encoder_hidden_states: Optional[torch.Tensor] = None,
441
+ encoder_attention_mask: Optional[torch.FloatTensor] = None,
442
+ use_cache: Optional[bool] = None,
443
+ output_attentions: Optional[bool] = None,
444
+ output_hidden_states: Optional[bool] = None,
445
+ return_dict: Optional[bool] = None,
446
+ ) -> Union[Tuple, BaseModelOutputWithPastAndCrossAttentions]:
447
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
448
+ output_hidden_states = (
449
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
450
+ )
451
+ use_cache = use_cache if use_cache is not None else self.config.use_cache
452
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
453
+
454
+ if input_ids is not None and inputs_embeds is not None:
455
+ raise ValueError("You cannot specify both input_ids and inputs_embeds at the same time")
456
+ elif input_ids is not None:
457
+ input_shape = input_ids.size()
458
+ input_ids = input_ids.view(-1, input_shape[-1])
459
+ batch_size = input_ids.shape[0]
460
+ elif inputs_embeds is not None:
461
+ input_shape = inputs_embeds.size()[:-1]
462
+ batch_size = inputs_embeds.shape[0]
463
+ else:
464
+ raise ValueError("You have to specify either input_ids or inputs_embeds")
465
+
466
+ device = input_ids.device if input_ids is not None else inputs_embeds.device
467
+
468
+ if token_type_ids is not None:
469
+ token_type_ids = token_type_ids.view(-1, input_shape[-1])
470
+
471
+ if position_ids is not None:
472
+ position_ids = position_ids.view(-1, input_shape[-1])
473
+
474
+ if past_key_values is None:
475
+ past_length = 0
476
+ past_key_values = tuple([None] * len(self.h))
477
+ else:
478
+ past_length = past_key_values[0][0].size(-2)
479
+
480
+ if position_ids is None:
481
+ position_ids = torch.arange(past_length, input_shape[-1] + past_length, dtype=torch.long, device=device)
482
+ position_ids = position_ids.unsqueeze(0).view(-1, input_shape[-1])
483
+
484
+ # Attention mask.
485
+ if attention_mask is not None:
486
+ if batch_size <= 0:
487
+ raise ValueError("batch_size has to be defined and > 0")
488
+ attention_mask = attention_mask.view(batch_size, -1)
489
+ # We create a 3D attention mask from a 2D tensor mask.
490
+ # Sizes are [batch_size, 1, 1, to_seq_length]
491
+ # So we can broadcast to [batch_size, num_heads, from_seq_length, to_seq_length]
492
+ # this attention mask is more simple than the triangular masking of causal attention
493
+ # used in OpenAI GPT, we just need to prepare the broadcast dimension here.
494
+ attention_mask = attention_mask[:, None, None, :]
495
+
496
+ # Since attention_mask is 1.0 for positions we want to attend and 0.0 for
497
+ # masked positions, this operation will create a tensor which is 0.0 for
498
+ # positions we want to attend and the dtype's smallest value for masked positions.
499
+ # Since we are adding it to the raw scores before the softmax, this is
500
+ # effectively the same as removing these entirely.
501
+ attention_mask = attention_mask.to(dtype=self.dtype) # fp16 compatibility
502
+ attention_mask = (1.0 - attention_mask) * torch.finfo(self.dtype).min
503
+
504
+ # If a 2D or 3D attention mask is provided for the cross-attention
505
+ # we need to make broadcastable to [batch_size, num_heads, seq_length, seq_length]
506
+ if self.config.add_cross_attention and encoder_hidden_states is not None:
507
+ encoder_batch_size, encoder_sequence_length, _ = encoder_hidden_states.size()
508
+ encoder_hidden_shape = (encoder_batch_size, encoder_sequence_length)
509
+ if encoder_attention_mask is None:
510
+ encoder_attention_mask = torch.ones(encoder_hidden_shape, device=device)
511
+ encoder_attention_mask = self.invert_attention_mask(encoder_attention_mask)
512
+ else:
513
+ encoder_attention_mask = None
514
+
515
+ # Prepare head mask if needed
516
+ # 1.0 in head_mask indicate we keep the head
517
+ # attention_probs has shape bsz x num_attention_heads x N x N
518
+ # head_mask has shape n_layer x batch x num_attention_heads x N x N
519
+ head_mask = self.get_head_mask(head_mask, self.config.n_layer)
520
+
521
+ if inputs_embeds is None:
522
+ inputs_embeds = self.wte(input_ids)
523
+
524
+ hidden_states = inputs_embeds
525
+
526
+ if token_type_ids is not None:
527
+ token_type_embeds = self.wte(token_type_ids)
528
+ hidden_states = hidden_states + token_type_embeds
529
+
530
+ hidden_states = self.drop(hidden_states)
531
+
532
+ output_shape = input_shape + (hidden_states.size(-1),)
533
+
534
+ presents = () if use_cache else None
535
+ all_self_attentions = () if output_attentions else None
536
+ all_cross_attentions = () if output_attentions and self.config.add_cross_attention else None
537
+ all_hidden_states = () if output_hidden_states else None
538
+ for i, (block, layer_past) in enumerate(zip(self.h, past_key_values)):
539
+ if output_hidden_states:
540
+ all_hidden_states = all_hidden_states + (hidden_states,)
541
+
542
+ if self.gradient_checkpointing and self.training:
543
+ if use_cache:
544
+ logger.warning(
545
+ "`use_cache=True` is incompatible with `config.gradient_checkpointing=True`. Setting "
546
+ "`use_cache=False`..."
547
+ )
548
+ use_cache = False
549
+
550
+ def create_custom_forward(module):
551
+ def custom_forward(*inputs):
552
+ # None for past_key_value
553
+ return module(*inputs, use_cache, output_attentions)
554
+
555
+ return custom_forward
556
+
557
+ outputs = torch.utils.checkpoint.checkpoint(
558
+ create_custom_forward(block),
559
+ hidden_states,
560
+ None,
561
+ attention_mask,
562
+ head_mask[i],
563
+ encoder_hidden_states,
564
+ encoder_attention_mask,
565
+ )
566
+ else:
567
+ outputs = block(
568
+ hidden_states,
569
+ layer_past=layer_past,
570
+ attention_mask=attention_mask,
571
+ head_mask=head_mask[i],
572
+ encoder_hidden_states=encoder_hidden_states,
573
+ encoder_attention_mask=encoder_attention_mask,
574
+ use_cache=use_cache,
575
+ output_attentions=output_attentions,
576
+ )
577
+
578
+ hidden_states = outputs[0]
579
+ if use_cache is True:
580
+ presents = presents + (outputs[1],)
581
+
582
+ if output_attentions:
583
+ all_self_attentions = all_self_attentions + (outputs[2 if use_cache else 1],)
584
+ if self.config.add_cross_attention and self.add_cross_attention_by_layer:
585
+ all_cross_attentions = all_cross_attentions + (outputs[3 if use_cache else 2],)
586
+
587
+ hidden_states = self.ln_f(hidden_states)
588
+
589
+ hidden_states = hidden_states.view(output_shape)
590
+ # Add last hidden state
591
+ if output_hidden_states:
592
+ all_hidden_states = all_hidden_states + (hidden_states,)
593
+
594
+ if not return_dict:
595
+ return tuple(
596
+ v for v in [hidden_states, presents, all_hidden_states, all_self_attentions, all_cross_attentions] if
597
+ v is not None)
598
+
599
+ return BaseModelOutputWithPastAndCrossAttentions(
600
+ last_hidden_state=hidden_states,
601
+ past_key_values=presents,
602
+ hidden_states=all_hidden_states,
603
+ attentions=all_self_attentions,
604
+ cross_attentions=all_cross_attentions,
605
+ )
606
+
607
+
608
+ # Adapted from transformers.models.codegen.modeling_codegen.CodeGenForCausalLM
609
+ class CodeT5pForCausalLM(CodeT5pPreTrainedModel):
610
+ _keys_to_ignore_on_load_missing = [r"h\.\d+\.attn\.causal_mask"]
611
+
612
+ def __init__(self, config):
613
+ super().__init__(config)
614
+ self.transformer = CodeT5pModel(config)
615
+ self.lm_head = nn.Linear(config.n_embd, config.vocab_size)
616
+
617
+ # Initialize weights and apply final processing
618
+ self.post_init()
619
+
620
+ def get_output_embeddings(self):
621
+ return self.lm_head
622
+
623
+ def set_output_embeddings(self, new_embeddings):
624
+ self.lm_head = new_embeddings
625
+
626
+ def prepare_inputs_for_generation(self, input_ids, past_key_values=None, **kwargs):
627
+ token_type_ids = kwargs.get("token_type_ids", None)
628
+ # only last token for inputs_ids if past is defined in kwargs
629
+ if past_key_values:
630
+ input_ids = input_ids[:, -1].unsqueeze(-1)
631
+ if token_type_ids is not None:
632
+ token_type_ids = token_type_ids[:, -1].unsqueeze(-1)
633
+
634
+ attention_mask = kwargs.get("attention_mask", None)
635
+ position_ids = kwargs.get("position_ids", None)
636
+
637
+ if attention_mask is not None and position_ids is None:
638
+ # create position_ids on the fly for batch generation
639
+ position_ids = attention_mask.long().cumsum(-1) - 1
640
+ position_ids.masked_fill_(attention_mask == 0, 1)
641
+ if past_key_values:
642
+ position_ids = position_ids[:, -1].unsqueeze(-1)
643
+ else:
644
+ position_ids = None
645
+ return {
646
+ "input_ids": input_ids,
647
+ "past_key_values": past_key_values,
648
+ "use_cache": kwargs.get("use_cache"),
649
+ "position_ids": position_ids,
650
+ "attention_mask": attention_mask,
651
+ "token_type_ids": token_type_ids,
652
+ }
653
+
654
+ def forward(
655
+ self,
656
+ input_ids: Optional[torch.LongTensor] = None,
657
+ past_key_values: Optional[Tuple[Tuple[torch.Tensor]]] = None,
658
+ attention_mask: Optional[torch.FloatTensor] = None,
659
+ token_type_ids: Optional[torch.LongTensor] = None,
660
+ position_ids: Optional[torch.LongTensor] = None,
661
+ head_mask: Optional[torch.FloatTensor] = None,
662
+ inputs_embeds: Optional[torch.FloatTensor] = None,
663
+ encoder_hidden_states: Optional[torch.Tensor] = None,
664
+ encoder_attention_mask: Optional[torch.FloatTensor] = None,
665
+ labels: Optional[torch.LongTensor] = None,
666
+ use_cache: Optional[bool] = None,
667
+ output_attentions: Optional[bool] = None,
668
+ output_hidden_states: Optional[bool] = None,
669
+ return_dict: Optional[bool] = None,
670
+ ) -> Union[Tuple, CausalLMOutputWithCrossAttentions]:
671
+ r"""
672
+ labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
673
+ Labels for language modeling. Note that the labels **are shifted** inside the model, i.e. you can set
674
+ `labels = input_ids` Indices are selected in `[-100, 0, ..., config.vocab_size]` All labels set to `-100`
675
+ are ignored (masked), the loss is only computed for labels in `[0, ..., config.vocab_size]`
676
+ """
677
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
678
+
679
+ transformer_outputs = self.transformer(
680
+ input_ids,
681
+ past_key_values=past_key_values,
682
+ attention_mask=attention_mask,
683
+ token_type_ids=token_type_ids,
684
+ position_ids=position_ids,
685
+ head_mask=head_mask,
686
+ inputs_embeds=inputs_embeds,
687
+ encoder_hidden_states=encoder_hidden_states,
688
+ encoder_attention_mask=encoder_attention_mask,
689
+ use_cache=use_cache,
690
+ output_attentions=output_attentions,
691
+ output_hidden_states=output_hidden_states,
692
+ return_dict=return_dict,
693
+ )
694
+ hidden_states = transformer_outputs[0]
695
+
696
+ # make sure sampling in fp16 works correctly and
697
+ # compute loss in fp32 to match with mesh-tf version
698
+ # https://github.com/EleutherAI/gpt-neo/blob/89ce74164da2fb16179106f54e2269b5da8db333/models/gpt2/gpt2.py#L179
699
+ lm_logits = self.lm_head(hidden_states).to(torch.float32)
700
+
701
+ loss = None
702
+ if labels is not None:
703
+ # Shift so that tokens < n predict n
704
+ shift_logits = lm_logits[..., :-1, :].contiguous()
705
+ shift_labels = labels[..., 1:].contiguous()
706
+ # Flatten the tokens
707
+ loss_fct = CrossEntropyLoss()
708
+ loss = loss_fct(shift_logits.view(-1, shift_logits.size(-1)), shift_labels.view(-1))
709
+
710
+ loss = loss.to(hidden_states.dtype)
711
+
712
+ if not return_dict:
713
+ output = (lm_logits,) + transformer_outputs[1:]
714
+ return ((loss,) + output) if loss is not None else output
715
+
716
+ return CausalLMOutputWithCrossAttentions(
717
+ loss=loss,
718
+ logits=lm_logits,
719
+ past_key_values=transformer_outputs.past_key_values,
720
+ hidden_states=transformer_outputs.hidden_states,
721
+ attentions=transformer_outputs.attentions,
722
+ cross_attentions=transformer_outputs.cross_attentions,
723
+ )
724
+
725
+ @staticmethod
726
+ def _reorder_cache(
727
+ past_key_values: Tuple[Tuple[torch.Tensor]], beam_idx: torch.Tensor
728
+ ) -> Tuple[Tuple[torch.Tensor]]:
729
+ """
730
+ This function is used to re-order the `past_key_values` cache if [`~PretrainedModel.beam_search`] or
731
+ [`~PretrainedModel.beam_sample`] is called. This is required to match `past_key_values` with the correct
732
+ beam_idx at every generation step.
733
+ """
734
+ return tuple(
735
+ tuple(past_state.index_select(0, beam_idx.to(past_state.device)) for past_state in layer_past)
736
+ for layer_past in past_key_values
737
+ )
738
+
739
+
740
+ def shift_tokens_right(input_ids: torch.Tensor, pad_token_id: int, decoder_start_token_id: int):
741
+ """
742
+ Shift input ids one token to the right.
743
+ """
744
+ shifted_input_ids = input_ids.new_zeros(input_ids.shape)
745
+ shifted_input_ids[:, 1:] = input_ids[:, :-1].clone()
746
+ if decoder_start_token_id is None:
747
+ raise ValueError("Make sure to set the decoder_start_token_id attribute of the model's configuration.")
748
+ shifted_input_ids[:, 0] = decoder_start_token_id
749
+
750
+ if pad_token_id is None:
751
+ raise ValueError("Make sure to set the pad_token_id attribute of the model's configuration.")
752
+ # replace possible -100 values in labels by `pad_token_id`
753
+ shifted_input_ids.masked_fill_(shifted_input_ids == -100, pad_token_id)
754
+
755
+ return shifted_input_ids
756
+
757
+
758
+ # Adapted from transformers.models.encoder_decoder.modeling_encoder_decoder.EncoderDecoderModel
759
+ class CodeT5pEncoderDecoderModel(PreTrainedModel):
760
+ config_class = CodeT5pConfig
761
+
762
+ def __init__(
763
+ self,
764
+ config: Optional[PretrainedConfig] = None,
765
+ encoder: Optional[PreTrainedModel] = None,
766
+ decoder: Optional[PreTrainedModel] = None,
767
+ ):
768
+ if config is None and (encoder is None or decoder is None):
769
+ raise ValueError("Either a configuration or an encoder and a decoder has to be provided.")
770
+ if config is None:
771
+ config = CodeT5pConfig.from_encoder_decoder_configs(encoder.config, decoder.config)
772
+ else:
773
+ if not isinstance(config, self.config_class):
774
+ raise ValueError(f"Config: {config} has to be of type {self.config_class}")
775
+
776
+ if config.decoder.cross_attention_hidden_size is not None:
777
+ if config.decoder.cross_attention_hidden_size != config.encoder.hidden_size:
778
+ raise ValueError(
779
+ "If `cross_attention_hidden_size` is specified in the decoder's configuration, it has to be equal"
780
+ f" to the encoder's `hidden_size`. Got {config.decoder.cross_attention_hidden_size} for"
781
+ f" `config.decoder.cross_attention_hidden_size` and {config.encoder.hidden_size} for"
782
+ " `config.encoder.hidden_size`."
783
+ )
784
+
785
+ # initialize with config
786
+ super().__init__(config)
787
+
788
+ if encoder is None:
789
+ encoder = CodeT5pModel(config.encoder)
790
+
791
+ if decoder is None:
792
+ decoder = CodeT5pForCausalLM(config.decoder)
793
+
794
+ self.encoder = encoder
795
+ self.decoder = decoder
796
+
797
+ if self.encoder.config.to_dict() != self.config.encoder.to_dict():
798
+ logger.warning(
799
+ f"Config of the encoder: {self.encoder.__class__} is overwritten by shared encoder config:"
800
+ f" {self.config.encoder}"
801
+ )
802
+ if self.decoder.config.to_dict() != self.config.decoder.to_dict():
803
+ logger.warning(
804
+ f"Config of the decoder: {self.decoder.__class__} is overwritten by shared decoder config:"
805
+ f" {self.config.decoder}"
806
+ )
807
+
808
+ # make sure that the individual model's config refers to the shared config
809
+ # so that the updates to the config will be synced
810
+ self.encoder.config = self.config.encoder
811
+ self.decoder.config = self.config.decoder
812
+
813
+ # encoder outputs might need to be projected to different dimension for decoder
814
+ if (
815
+ self.encoder.config.hidden_size != self.decoder.config.hidden_size
816
+ and self.decoder.config.cross_attention_hidden_size is None
817
+ ):
818
+ self.enc_to_dec_proj = nn.Linear(self.encoder.config.hidden_size, self.decoder.config.hidden_size)
819
+
820
+ if self.encoder.get_output_embeddings() is not None:
821
+ raise ValueError(
822
+ f"The encoder {self.encoder} should not have a LM Head. Please use a model without LM Head"
823
+ )
824
+ # tie encoder, decoder weights if config set accordingly
825
+ self.tie_weights()
826
+
827
+ def tie_weights(self):
828
+ # tie encoder & decoder if needed
829
+ if self.config.tie_encoder_decoder:
830
+ # tie encoder and decoder base model
831
+ decoder_base_model_prefix = self.decoder.base_model_prefix
832
+ self._tie_encoder_decoder_weights(
833
+ self.encoder, self.decoder._modules[decoder_base_model_prefix], self.decoder.base_model_prefix
834
+ )
835
+
836
+ def get_encoder(self):
837
+ return self.encoder
838
+
839
+ def get_decoder(self):
840
+ return self.decoder
841
+
842
+ def get_input_embeddings(self):
843
+ return self.encoder.get_input_embeddings()
844
+
845
+ def get_output_embeddings(self):
846
+ return self.decoder.get_output_embeddings()
847
+
848
+ def set_output_embeddings(self, new_embeddings):
849
+ return self.decoder.set_output_embeddings(new_embeddings)
850
+
851
+ @classmethod
852
+ def from_pretrained(cls, *args, **kwargs):
853
+ # At the moment fast initialization is not supported for composite models
854
+ if kwargs.get("_fast_init", False):
855
+ logger.warning(
856
+ "Fast initialization is currently not supported for EncoderDecoderModel. "
857
+ "Falling back to slow initialization..."
858
+ )
859
+ kwargs["_fast_init"] = False
860
+ return super().from_pretrained(*args, **kwargs)
861
+
862
+ def forward(
863
+ self,
864
+ input_ids: Optional[torch.LongTensor] = None,
865
+ attention_mask: Optional[torch.FloatTensor] = None,
866
+ decoder_input_ids: Optional[torch.LongTensor] = None,
867
+ decoder_attention_mask: Optional[torch.BoolTensor] = None,
868
+ encoder_outputs: Optional[Tuple[torch.FloatTensor]] = None,
869
+ past_key_values: Tuple[Tuple[torch.FloatTensor]] = None,
870
+ inputs_embeds: Optional[torch.FloatTensor] = None,
871
+ decoder_inputs_embeds: Optional[torch.FloatTensor] = None,
872
+ labels: Optional[torch.LongTensor] = None,
873
+ use_cache: Optional[bool] = None,
874
+ output_attentions: Optional[bool] = None,
875
+ output_hidden_states: Optional[bool] = None,
876
+ return_dict: Optional[bool] = None,
877
+ **kwargs,
878
+ ) -> Union[Tuple, Seq2SeqLMOutput]:
879
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
880
+
881
+ kwargs_encoder = {argument: value for argument, value in kwargs.items() if not argument.startswith("decoder_")}
882
+
883
+ kwargs_decoder = {
884
+ argument[len("decoder_"):]: value for argument, value in kwargs.items() if argument.startswith("decoder_")
885
+ }
886
+
887
+ if encoder_outputs is None:
888
+ encoder_outputs = self.encoder(
889
+ input_ids=input_ids,
890
+ attention_mask=attention_mask,
891
+ inputs_embeds=inputs_embeds,
892
+ output_attentions=output_attentions,
893
+ output_hidden_states=output_hidden_states,
894
+ return_dict=return_dict,
895
+ **kwargs_encoder,
896
+ )
897
+ elif isinstance(encoder_outputs, tuple):
898
+ encoder_outputs = BaseModelOutput(*encoder_outputs)
899
+
900
+ encoder_hidden_states = encoder_outputs[0]
901
+
902
+ # optionally project encoder_hidden_states
903
+ if (
904
+ self.encoder.config.hidden_size != self.decoder.config.hidden_size
905
+ and self.decoder.config.cross_attention_hidden_size is None
906
+ ):
907
+ encoder_hidden_states = self.enc_to_dec_proj(encoder_hidden_states)
908
+
909
+ if (labels is not None) and (decoder_input_ids is None and decoder_inputs_embeds is None):
910
+ decoder_input_ids = shift_tokens_right(
911
+ labels, self.config.pad_token_id, self.config.decoder_start_token_id
912
+ )
913
+
914
+ # Decode
915
+ decoder_outputs = self.decoder(
916
+ input_ids=decoder_input_ids,
917
+ attention_mask=decoder_attention_mask,
918
+ encoder_hidden_states=encoder_hidden_states,
919
+ encoder_attention_mask=attention_mask,
920
+ inputs_embeds=decoder_inputs_embeds,
921
+ output_attentions=output_attentions,
922
+ output_hidden_states=output_hidden_states,
923
+ use_cache=use_cache,
924
+ past_key_values=past_key_values,
925
+ return_dict=return_dict,
926
+ **kwargs_decoder,
927
+ )
928
+
929
+ # Compute loss independent from decoder (as some shift the logits inside them)
930
+ loss = None
931
+ if labels is not None:
932
+ # warnings.warn(DEPRECATION_WARNING, FutureWarning)
933
+ logits = decoder_outputs.logits if return_dict else decoder_outputs[0]
934
+ loss_fct = CrossEntropyLoss()
935
+ loss = loss_fct(logits.reshape(-1, self.decoder.config.vocab_size), labels.view(-1))
936
+
937
+ if not return_dict:
938
+ if loss is not None:
939
+ return (loss,) + decoder_outputs + encoder_outputs
940
+ else:
941
+ return decoder_outputs + encoder_outputs
942
+
943
+ return Seq2SeqLMOutput(
944
+ loss=loss,
945
+ logits=decoder_outputs.logits,
946
+ past_key_values=decoder_outputs.past_key_values,
947
+ decoder_hidden_states=decoder_outputs.hidden_states,
948
+ decoder_attentions=decoder_outputs.attentions,
949
+ cross_attentions=decoder_outputs.cross_attentions,
950
+ encoder_last_hidden_state=encoder_outputs.last_hidden_state,
951
+ encoder_hidden_states=encoder_outputs.hidden_states,
952
+ encoder_attentions=encoder_outputs.attentions,
953
+ )
954
+
955
+ def prepare_decoder_input_ids_from_labels(self, labels: torch.Tensor):
956
+ return shift_tokens_right(labels, self.config.pad_token_id, self.config.decoder_start_token_id)
957
+
958
+ def prepare_inputs_for_generation(
959
+ self, input_ids, past=None, attention_mask=None, use_cache=None, encoder_outputs=None, **kwargs
960
+ ):
961
+ decoder_inputs = self.decoder.prepare_inputs_for_generation(input_ids, past=past)
962
+ decoder_attention_mask = decoder_inputs["attention_mask"] if "attention_mask" in decoder_inputs else None
963
+ input_dict = {
964
+ "attention_mask": attention_mask,
965
+ "decoder_attention_mask": decoder_attention_mask,
966
+ "decoder_input_ids": decoder_inputs["input_ids"],
967
+ "encoder_outputs": encoder_outputs,
968
+ "past_key_values": decoder_inputs["past_key_values"],
969
+ "use_cache": use_cache,
970
+ }
971
+ return input_dict
972
+
973
+ def resize_token_embeddings(self, *args, **kwargs):
974
+ raise NotImplementedError(
975
+ "Resizing the embedding layers via the EncoderDecoderModel directly is not supported. Please use the"
976
+ " respective methods of the wrapped objects (model.encoder.resize_token_embeddings(...) or"
977
+ " model.decoder.resize_token_embeddings(...))"
978
+ )
979
+
980
+ def _reorder_cache(self, past, beam_idx):
981
+ # apply decoder cache reordering here
982
+ return self.decoder._reorder_cache(past, beam_idx)
pytorch_model-00001-of-00002.bin ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:c4f816e805e4a596a1405788344bd2715241ee86e2de6e1dcb73f5b99e5886c8
3
+ size 7895051144
pytorch_model-00002-of-00002.bin ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:132c7df3b7031a8846838c6350cf687da3e51c96424e5ed6512390d75020c273
3
+ size 7211114903
pytorch_model.bin.index.json ADDED
@@ -0,0 +1,498 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "metadata": {
3
+ "total_size": 15105998848
4
+ },
5
+ "weight_map": {
6
+ "decoder.lm_head.bias": "pytorch_model-00002-of-00002.bin",
7
+ "decoder.lm_head.weight": "pytorch_model-00002-of-00002.bin",
8
+ "decoder.transformer.h.0.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
9
+ "decoder.transformer.h.0.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
10
+ "decoder.transformer.h.0.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
11
+ "decoder.transformer.h.0.ln_1.bias": "pytorch_model-00001-of-00002.bin",
12
+ "decoder.transformer.h.0.ln_1.weight": "pytorch_model-00001-of-00002.bin",
13
+ "decoder.transformer.h.0.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
14
+ "decoder.transformer.h.0.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
15
+ "decoder.transformer.h.0.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
16
+ "decoder.transformer.h.0.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
17
+ "decoder.transformer.h.1.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
18
+ "decoder.transformer.h.1.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
19
+ "decoder.transformer.h.1.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
20
+ "decoder.transformer.h.1.ln_1.bias": "pytorch_model-00001-of-00002.bin",
21
+ "decoder.transformer.h.1.ln_1.weight": "pytorch_model-00001-of-00002.bin",
22
+ "decoder.transformer.h.1.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
23
+ "decoder.transformer.h.1.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
24
+ "decoder.transformer.h.1.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
25
+ "decoder.transformer.h.1.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
26
+ "decoder.transformer.h.10.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
27
+ "decoder.transformer.h.10.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
28
+ "decoder.transformer.h.10.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
29
+ "decoder.transformer.h.10.ln_1.bias": "pytorch_model-00001-of-00002.bin",
30
+ "decoder.transformer.h.10.ln_1.weight": "pytorch_model-00001-of-00002.bin",
31
+ "decoder.transformer.h.10.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
32
+ "decoder.transformer.h.10.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
33
+ "decoder.transformer.h.10.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
34
+ "decoder.transformer.h.10.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
35
+ "decoder.transformer.h.11.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
36
+ "decoder.transformer.h.11.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
37
+ "decoder.transformer.h.11.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
38
+ "decoder.transformer.h.11.ln_1.bias": "pytorch_model-00001-of-00002.bin",
39
+ "decoder.transformer.h.11.ln_1.weight": "pytorch_model-00001-of-00002.bin",
40
+ "decoder.transformer.h.11.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
41
+ "decoder.transformer.h.11.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
42
+ "decoder.transformer.h.11.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
43
+ "decoder.transformer.h.11.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
44
+ "decoder.transformer.h.12.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
45
+ "decoder.transformer.h.12.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
46
+ "decoder.transformer.h.12.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
47
+ "decoder.transformer.h.12.ln_1.bias": "pytorch_model-00001-of-00002.bin",
48
+ "decoder.transformer.h.12.ln_1.weight": "pytorch_model-00001-of-00002.bin",
49
+ "decoder.transformer.h.12.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
50
+ "decoder.transformer.h.12.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
51
+ "decoder.transformer.h.12.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
52
+ "decoder.transformer.h.12.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
53
+ "decoder.transformer.h.13.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
54
+ "decoder.transformer.h.13.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
55
+ "decoder.transformer.h.13.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
56
+ "decoder.transformer.h.13.ln_1.bias": "pytorch_model-00001-of-00002.bin",
57
+ "decoder.transformer.h.13.ln_1.weight": "pytorch_model-00001-of-00002.bin",
58
+ "decoder.transformer.h.13.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
59
+ "decoder.transformer.h.13.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
60
+ "decoder.transformer.h.13.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
61
+ "decoder.transformer.h.13.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
62
+ "decoder.transformer.h.14.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
63
+ "decoder.transformer.h.14.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
64
+ "decoder.transformer.h.14.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
65
+ "decoder.transformer.h.14.ln_1.bias": "pytorch_model-00001-of-00002.bin",
66
+ "decoder.transformer.h.14.ln_1.weight": "pytorch_model-00001-of-00002.bin",
67
+ "decoder.transformer.h.14.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
68
+ "decoder.transformer.h.14.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
69
+ "decoder.transformer.h.14.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
70
+ "decoder.transformer.h.14.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
71
+ "decoder.transformer.h.15.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
72
+ "decoder.transformer.h.15.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
73
+ "decoder.transformer.h.15.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
74
+ "decoder.transformer.h.15.ln_1.bias": "pytorch_model-00001-of-00002.bin",
75
+ "decoder.transformer.h.15.ln_1.weight": "pytorch_model-00001-of-00002.bin",
76
+ "decoder.transformer.h.15.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
77
+ "decoder.transformer.h.15.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
78
+ "decoder.transformer.h.15.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
79
+ "decoder.transformer.h.15.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
80
+ "decoder.transformer.h.16.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
81
+ "decoder.transformer.h.16.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
82
+ "decoder.transformer.h.16.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
83
+ "decoder.transformer.h.16.ln_1.bias": "pytorch_model-00001-of-00002.bin",
84
+ "decoder.transformer.h.16.ln_1.weight": "pytorch_model-00001-of-00002.bin",
85
+ "decoder.transformer.h.16.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
86
+ "decoder.transformer.h.16.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
87
+ "decoder.transformer.h.16.mlp.fc_out.bias": "pytorch_model-00002-of-00002.bin",
88
+ "decoder.transformer.h.16.mlp.fc_out.weight": "pytorch_model-00002-of-00002.bin",
89
+ "decoder.transformer.h.17.attn.causal_mask": "pytorch_model-00002-of-00002.bin",
90
+ "decoder.transformer.h.17.attn.out_proj.weight": "pytorch_model-00002-of-00002.bin",
91
+ "decoder.transformer.h.17.attn.qkv_proj.weight": "pytorch_model-00002-of-00002.bin",
92
+ "decoder.transformer.h.17.ln_1.bias": "pytorch_model-00002-of-00002.bin",
93
+ "decoder.transformer.h.17.ln_1.weight": "pytorch_model-00002-of-00002.bin",
94
+ "decoder.transformer.h.17.mlp.fc_in.bias": "pytorch_model-00002-of-00002.bin",
95
+ "decoder.transformer.h.17.mlp.fc_in.weight": "pytorch_model-00002-of-00002.bin",
96
+ "decoder.transformer.h.17.mlp.fc_out.bias": "pytorch_model-00002-of-00002.bin",
97
+ "decoder.transformer.h.17.mlp.fc_out.weight": "pytorch_model-00002-of-00002.bin",
98
+ "decoder.transformer.h.18.attn.causal_mask": "pytorch_model-00002-of-00002.bin",
99
+ "decoder.transformer.h.18.attn.out_proj.weight": "pytorch_model-00002-of-00002.bin",
100
+ "decoder.transformer.h.18.attn.qkv_proj.weight": "pytorch_model-00002-of-00002.bin",
101
+ "decoder.transformer.h.18.ln_1.bias": "pytorch_model-00002-of-00002.bin",
102
+ "decoder.transformer.h.18.ln_1.weight": "pytorch_model-00002-of-00002.bin",
103
+ "decoder.transformer.h.18.mlp.fc_in.bias": "pytorch_model-00002-of-00002.bin",
104
+ "decoder.transformer.h.18.mlp.fc_in.weight": "pytorch_model-00002-of-00002.bin",
105
+ "decoder.transformer.h.18.mlp.fc_out.bias": "pytorch_model-00002-of-00002.bin",
106
+ "decoder.transformer.h.18.mlp.fc_out.weight": "pytorch_model-00002-of-00002.bin",
107
+ "decoder.transformer.h.19.attn.causal_mask": "pytorch_model-00002-of-00002.bin",
108
+ "decoder.transformer.h.19.attn.out_proj.weight": "pytorch_model-00002-of-00002.bin",
109
+ "decoder.transformer.h.19.attn.qkv_proj.weight": "pytorch_model-00002-of-00002.bin",
110
+ "decoder.transformer.h.19.ln_1.bias": "pytorch_model-00002-of-00002.bin",
111
+ "decoder.transformer.h.19.ln_1.weight": "pytorch_model-00002-of-00002.bin",
112
+ "decoder.transformer.h.19.mlp.fc_in.bias": "pytorch_model-00002-of-00002.bin",
113
+ "decoder.transformer.h.19.mlp.fc_in.weight": "pytorch_model-00002-of-00002.bin",
114
+ "decoder.transformer.h.19.mlp.fc_out.bias": "pytorch_model-00002-of-00002.bin",
115
+ "decoder.transformer.h.19.mlp.fc_out.weight": "pytorch_model-00002-of-00002.bin",
116
+ "decoder.transformer.h.2.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
117
+ "decoder.transformer.h.2.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
118
+ "decoder.transformer.h.2.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
119
+ "decoder.transformer.h.2.ln_1.bias": "pytorch_model-00001-of-00002.bin",
120
+ "decoder.transformer.h.2.ln_1.weight": "pytorch_model-00001-of-00002.bin",
121
+ "decoder.transformer.h.2.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
122
+ "decoder.transformer.h.2.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
123
+ "decoder.transformer.h.2.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
124
+ "decoder.transformer.h.2.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
125
+ "decoder.transformer.h.20.attn.causal_mask": "pytorch_model-00002-of-00002.bin",
126
+ "decoder.transformer.h.20.attn.out_proj.weight": "pytorch_model-00002-of-00002.bin",
127
+ "decoder.transformer.h.20.attn.qkv_proj.weight": "pytorch_model-00002-of-00002.bin",
128
+ "decoder.transformer.h.20.ln_1.bias": "pytorch_model-00002-of-00002.bin",
129
+ "decoder.transformer.h.20.ln_1.weight": "pytorch_model-00002-of-00002.bin",
130
+ "decoder.transformer.h.20.mlp.fc_in.bias": "pytorch_model-00002-of-00002.bin",
131
+ "decoder.transformer.h.20.mlp.fc_in.weight": "pytorch_model-00002-of-00002.bin",
132
+ "decoder.transformer.h.20.mlp.fc_out.bias": "pytorch_model-00002-of-00002.bin",
133
+ "decoder.transformer.h.20.mlp.fc_out.weight": "pytorch_model-00002-of-00002.bin",
134
+ "decoder.transformer.h.21.attn.causal_mask": "pytorch_model-00002-of-00002.bin",
135
+ "decoder.transformer.h.21.attn.out_proj.weight": "pytorch_model-00002-of-00002.bin",
136
+ "decoder.transformer.h.21.attn.qkv_proj.weight": "pytorch_model-00002-of-00002.bin",
137
+ "decoder.transformer.h.21.ln_1.bias": "pytorch_model-00002-of-00002.bin",
138
+ "decoder.transformer.h.21.ln_1.weight": "pytorch_model-00002-of-00002.bin",
139
+ "decoder.transformer.h.21.mlp.fc_in.bias": "pytorch_model-00002-of-00002.bin",
140
+ "decoder.transformer.h.21.mlp.fc_in.weight": "pytorch_model-00002-of-00002.bin",
141
+ "decoder.transformer.h.21.mlp.fc_out.bias": "pytorch_model-00002-of-00002.bin",
142
+ "decoder.transformer.h.21.mlp.fc_out.weight": "pytorch_model-00002-of-00002.bin",
143
+ "decoder.transformer.h.22.attn.causal_mask": "pytorch_model-00002-of-00002.bin",
144
+ "decoder.transformer.h.22.attn.out_proj.weight": "pytorch_model-00002-of-00002.bin",
145
+ "decoder.transformer.h.22.attn.qkv_proj.weight": "pytorch_model-00002-of-00002.bin",
146
+ "decoder.transformer.h.22.ln_1.bias": "pytorch_model-00002-of-00002.bin",
147
+ "decoder.transformer.h.22.ln_1.weight": "pytorch_model-00002-of-00002.bin",
148
+ "decoder.transformer.h.22.mlp.fc_in.bias": "pytorch_model-00002-of-00002.bin",
149
+ "decoder.transformer.h.22.mlp.fc_in.weight": "pytorch_model-00002-of-00002.bin",
150
+ "decoder.transformer.h.22.mlp.fc_out.bias": "pytorch_model-00002-of-00002.bin",
151
+ "decoder.transformer.h.22.mlp.fc_out.weight": "pytorch_model-00002-of-00002.bin",
152
+ "decoder.transformer.h.23.attn.causal_mask": "pytorch_model-00002-of-00002.bin",
153
+ "decoder.transformer.h.23.attn.out_proj.weight": "pytorch_model-00002-of-00002.bin",
154
+ "decoder.transformer.h.23.attn.qkv_proj.weight": "pytorch_model-00002-of-00002.bin",
155
+ "decoder.transformer.h.23.ln_1.bias": "pytorch_model-00002-of-00002.bin",
156
+ "decoder.transformer.h.23.ln_1.weight": "pytorch_model-00002-of-00002.bin",
157
+ "decoder.transformer.h.23.mlp.fc_in.bias": "pytorch_model-00002-of-00002.bin",
158
+ "decoder.transformer.h.23.mlp.fc_in.weight": "pytorch_model-00002-of-00002.bin",
159
+ "decoder.transformer.h.23.mlp.fc_out.bias": "pytorch_model-00002-of-00002.bin",
160
+ "decoder.transformer.h.23.mlp.fc_out.weight": "pytorch_model-00002-of-00002.bin",
161
+ "decoder.transformer.h.24.attn.causal_mask": "pytorch_model-00002-of-00002.bin",
162
+ "decoder.transformer.h.24.attn.out_proj.weight": "pytorch_model-00002-of-00002.bin",
163
+ "decoder.transformer.h.24.attn.qkv_proj.weight": "pytorch_model-00002-of-00002.bin",
164
+ "decoder.transformer.h.24.ln_1.bias": "pytorch_model-00002-of-00002.bin",
165
+ "decoder.transformer.h.24.ln_1.weight": "pytorch_model-00002-of-00002.bin",
166
+ "decoder.transformer.h.24.mlp.fc_in.bias": "pytorch_model-00002-of-00002.bin",
167
+ "decoder.transformer.h.24.mlp.fc_in.weight": "pytorch_model-00002-of-00002.bin",
168
+ "decoder.transformer.h.24.mlp.fc_out.bias": "pytorch_model-00002-of-00002.bin",
169
+ "decoder.transformer.h.24.mlp.fc_out.weight": "pytorch_model-00002-of-00002.bin",
170
+ "decoder.transformer.h.25.attn.causal_mask": "pytorch_model-00002-of-00002.bin",
171
+ "decoder.transformer.h.25.attn.out_proj.weight": "pytorch_model-00002-of-00002.bin",
172
+ "decoder.transformer.h.25.attn.qkv_proj.weight": "pytorch_model-00002-of-00002.bin",
173
+ "decoder.transformer.h.25.ln_1.bias": "pytorch_model-00002-of-00002.bin",
174
+ "decoder.transformer.h.25.ln_1.weight": "pytorch_model-00002-of-00002.bin",
175
+ "decoder.transformer.h.25.mlp.fc_in.bias": "pytorch_model-00002-of-00002.bin",
176
+ "decoder.transformer.h.25.mlp.fc_in.weight": "pytorch_model-00002-of-00002.bin",
177
+ "decoder.transformer.h.25.mlp.fc_out.bias": "pytorch_model-00002-of-00002.bin",
178
+ "decoder.transformer.h.25.mlp.fc_out.weight": "pytorch_model-00002-of-00002.bin",
179
+ "decoder.transformer.h.26.attn.causal_mask": "pytorch_model-00002-of-00002.bin",
180
+ "decoder.transformer.h.26.attn.out_proj.weight": "pytorch_model-00002-of-00002.bin",
181
+ "decoder.transformer.h.26.attn.qkv_proj.weight": "pytorch_model-00002-of-00002.bin",
182
+ "decoder.transformer.h.26.ln_1.bias": "pytorch_model-00002-of-00002.bin",
183
+ "decoder.transformer.h.26.ln_1.weight": "pytorch_model-00002-of-00002.bin",
184
+ "decoder.transformer.h.26.mlp.fc_in.bias": "pytorch_model-00002-of-00002.bin",
185
+ "decoder.transformer.h.26.mlp.fc_in.weight": "pytorch_model-00002-of-00002.bin",
186
+ "decoder.transformer.h.26.mlp.fc_out.bias": "pytorch_model-00002-of-00002.bin",
187
+ "decoder.transformer.h.26.mlp.fc_out.weight": "pytorch_model-00002-of-00002.bin",
188
+ "decoder.transformer.h.27.attn.causal_mask": "pytorch_model-00002-of-00002.bin",
189
+ "decoder.transformer.h.27.attn.out_proj.weight": "pytorch_model-00002-of-00002.bin",
190
+ "decoder.transformer.h.27.attn.qkv_proj.weight": "pytorch_model-00002-of-00002.bin",
191
+ "decoder.transformer.h.27.ln_1.bias": "pytorch_model-00002-of-00002.bin",
192
+ "decoder.transformer.h.27.ln_1.weight": "pytorch_model-00002-of-00002.bin",
193
+ "decoder.transformer.h.27.mlp.fc_in.bias": "pytorch_model-00002-of-00002.bin",
194
+ "decoder.transformer.h.27.mlp.fc_in.weight": "pytorch_model-00002-of-00002.bin",
195
+ "decoder.transformer.h.27.mlp.fc_out.bias": "pytorch_model-00002-of-00002.bin",
196
+ "decoder.transformer.h.27.mlp.fc_out.weight": "pytorch_model-00002-of-00002.bin",
197
+ "decoder.transformer.h.28.attn.causal_mask": "pytorch_model-00002-of-00002.bin",
198
+ "decoder.transformer.h.28.attn.out_proj.weight": "pytorch_model-00002-of-00002.bin",
199
+ "decoder.transformer.h.28.attn.qkv_proj.weight": "pytorch_model-00002-of-00002.bin",
200
+ "decoder.transformer.h.28.ln_1.bias": "pytorch_model-00002-of-00002.bin",
201
+ "decoder.transformer.h.28.ln_1.weight": "pytorch_model-00002-of-00002.bin",
202
+ "decoder.transformer.h.28.mlp.fc_in.bias": "pytorch_model-00002-of-00002.bin",
203
+ "decoder.transformer.h.28.mlp.fc_in.weight": "pytorch_model-00002-of-00002.bin",
204
+ "decoder.transformer.h.28.mlp.fc_out.bias": "pytorch_model-00002-of-00002.bin",
205
+ "decoder.transformer.h.28.mlp.fc_out.weight": "pytorch_model-00002-of-00002.bin",
206
+ "decoder.transformer.h.29.attn.causal_mask": "pytorch_model-00002-of-00002.bin",
207
+ "decoder.transformer.h.29.attn.out_proj.weight": "pytorch_model-00002-of-00002.bin",
208
+ "decoder.transformer.h.29.attn.qkv_proj.weight": "pytorch_model-00002-of-00002.bin",
209
+ "decoder.transformer.h.29.ln_1.bias": "pytorch_model-00002-of-00002.bin",
210
+ "decoder.transformer.h.29.ln_1.weight": "pytorch_model-00002-of-00002.bin",
211
+ "decoder.transformer.h.29.mlp.fc_in.bias": "pytorch_model-00002-of-00002.bin",
212
+ "decoder.transformer.h.29.mlp.fc_in.weight": "pytorch_model-00002-of-00002.bin",
213
+ "decoder.transformer.h.29.mlp.fc_out.bias": "pytorch_model-00002-of-00002.bin",
214
+ "decoder.transformer.h.29.mlp.fc_out.weight": "pytorch_model-00002-of-00002.bin",
215
+ "decoder.transformer.h.3.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
216
+ "decoder.transformer.h.3.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
217
+ "decoder.transformer.h.3.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
218
+ "decoder.transformer.h.3.ln_1.bias": "pytorch_model-00001-of-00002.bin",
219
+ "decoder.transformer.h.3.ln_1.weight": "pytorch_model-00001-of-00002.bin",
220
+ "decoder.transformer.h.3.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
221
+ "decoder.transformer.h.3.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
222
+ "decoder.transformer.h.3.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
223
+ "decoder.transformer.h.3.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
224
+ "decoder.transformer.h.30.attn.causal_mask": "pytorch_model-00002-of-00002.bin",
225
+ "decoder.transformer.h.30.attn.out_proj.weight": "pytorch_model-00002-of-00002.bin",
226
+ "decoder.transformer.h.30.attn.qkv_proj.weight": "pytorch_model-00002-of-00002.bin",
227
+ "decoder.transformer.h.30.ln_1.bias": "pytorch_model-00002-of-00002.bin",
228
+ "decoder.transformer.h.30.ln_1.weight": "pytorch_model-00002-of-00002.bin",
229
+ "decoder.transformer.h.30.mlp.fc_in.bias": "pytorch_model-00002-of-00002.bin",
230
+ "decoder.transformer.h.30.mlp.fc_in.weight": "pytorch_model-00002-of-00002.bin",
231
+ "decoder.transformer.h.30.mlp.fc_out.bias": "pytorch_model-00002-of-00002.bin",
232
+ "decoder.transformer.h.30.mlp.fc_out.weight": "pytorch_model-00002-of-00002.bin",
233
+ "decoder.transformer.h.31.attn.causal_mask": "pytorch_model-00002-of-00002.bin",
234
+ "decoder.transformer.h.31.attn.out_proj.weight": "pytorch_model-00002-of-00002.bin",
235
+ "decoder.transformer.h.31.attn.qkv_proj.weight": "pytorch_model-00002-of-00002.bin",
236
+ "decoder.transformer.h.31.ln_1.bias": "pytorch_model-00002-of-00002.bin",
237
+ "decoder.transformer.h.31.ln_1.weight": "pytorch_model-00002-of-00002.bin",
238
+ "decoder.transformer.h.31.mlp.fc_in.bias": "pytorch_model-00002-of-00002.bin",
239
+ "decoder.transformer.h.31.mlp.fc_in.weight": "pytorch_model-00002-of-00002.bin",
240
+ "decoder.transformer.h.31.mlp.fc_out.bias": "pytorch_model-00002-of-00002.bin",
241
+ "decoder.transformer.h.31.mlp.fc_out.weight": "pytorch_model-00002-of-00002.bin",
242
+ "decoder.transformer.h.32.attn.causal_mask": "pytorch_model-00002-of-00002.bin",
243
+ "decoder.transformer.h.32.attn.out_proj.weight": "pytorch_model-00002-of-00002.bin",
244
+ "decoder.transformer.h.32.attn.qkv_proj.weight": "pytorch_model-00002-of-00002.bin",
245
+ "decoder.transformer.h.32.crossattention.causal_mask": "pytorch_model-00002-of-00002.bin",
246
+ "decoder.transformer.h.32.crossattention.out_proj.weight": "pytorch_model-00002-of-00002.bin",
247
+ "decoder.transformer.h.32.crossattention.q_attn.weight": "pytorch_model-00002-of-00002.bin",
248
+ "decoder.transformer.h.32.crossattention.qkv_proj.weight": "pytorch_model-00002-of-00002.bin",
249
+ "decoder.transformer.h.32.ln_1.bias": "pytorch_model-00002-of-00002.bin",
250
+ "decoder.transformer.h.32.ln_1.weight": "pytorch_model-00002-of-00002.bin",
251
+ "decoder.transformer.h.32.mlp.fc_in.bias": "pytorch_model-00002-of-00002.bin",
252
+ "decoder.transformer.h.32.mlp.fc_in.weight": "pytorch_model-00002-of-00002.bin",
253
+ "decoder.transformer.h.32.mlp.fc_out.bias": "pytorch_model-00002-of-00002.bin",
254
+ "decoder.transformer.h.32.mlp.fc_out.weight": "pytorch_model-00002-of-00002.bin",
255
+ "decoder.transformer.h.4.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
256
+ "decoder.transformer.h.4.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
257
+ "decoder.transformer.h.4.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
258
+ "decoder.transformer.h.4.ln_1.bias": "pytorch_model-00001-of-00002.bin",
259
+ "decoder.transformer.h.4.ln_1.weight": "pytorch_model-00001-of-00002.bin",
260
+ "decoder.transformer.h.4.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
261
+ "decoder.transformer.h.4.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
262
+ "decoder.transformer.h.4.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
263
+ "decoder.transformer.h.4.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
264
+ "decoder.transformer.h.5.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
265
+ "decoder.transformer.h.5.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
266
+ "decoder.transformer.h.5.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
267
+ "decoder.transformer.h.5.ln_1.bias": "pytorch_model-00001-of-00002.bin",
268
+ "decoder.transformer.h.5.ln_1.weight": "pytorch_model-00001-of-00002.bin",
269
+ "decoder.transformer.h.5.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
270
+ "decoder.transformer.h.5.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
271
+ "decoder.transformer.h.5.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
272
+ "decoder.transformer.h.5.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
273
+ "decoder.transformer.h.6.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
274
+ "decoder.transformer.h.6.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
275
+ "decoder.transformer.h.6.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
276
+ "decoder.transformer.h.6.ln_1.bias": "pytorch_model-00001-of-00002.bin",
277
+ "decoder.transformer.h.6.ln_1.weight": "pytorch_model-00001-of-00002.bin",
278
+ "decoder.transformer.h.6.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
279
+ "decoder.transformer.h.6.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
280
+ "decoder.transformer.h.6.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
281
+ "decoder.transformer.h.6.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
282
+ "decoder.transformer.h.7.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
283
+ "decoder.transformer.h.7.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
284
+ "decoder.transformer.h.7.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
285
+ "decoder.transformer.h.7.ln_1.bias": "pytorch_model-00001-of-00002.bin",
286
+ "decoder.transformer.h.7.ln_1.weight": "pytorch_model-00001-of-00002.bin",
287
+ "decoder.transformer.h.7.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
288
+ "decoder.transformer.h.7.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
289
+ "decoder.transformer.h.7.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
290
+ "decoder.transformer.h.7.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
291
+ "decoder.transformer.h.8.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
292
+ "decoder.transformer.h.8.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
293
+ "decoder.transformer.h.8.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
294
+ "decoder.transformer.h.8.ln_1.bias": "pytorch_model-00001-of-00002.bin",
295
+ "decoder.transformer.h.8.ln_1.weight": "pytorch_model-00001-of-00002.bin",
296
+ "decoder.transformer.h.8.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
297
+ "decoder.transformer.h.8.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
298
+ "decoder.transformer.h.8.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
299
+ "decoder.transformer.h.8.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
300
+ "decoder.transformer.h.9.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
301
+ "decoder.transformer.h.9.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
302
+ "decoder.transformer.h.9.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
303
+ "decoder.transformer.h.9.ln_1.bias": "pytorch_model-00001-of-00002.bin",
304
+ "decoder.transformer.h.9.ln_1.weight": "pytorch_model-00001-of-00002.bin",
305
+ "decoder.transformer.h.9.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
306
+ "decoder.transformer.h.9.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
307
+ "decoder.transformer.h.9.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
308
+ "decoder.transformer.h.9.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
309
+ "decoder.transformer.ln_f.bias": "pytorch_model-00002-of-00002.bin",
310
+ "decoder.transformer.ln_f.weight": "pytorch_model-00002-of-00002.bin",
311
+ "decoder.transformer.wte.weight": "pytorch_model-00001-of-00002.bin",
312
+ "enc_to_dec_proj.bias": "pytorch_model-00002-of-00002.bin",
313
+ "enc_to_dec_proj.weight": "pytorch_model-00002-of-00002.bin",
314
+ "encoder.h.0.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
315
+ "encoder.h.0.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
316
+ "encoder.h.0.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
317
+ "encoder.h.0.ln_1.bias": "pytorch_model-00001-of-00002.bin",
318
+ "encoder.h.0.ln_1.weight": "pytorch_model-00001-of-00002.bin",
319
+ "encoder.h.0.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
320
+ "encoder.h.0.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
321
+ "encoder.h.0.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
322
+ "encoder.h.0.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
323
+ "encoder.h.1.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
324
+ "encoder.h.1.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
325
+ "encoder.h.1.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
326
+ "encoder.h.1.ln_1.bias": "pytorch_model-00001-of-00002.bin",
327
+ "encoder.h.1.ln_1.weight": "pytorch_model-00001-of-00002.bin",
328
+ "encoder.h.1.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
329
+ "encoder.h.1.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
330
+ "encoder.h.1.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
331
+ "encoder.h.1.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
332
+ "encoder.h.10.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
333
+ "encoder.h.10.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
334
+ "encoder.h.10.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
335
+ "encoder.h.10.ln_1.bias": "pytorch_model-00001-of-00002.bin",
336
+ "encoder.h.10.ln_1.weight": "pytorch_model-00001-of-00002.bin",
337
+ "encoder.h.10.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
338
+ "encoder.h.10.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
339
+ "encoder.h.10.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
340
+ "encoder.h.10.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
341
+ "encoder.h.11.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
342
+ "encoder.h.11.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
343
+ "encoder.h.11.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
344
+ "encoder.h.11.ln_1.bias": "pytorch_model-00001-of-00002.bin",
345
+ "encoder.h.11.ln_1.weight": "pytorch_model-00001-of-00002.bin",
346
+ "encoder.h.11.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
347
+ "encoder.h.11.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
348
+ "encoder.h.11.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
349
+ "encoder.h.11.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
350
+ "encoder.h.12.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
351
+ "encoder.h.12.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
352
+ "encoder.h.12.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
353
+ "encoder.h.12.ln_1.bias": "pytorch_model-00001-of-00002.bin",
354
+ "encoder.h.12.ln_1.weight": "pytorch_model-00001-of-00002.bin",
355
+ "encoder.h.12.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
356
+ "encoder.h.12.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
357
+ "encoder.h.12.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
358
+ "encoder.h.12.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
359
+ "encoder.h.13.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
360
+ "encoder.h.13.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
361
+ "encoder.h.13.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
362
+ "encoder.h.13.ln_1.bias": "pytorch_model-00001-of-00002.bin",
363
+ "encoder.h.13.ln_1.weight": "pytorch_model-00001-of-00002.bin",
364
+ "encoder.h.13.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
365
+ "encoder.h.13.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
366
+ "encoder.h.13.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
367
+ "encoder.h.13.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
368
+ "encoder.h.14.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
369
+ "encoder.h.14.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
370
+ "encoder.h.14.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
371
+ "encoder.h.14.ln_1.bias": "pytorch_model-00001-of-00002.bin",
372
+ "encoder.h.14.ln_1.weight": "pytorch_model-00001-of-00002.bin",
373
+ "encoder.h.14.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
374
+ "encoder.h.14.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
375
+ "encoder.h.14.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
376
+ "encoder.h.14.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
377
+ "encoder.h.15.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
378
+ "encoder.h.15.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
379
+ "encoder.h.15.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
380
+ "encoder.h.15.ln_1.bias": "pytorch_model-00001-of-00002.bin",
381
+ "encoder.h.15.ln_1.weight": "pytorch_model-00001-of-00002.bin",
382
+ "encoder.h.15.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
383
+ "encoder.h.15.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
384
+ "encoder.h.15.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
385
+ "encoder.h.15.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
386
+ "encoder.h.16.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
387
+ "encoder.h.16.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
388
+ "encoder.h.16.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
389
+ "encoder.h.16.ln_1.bias": "pytorch_model-00001-of-00002.bin",
390
+ "encoder.h.16.ln_1.weight": "pytorch_model-00001-of-00002.bin",
391
+ "encoder.h.16.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
392
+ "encoder.h.16.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
393
+ "encoder.h.16.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
394
+ "encoder.h.16.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
395
+ "encoder.h.17.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
396
+ "encoder.h.17.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
397
+ "encoder.h.17.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
398
+ "encoder.h.17.ln_1.bias": "pytorch_model-00001-of-00002.bin",
399
+ "encoder.h.17.ln_1.weight": "pytorch_model-00001-of-00002.bin",
400
+ "encoder.h.17.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
401
+ "encoder.h.17.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
402
+ "encoder.h.17.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
403
+ "encoder.h.17.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
404
+ "encoder.h.18.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
405
+ "encoder.h.18.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
406
+ "encoder.h.18.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
407
+ "encoder.h.18.ln_1.bias": "pytorch_model-00001-of-00002.bin",
408
+ "encoder.h.18.ln_1.weight": "pytorch_model-00001-of-00002.bin",
409
+ "encoder.h.18.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
410
+ "encoder.h.18.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
411
+ "encoder.h.18.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
412
+ "encoder.h.18.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
413
+ "encoder.h.19.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
414
+ "encoder.h.19.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
415
+ "encoder.h.19.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
416
+ "encoder.h.19.ln_1.bias": "pytorch_model-00001-of-00002.bin",
417
+ "encoder.h.19.ln_1.weight": "pytorch_model-00001-of-00002.bin",
418
+ "encoder.h.19.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
419
+ "encoder.h.19.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
420
+ "encoder.h.19.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
421
+ "encoder.h.19.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
422
+ "encoder.h.2.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
423
+ "encoder.h.2.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
424
+ "encoder.h.2.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
425
+ "encoder.h.2.ln_1.bias": "pytorch_model-00001-of-00002.bin",
426
+ "encoder.h.2.ln_1.weight": "pytorch_model-00001-of-00002.bin",
427
+ "encoder.h.2.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
428
+ "encoder.h.2.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
429
+ "encoder.h.2.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
430
+ "encoder.h.2.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
431
+ "encoder.h.3.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
432
+ "encoder.h.3.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
433
+ "encoder.h.3.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
434
+ "encoder.h.3.ln_1.bias": "pytorch_model-00001-of-00002.bin",
435
+ "encoder.h.3.ln_1.weight": "pytorch_model-00001-of-00002.bin",
436
+ "encoder.h.3.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
437
+ "encoder.h.3.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
438
+ "encoder.h.3.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
439
+ "encoder.h.3.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
440
+ "encoder.h.4.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
441
+ "encoder.h.4.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
442
+ "encoder.h.4.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
443
+ "encoder.h.4.ln_1.bias": "pytorch_model-00001-of-00002.bin",
444
+ "encoder.h.4.ln_1.weight": "pytorch_model-00001-of-00002.bin",
445
+ "encoder.h.4.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
446
+ "encoder.h.4.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
447
+ "encoder.h.4.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
448
+ "encoder.h.4.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
449
+ "encoder.h.5.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
450
+ "encoder.h.5.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
451
+ "encoder.h.5.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
452
+ "encoder.h.5.ln_1.bias": "pytorch_model-00001-of-00002.bin",
453
+ "encoder.h.5.ln_1.weight": "pytorch_model-00001-of-00002.bin",
454
+ "encoder.h.5.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
455
+ "encoder.h.5.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
456
+ "encoder.h.5.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
457
+ "encoder.h.5.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
458
+ "encoder.h.6.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
459
+ "encoder.h.6.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
460
+ "encoder.h.6.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
461
+ "encoder.h.6.ln_1.bias": "pytorch_model-00001-of-00002.bin",
462
+ "encoder.h.6.ln_1.weight": "pytorch_model-00001-of-00002.bin",
463
+ "encoder.h.6.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
464
+ "encoder.h.6.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
465
+ "encoder.h.6.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
466
+ "encoder.h.6.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
467
+ "encoder.h.7.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
468
+ "encoder.h.7.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
469
+ "encoder.h.7.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
470
+ "encoder.h.7.ln_1.bias": "pytorch_model-00001-of-00002.bin",
471
+ "encoder.h.7.ln_1.weight": "pytorch_model-00001-of-00002.bin",
472
+ "encoder.h.7.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
473
+ "encoder.h.7.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
474
+ "encoder.h.7.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
475
+ "encoder.h.7.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
476
+ "encoder.h.8.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
477
+ "encoder.h.8.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
478
+ "encoder.h.8.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
479
+ "encoder.h.8.ln_1.bias": "pytorch_model-00001-of-00002.bin",
480
+ "encoder.h.8.ln_1.weight": "pytorch_model-00001-of-00002.bin",
481
+ "encoder.h.8.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
482
+ "encoder.h.8.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
483
+ "encoder.h.8.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
484
+ "encoder.h.8.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
485
+ "encoder.h.9.attn.causal_mask": "pytorch_model-00001-of-00002.bin",
486
+ "encoder.h.9.attn.out_proj.weight": "pytorch_model-00001-of-00002.bin",
487
+ "encoder.h.9.attn.qkv_proj.weight": "pytorch_model-00001-of-00002.bin",
488
+ "encoder.h.9.ln_1.bias": "pytorch_model-00001-of-00002.bin",
489
+ "encoder.h.9.ln_1.weight": "pytorch_model-00001-of-00002.bin",
490
+ "encoder.h.9.mlp.fc_in.bias": "pytorch_model-00001-of-00002.bin",
491
+ "encoder.h.9.mlp.fc_in.weight": "pytorch_model-00001-of-00002.bin",
492
+ "encoder.h.9.mlp.fc_out.bias": "pytorch_model-00001-of-00002.bin",
493
+ "encoder.h.9.mlp.fc_out.weight": "pytorch_model-00001-of-00002.bin",
494
+ "encoder.ln_f.bias": "pytorch_model-00001-of-00002.bin",
495
+ "encoder.ln_f.weight": "pytorch_model-00001-of-00002.bin",
496
+ "encoder.wte.weight": "pytorch_model-00001-of-00002.bin"
497
+ }
498
+ }
special_tokens_map.json ADDED
@@ -0,0 +1,6 @@
 
 
 
 
 
 
 
1
+ {
2
+ "bos_token": "<|endoftext|>",
3
+ "eos_token": "<|endoftext|>",
4
+ "pad_token": "<|endoftext|>",
5
+ "unk_token": "<|endoftext|>"
6
+ }
tokenizer.json ADDED
The diff for this file is too large to render. See raw diff
 
tokenizer_config.json ADDED
@@ -0,0 +1,10 @@
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "add_prefix_space": false,
3
+ "bos_token": "<|endoftext|>",
4
+ "eos_token": "<|endoftext|>",
5
+ "model_max_length": 2048,
6
+ "name_or_path": "Salesforce/instructcodet5p-16b",
7
+ "special_tokens_map_file": null,
8
+ "tokenizer_class": "CodeGenTokenizer",
9
+ "unk_token": "<|endoftext|>"
10
+ }
vocab.json ADDED
The diff for this file is too large to render. See raw diff