malteos commited on
Commit
2abcf11
0 Parent(s):

config files

Browse files
config.json ADDED
@@ -0,0 +1,29 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "alibi": false,
3
+ "apply_residual_connection_post_layernorm": false,
4
+ "architectures": [
5
+ "MegLMForCausalLM"
6
+ ],
7
+ "auto_map": {
8
+ "AutoConfig": "configuration_meglm.MegLMConfig",
9
+ "AutoModel": "modeling_meglm.MegLMModel",
10
+ "AutoModelForCausalLM": "modeling_meglm.MegLMForCausalLM"
11
+ },
12
+ "attention_dropout": 0.0,
13
+ "bias": true,
14
+ "bos_token_id": 1,
15
+ "eos_token_id": 2,
16
+ "hidden_dropout": 0.0,
17
+ "hidden_size": 2560,
18
+ "initializer_range": 0.02,
19
+ "layer_norm_epsilon": 1e-05,
20
+ "model_type": "MegLMModel",
21
+ "multi_query": false,
22
+ "n_head": 32,
23
+ "n_layer": 32,
24
+ "parallel_attn": false,
25
+ "torch_dtype": "bfloat16",
26
+ "transformers_version": "4.29.0",
27
+ "use_cache": true,
28
+ "vocab_size": 32768
29
+ }
configuration_meglm.py ADDED
@@ -0,0 +1,79 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # coding=utf-8
2
+ # Copyright 2022 the Big Science Workshop and HuggingFace Inc. team. All rights reserved.
3
+ #
4
+ # Licensed under the Apache License, Version 2.0 (the "License");
5
+ # you may not use this file except in compliance with the License.
6
+ # You may obtain a copy of the License at
7
+ #
8
+ # http://www.apache.org/licenses/LICENSE-2.0
9
+ #
10
+ # Unless required by applicable law or agreed to in writing, software
11
+ # distributed under the License is distributed on an "AS IS" BASIS,
12
+ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
+ # See the License for the specific language governing permissions and
14
+ # limitations under the License.
15
+ """ Bloom configuration"""
16
+ from transformers.configuration_utils import PretrainedConfig
17
+ from transformers.utils import logging
18
+
19
+
20
+ logger = logging.get_logger(__name__)
21
+
22
+
23
+ class MegLMConfig(PretrainedConfig):
24
+ model_type = "MegLMModel"
25
+ keys_to_ignore_at_inference = ["past_key_values"]
26
+ attribute_map = {
27
+ "num_hidden_layers": "n_layer",
28
+ "num_attention_heads": "n_head",
29
+ }
30
+
31
+ def __init__(
32
+ self,
33
+ vocab_size=250880,
34
+ hidden_size=64,
35
+ n_layer=2,
36
+ n_head=8,
37
+ layer_norm_epsilon=1e-5,
38
+ initializer_range=0.02,
39
+ use_cache=True,
40
+ bos_token_id=1,
41
+ eos_token_id=2,
42
+ apply_residual_connection_post_layernorm=False,
43
+ hidden_dropout=0.0,
44
+ attention_dropout=0.0,
45
+ multi_query=False,
46
+ alibi=False,
47
+ bias=False,
48
+ parallel_attn=False,
49
+ **kwargs,
50
+ ):
51
+ self.vocab_size = vocab_size
52
+ # Backward compatibility with n_embed kwarg
53
+ n_embed = kwargs.pop("n_embed", None)
54
+ self.hidden_size = hidden_size if n_embed is None else n_embed
55
+ self.n_layer = n_layer
56
+ self.n_head = n_head
57
+ self.layer_norm_epsilon = layer_norm_epsilon
58
+ self.initializer_range = initializer_range
59
+ self.use_cache = use_cache
60
+ self.apply_residual_connection_post_layernorm = apply_residual_connection_post_layernorm
61
+ self.hidden_dropout = hidden_dropout
62
+ self.attention_dropout = attention_dropout
63
+
64
+ self.bos_token_id = bos_token_id
65
+ self.eos_token_id = eos_token_id
66
+ self.multi_query = multi_query
67
+ self.alibi = alibi
68
+ self.bias = bias
69
+ self.parallel_attn = parallel_attn
70
+
71
+ super().__init__(bos_token_id=bos_token_id, eos_token_id=eos_token_id, **kwargs)
72
+
73
+ @property
74
+ def head_dim(self):
75
+ return self.hidden_size // self.n_head
76
+
77
+ @property
78
+ def rotary(self):
79
+ return not self.alibi
generation_config.json ADDED
@@ -0,0 +1,6 @@
 
 
 
 
 
 
 
1
+ {
2
+ "_from_model_config": true,
3
+ "bos_token_id": 1,
4
+ "eos_token_id": 2,
5
+ "transformers_version": "4.29.0"
6
+ }
modeling_meglm.py ADDED
@@ -0,0 +1,818 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # port of models described in RW
2
+ # We use the bloom model as a starting point for these model.
3
+ # Please refer to the bloom models for usage instructions.
4
+
5
+ import math
6
+ import warnings
7
+ from typing import Optional, Tuple, Union
8
+
9
+ import torch
10
+ import torch.utils.checkpoint
11
+ from torch import nn
12
+ from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, LayerNorm, MSELoss
13
+ from torch.nn import functional as F
14
+
15
+ from transformers.modeling_outputs import (
16
+ BaseModelOutputWithPastAndCrossAttentions,
17
+ CausalLMOutputWithCrossAttentions,
18
+ QuestionAnsweringModelOutput,
19
+ SequenceClassifierOutputWithPast,
20
+ TokenClassifierOutput,
21
+ )
22
+ from transformers.modeling_utils import PreTrainedModel
23
+ from transformers.utils import logging
24
+ from .configuration_meglm import MegLMConfig
25
+
26
+ logger = logging.get_logger(__name__)
27
+
28
+ # NOTE(Hesslow): Unfortunately we did not fuse matmul and bias during training, this means that there's one additional quantization to bfloat16 between the operations.
29
+ # In order not to degrade the quality of our HF-port, we keep these characteristics in the final model.
30
+ class Linear(nn.Linear):
31
+ def forward(self, input: torch.Tensor) -> torch.Tensor:
32
+ ret = input @ self.weight.T
33
+ if self.bias is None:
34
+ return ret
35
+ else:
36
+ return ret + self.bias
37
+
38
+
39
+ from einops import rearrange
40
+
41
+ # rotary pos emb helpers (torch.jit.script does not seem to support staticmethod...)
42
+ def rotate_half(x):
43
+ x1, x2 = x[..., : x.shape[-1] // 2], x[..., x.shape[-1] // 2 :]
44
+ return torch.cat((-x2, x1), dim=x1.ndim - 1) # dim=-1 triggers a bug in torch < 1.8.0
45
+
46
+
47
+ class RotaryEmbedding(torch.nn.Module):
48
+ """Implementation of RotaryEmbedding from GPT-NeoX.
49
+ This implementation is design to operate on queries and keys that are compatible with
50
+ [batch_size, n_heads_per_partition, seq_len, head_dim] (e.g. MinGPTAttention format).
51
+ """
52
+
53
+ def __init__(
54
+ self,
55
+ head_dim: int,
56
+ base=10000,
57
+ ):
58
+ super().__init__()
59
+ inv_freq = 1.0 / (base ** (torch.arange(0, head_dim, 2).float() / head_dim))
60
+ self.register_buffer("inv_freq", inv_freq, persistent=False)
61
+ self.head_dim = head_dim
62
+ self.seq_len_cached = None
63
+ self.batch_size_cached = None
64
+ self.cos_cached: torch.Tensor | None = None
65
+ self.sin_cached: torch.Tensor | None = None
66
+
67
+ def cos_sin(
68
+ self,
69
+ seq_len: int,
70
+ device="cuda",
71
+ dtype=torch.bfloat16,
72
+ ) -> torch.Tensor:
73
+ if seq_len != self.seq_len_cached:
74
+ self.seq_len_cached = seq_len
75
+ t = torch.arange(seq_len, device=device).type_as(self.inv_freq)
76
+ freqs = torch.einsum("i,j->ij", t, self.inv_freq)
77
+ emb = torch.cat((freqs, freqs), dim=-1).to(device)
78
+
79
+ if dtype in [torch.float16, torch.bfloat16]:
80
+ emb = emb.float()
81
+
82
+ self.cos_cached = emb.cos()[None, :, :]
83
+ self.sin_cached = emb.sin()[None, :, :]
84
+
85
+ self.cos_cached = self.cos_cached.type(dtype)
86
+ self.sin_cached = self.sin_cached.type(dtype)
87
+
88
+ return self.cos_cached, self.sin_cached
89
+
90
+ def forward(self, q, k):
91
+ batch, seq_len, head_dim = q.shape
92
+ cos, sin = self.cos_sin(seq_len, q.device, q.dtype)
93
+ return (q * cos) + (rotate_half(q) * sin), (k * cos) + (rotate_half(k) * sin)
94
+
95
+
96
+ def _make_causal_mask(
97
+ input_ids_shape: torch.Size, device: torch.device, past_key_values_length: int
98
+ ) -> torch.BoolTensor:
99
+ batch_size, target_length = input_ids_shape
100
+ mask = torch.empty((target_length, target_length + past_key_values_length), dtype=torch.bool, device=device)
101
+ # ONNX doesn't support `torch.Tensor.triu` properly, thus we use this workaround
102
+ seq_ids = torch.arange(target_length, device=device)
103
+ mask[:, past_key_values_length:] = seq_ids[:, None] < seq_ids[None, :]
104
+
105
+ if past_key_values_length > 0:
106
+ mask[:, :past_key_values_length] = False
107
+
108
+ expanded_mask = mask[None, None, :, :].expand(batch_size, 1, target_length, target_length + past_key_values_length)
109
+ return expanded_mask
110
+
111
+
112
+ def _expand_mask(mask: torch.Tensor, tgt_length: int) -> torch.BoolTensor:
113
+ batch_size, src_length = mask.shape
114
+ tgt_length = tgt_length if tgt_length is not None else src_length
115
+
116
+ expanded_mask = ~(mask[:, None, None, :].to(torch.bool))
117
+ return expanded_mask.expand(batch_size, 1, tgt_length, src_length)
118
+
119
+
120
+ def build_alibi_tensor(attention_mask: torch.Tensor, num_heads: int, dtype: torch.dtype) -> torch.Tensor:
121
+ batch_size, seq_length = attention_mask.shape
122
+ closest_power_of_2 = 2 ** math.floor(math.log2(num_heads))
123
+ base = torch.tensor(
124
+ 2 ** (-(2 ** -(math.log2(closest_power_of_2) - 3))), device=attention_mask.device, dtype=torch.float32
125
+ )
126
+ powers = torch.arange(1, 1 + closest_power_of_2, device=attention_mask.device, dtype=torch.int32)
127
+ slopes = torch.pow(base, powers)
128
+
129
+ if closest_power_of_2 != num_heads:
130
+ extra_base = torch.tensor(
131
+ 2 ** (-(2 ** -(math.log2(2 * closest_power_of_2) - 3))), device=attention_mask.device, dtype=torch.float32
132
+ )
133
+ num_remaining_heads = min(closest_power_of_2, num_heads - closest_power_of_2)
134
+ extra_powers = torch.arange(1, 1 + 2 * num_remaining_heads, 2, device=attention_mask.device, dtype=torch.int32)
135
+ slopes = torch.cat([slopes, torch.pow(extra_base, extra_powers)], dim=0)
136
+
137
+ # Note: alibi will added to the attention bias that will be applied to the query, key product of attention
138
+ # => therefore alibi will have to be of shape (batch_size, num_heads, query_length, key_length)
139
+ # => here we set (batch_size=1, num_heads=num_heads, query_length=1, key_length=max_length)
140
+ # => the query_length dimension will then be broadcasted correctly
141
+ # This is more or less identical to T5's relative position bias:
142
+ # https://github.com/huggingface/transformers/blob/f681437203baa7671de3174b0fa583c349d9d5e1/src/transformers/models/t5/modeling_t5.py#L527
143
+ arange_tensor = ((attention_mask.cumsum(dim=-1) - 1) * attention_mask)[:, None, :]
144
+ alibi = slopes[..., None].bfloat16() * arange_tensor
145
+ return alibi.reshape(batch_size * num_heads, 1, seq_length).to(dtype)
146
+
147
+
148
+ def dropout_add(x: torch.Tensor, residual: torch.Tensor, prob: float, training: bool) -> torch.Tensor:
149
+ out = F.dropout(x, p=prob, training=training)
150
+ out = residual + out
151
+ return out
152
+
153
+
154
+ class Attention(nn.Module):
155
+ def __init__(self, config: MegLMConfig):
156
+ super().__init__()
157
+
158
+ self.hidden_size = config.hidden_size
159
+ self.num_heads = config.n_head
160
+ self.head_dim = self.hidden_size // self.num_heads
161
+ self.split_size = self.hidden_size
162
+ self.hidden_dropout = config.hidden_dropout
163
+
164
+ if self.head_dim * self.num_heads != self.hidden_size:
165
+ raise ValueError(
166
+ f"`hidden_size` must be divisible by num_heads (got `hidden_size`: {self.hidden_size} and `num_heads`:"
167
+ f" {self.num_heads})."
168
+ )
169
+
170
+ self.maybe_rotary = RotaryEmbedding(config.head_dim) if config.rotary else lambda q, k: (q, k)
171
+
172
+ # Layer-wise attention scaling
173
+ self.inv_norm_factor = 1.0 / math.sqrt(self.head_dim)
174
+ self.beta = self.inv_norm_factor
175
+
176
+ self.query_key_value = Linear(
177
+ self.hidden_size,
178
+ 3 * self.hidden_size if not config.multi_query else (self.hidden_size + 2 * self.head_dim),
179
+ bias=config.bias,
180
+ )
181
+ self.multi_query = config.multi_query
182
+ self.dense = Linear(self.hidden_size, self.hidden_size, bias=config.bias)
183
+ self.attention_dropout = nn.Dropout(config.attention_dropout)
184
+ self.num_kv = config.n_head if not self.multi_query else 1
185
+
186
+ def _split_heads(self, fused_qkv: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
187
+ """
188
+ Split the last dimension into (num_heads, head_dim) without making any copies, results share same memory
189
+ storage as `fused_qkv`
190
+
191
+ Args:
192
+ fused_qkv (`torch.tensor`, *required*): [batch_size, seq_length, num_heads * 3 * head_dim]
193
+
194
+ Returns:
195
+ query: [batch_size, seq_length, num_heads, head_dim] key: [batch_size, seq_length, num_heads, head_dim]
196
+ value: [batch_size, seq_length, num_heads, head_dim]
197
+ """
198
+ if not self.multi_query:
199
+ batch_size, seq_length, three_times_hidden_size = fused_qkv.shape
200
+ fused_qkv = fused_qkv.view(batch_size, seq_length, self.num_heads, 3, self.head_dim)
201
+ return fused_qkv[..., 0, :], fused_qkv[..., 1, :], fused_qkv[..., 2, :]
202
+ else:
203
+ batch_size, seq_length, three_times_hidden_size = fused_qkv.shape
204
+ fused_qkv = fused_qkv.view(batch_size, seq_length, self.num_heads + 2, self.head_dim)
205
+ return fused_qkv[..., :-2, :], fused_qkv[..., [-2], :], fused_qkv[..., [-1], :]
206
+
207
+ def _merge_heads(self, x: torch.Tensor) -> torch.Tensor:
208
+ """
209
+ Merge heads together over the last dimenstion
210
+
211
+ Args:
212
+ x: (`torch.tensor`, *required*): [batch_size * num_heads, seq_length, head_dim]
213
+
214
+ Returns:
215
+ torch.tensor: [batch_size, seq_length, num_heads * head_dim]
216
+ """
217
+ # What we want to achieve is:
218
+ # batch_size * num_heads, seq_length, head_dim -> batch_size, seq_length, num_heads * head_dim
219
+ batch_size_and_num_heads, seq_length, _ = x.shape
220
+ batch_size = batch_size_and_num_heads // self.num_heads
221
+
222
+ # First view to decompose the batch size
223
+ # batch_size * num_heads, seq_length, head_dim -> batch_size, num_heads, seq_length, head_dim
224
+ x = x.view(batch_size, self.num_heads, seq_length, self.head_dim)
225
+
226
+ # batch_size, num_heads, seq_length, head_dim -> batch_size, seq_length, num_heads, head_dim
227
+ x = x.permute(0, 2, 1, 3)
228
+
229
+ # batch_size, seq_length, num_heads, head_dim -> batch_size, seq_length, num_heads * head_dim
230
+ return x.reshape(batch_size, seq_length, self.num_heads * self.head_dim)
231
+
232
+ def forward(
233
+ self,
234
+ hidden_states: torch.Tensor,
235
+ alibi: torch.Tensor,
236
+ attention_mask: torch.Tensor,
237
+ layer_past: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,
238
+ head_mask: Optional[torch.Tensor] = None,
239
+ use_cache: bool = False,
240
+ output_attentions: bool = False,
241
+ ):
242
+ fused_qkv = self.query_key_value(hidden_states) # [batch_size, seq_length, 3 x hidden_size]
243
+
244
+ # 3 x [batch_size, seq_length, num_heads, head_dim]
245
+ (query_layer, key_layer, value_layer) = self._split_heads(fused_qkv)
246
+
247
+ batch_size, q_length, _, _ = query_layer.shape
248
+
249
+ query_layer = query_layer.transpose(1, 2).reshape(batch_size * self.num_heads, q_length, self.head_dim)
250
+ key_layer = key_layer.transpose(1, 2).reshape(
251
+ batch_size * self.num_kv,
252
+ q_length,
253
+ self.head_dim,
254
+ )
255
+ value_layer = value_layer.transpose(1, 2).reshape(batch_size * self.num_kv, q_length, self.head_dim)
256
+
257
+ query_layer, key_layer = self.maybe_rotary(query_layer, key_layer)
258
+
259
+ if layer_past is not None:
260
+ past_key, past_value = layer_past
261
+ # concatenate along seq_length dimension:
262
+ # - key: [batch_size * self.num_heads, head_dim, kv_length]
263
+ # - value: [batch_size * self.num_heads, kv_length, head_dim]
264
+ key_layer = torch.cat((past_key, key_layer), dim=1)
265
+ value_layer = torch.cat((past_value, value_layer), dim=1)
266
+
267
+ _, kv_length, _ = key_layer.shape
268
+
269
+ if use_cache is True:
270
+ present = (key_layer, value_layer)
271
+ else:
272
+ present = None
273
+
274
+ if alibi is None:
275
+ query_layer_ = query_layer.reshape(batch_size, self.num_heads, -1, self.head_dim)
276
+ key_layer_ = key_layer.reshape(batch_size, self.num_kv, -1, self.head_dim)
277
+ value_layer_ = value_layer.reshape(batch_size, self.num_kv, -1, self.head_dim)
278
+
279
+ attn_output = F.scaled_dot_product_attention(
280
+ query_layer_, key_layer_, value_layer_, None, 0.0, is_causal=True
281
+ )
282
+
283
+ x = attn_output.view(batch_size, self.num_heads, q_length, self.head_dim)
284
+ x = x.permute(0, 2, 1, 3)
285
+ attn_output = x.reshape(batch_size, q_length, self.num_heads * self.head_dim)
286
+
287
+ output_tensor = self.dense(attn_output)
288
+
289
+ outputs = (output_tensor, present)
290
+ assert not output_attentions # not supported.
291
+ return outputs
292
+ else:
293
+ attention_mask_float = (attention_mask * 1.0).masked_fill(attention_mask, -1e9).to(torch.bfloat16)
294
+ matmul_result = query_layer @ key_layer.transpose(-1, -2)
295
+
296
+ # change view to [batch_size, num_heads, q_length, kv_length]
297
+ attention_scores = matmul_result.view(batch_size, self.num_heads, q_length, kv_length)
298
+
299
+ # cast attention scores to fp32, compute scaled softmax and cast back to initial dtype - [batch_size, num_heads, q_length, kv_length]
300
+ input_dtype = attention_scores.dtype
301
+ # `float16` has a minimum value of -65504.0, whereas `bfloat16` and `float32` have a minimum value of `-3.4e+38`
302
+ if input_dtype == torch.float16 or input_dtype == torch.bfloat16:
303
+ attention_scores = attention_scores.to(torch.float32)
304
+ # attn_weights = torch.masked_fill(attention_scores, attention_mask, torch.finfo(attention_scores.dtype).min)
305
+ attention_probs = F.softmax(
306
+ (attention_scores + alibi.view(batch_size, self.num_heads, 1, -1)) * self.inv_norm_factor + attention_mask_float,
307
+ dim=-1,
308
+ dtype=hidden_states.dtype,
309
+ )
310
+ # [batch_size, num_heads, q_length, kv_length]
311
+ attention_probs = self.attention_dropout(attention_probs)
312
+
313
+ if head_mask is not None:
314
+ attention_probs = attention_probs * head_mask
315
+
316
+ # change view [batch_size x num_heads, q_length, kv_length]
317
+ attention_probs_reshaped = attention_probs.view(batch_size * self.num_heads, q_length, kv_length)
318
+
319
+ # matmul: [batch_size * num_heads, q_length, head_dim]
320
+ context_layer = attention_probs_reshaped @ value_layer
321
+
322
+ # change view [batch_size, num_heads, q_length, head_dim]
323
+ context_layer = self._merge_heads(context_layer)
324
+
325
+ output_tensor = self.dense(context_layer)
326
+
327
+ outputs = (output_tensor, present)
328
+ if output_attentions:
329
+ outputs += (attention_probs,)
330
+
331
+ return outputs
332
+
333
+
334
+ class MLP(nn.Module):
335
+ def __init__(self, config: MegLMConfig):
336
+ super().__init__()
337
+ hidden_size = config.hidden_size
338
+
339
+ self.dense_h_to_4h = Linear(hidden_size, 4 * hidden_size, bias=config.bias)
340
+ self.act = nn.GELU()
341
+ self.dense_4h_to_h = Linear(4 * hidden_size, hidden_size, bias=config.bias)
342
+ self.hidden_dropout = config.hidden_dropout
343
+
344
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
345
+ x = self.act(self.dense_h_to_4h(x))
346
+ x = self.dense_4h_to_h(x)
347
+ return x
348
+
349
+
350
+ class DecoderLayer(nn.Module):
351
+ def __init__(self, config: MegLMConfig):
352
+ super().__init__()
353
+ hidden_size = config.hidden_size
354
+
355
+ self.input_layernorm = LayerNorm(hidden_size, eps=config.layer_norm_epsilon)
356
+ self.num_heads = config.n_head
357
+ self.self_attention = Attention(config)
358
+
359
+ if not config.parallel_attn:
360
+ # unused if parallel attn
361
+ self.post_attention_layernorm = LayerNorm(hidden_size, eps=config.layer_norm_epsilon)
362
+
363
+ self.mlp = MLP(config)
364
+
365
+ self.apply_residual_connection_post_layernorm = config.apply_residual_connection_post_layernorm
366
+ self.hidden_dropout = config.hidden_dropout
367
+
368
+ self.config = config
369
+
370
+ def forward(
371
+ self,
372
+ hidden_states: torch.Tensor,
373
+ alibi: torch.Tensor,
374
+ attention_mask: torch.Tensor,
375
+ layer_past: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,
376
+ head_mask: Optional[torch.Tensor] = None,
377
+ use_cache: bool = False,
378
+ output_attentions: bool = False,
379
+ ):
380
+
381
+ layernorm_output = self.input_layernorm(hidden_states)
382
+ residual = hidden_states
383
+
384
+ # Self attention.
385
+ attn_outputs = self.self_attention(
386
+ layernorm_output,
387
+ layer_past=layer_past,
388
+ attention_mask=attention_mask,
389
+ alibi=alibi,
390
+ head_mask=head_mask,
391
+ use_cache=use_cache,
392
+ output_attentions=output_attentions,
393
+ )
394
+
395
+ attention_output = attn_outputs[0]
396
+
397
+ if not self.config.parallel_attn:
398
+ residual = dropout_add(attention_output, residual, self.config.attention_dropout, training=self.training)
399
+ layernorm_output = self.post_attention_layernorm(residual)
400
+
401
+ outputs = attn_outputs[1:]
402
+
403
+ # MLP.
404
+ mlp_output = self.mlp(layernorm_output)
405
+
406
+ if self.config.parallel_attn:
407
+ mlp_output += attention_output
408
+
409
+ output = dropout_add(mlp_output, residual, self.config.hidden_dropout, training=self.training)
410
+
411
+ if use_cache:
412
+ outputs = (output,) + outputs
413
+ else:
414
+ outputs = (output,) + outputs[1:]
415
+
416
+ return outputs # hidden_states, present, attentions
417
+
418
+
419
+ class MegLMPreTrainedModel(PreTrainedModel):
420
+ _keys_to_ignore_on_load_missing = [r"h.*.self_attention.scale_mask_softmax.causal_mask", r"lm_head.weight"]
421
+ """
422
+ An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
423
+ models.
424
+ """
425
+
426
+ config_class = MegLMConfig
427
+ base_model_prefix = "transformer"
428
+ supports_gradient_checkpointing = True
429
+ _no_split_modules = ["DecoderLayer"]
430
+
431
+ def __init__(self, *inputs, **kwargs):
432
+ super().__init__(*inputs, **kwargs)
433
+
434
+ def _init_weights(self, module: nn.Module):
435
+ """Initialize the weights."""
436
+ if isinstance(module, nn.Linear) or isinstance(module, Linear):
437
+ # Slightly different from the TF version which uses truncated_normal for initialization
438
+ # cf https://github.com/pytorch/pytorch/pull/5617
439
+ module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
440
+ if module.bias is not None:
441
+ module.bias.data.zero_()
442
+ elif isinstance(module, nn.Embedding):
443
+ module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
444
+ if module.padding_idx is not None:
445
+ module.weight.data[module.padding_idx].zero_()
446
+ elif isinstance(module, LayerNorm):
447
+ module.bias.data.zero_()
448
+ module.weight.data.fill_(1.0)
449
+
450
+ def _set_gradient_checkpointing(self, module: nn.Module, value: bool = False):
451
+ if isinstance(module, MegLMModel):
452
+ module.gradient_checkpointing = value
453
+
454
+ @staticmethod
455
+ def _convert_to_standard_cache(
456
+ past_key_value: Tuple[Tuple[torch.Tensor, torch.Tensor]], batch_size: int
457
+ ) -> Tuple[Tuple[torch.Tensor, torch.Tensor]]:
458
+ """
459
+ Standardizes the format of the cache so as to match most implementations, i.e. to tuple(tuple([batch_size,
460
+ num_heads, ...]))
461
+ """
462
+ batch_size_times_num_heads, head_dim, seq_length = past_key_value[0][0].shape
463
+ num_heads = batch_size_times_num_heads // batch_size
464
+ # key: [batch_size * num_heads, head_dim, seq_length] -> [batch_size, num_heads, head_dim, seq_length]
465
+ # value: [batch_size * num_heads, seq_length, head_dim] -> [batch_size, num_heads, seq_length, head_dim]
466
+ return tuple(
467
+ (
468
+ layer_past[0].view(batch_size, num_heads, head_dim, seq_length),
469
+ layer_past[1].view(batch_size, num_heads, seq_length, head_dim),
470
+ )
471
+ for layer_past in past_key_value
472
+ )
473
+
474
+ @staticmethod
475
+ def _convert_to_rw_cache(
476
+ past_key_value: Tuple[Tuple[torch.Tensor, torch.Tensor]]
477
+ ) -> Tuple[Tuple[torch.Tensor, torch.Tensor]]:
478
+ batch_size, num_heads, head_dim, seq_length = past_key_value[0][0].shape
479
+ batch_size_times_num_heads = batch_size * num_heads
480
+ # key: [batch_size, num_heads, head_dim, seq_length] -> [batch_size * num_heads, head_dim, seq_length]
481
+ # value: [batch_size, num_heads, seq_length, head_dim] -> [batch_size * num_heads, seq_length, head_dim]
482
+ return tuple(
483
+ (
484
+ layer_past[0].view(batch_size_times_num_heads, head_dim, seq_length),
485
+ layer_past[1].view(batch_size_times_num_heads, seq_length, head_dim),
486
+ )
487
+ for layer_past in past_key_value
488
+ )
489
+
490
+
491
+ class MegLMModel(MegLMPreTrainedModel):
492
+ def __init__(self, config: MegLMConfig):
493
+ super().__init__(config)
494
+
495
+ self.embed_dim = config.hidden_size
496
+ self.num_heads = config.n_head
497
+ self.alibi = config.alibi
498
+
499
+ # Embedding + LN Embedding
500
+ self.word_embeddings = nn.Embedding(config.vocab_size, self.embed_dim)
501
+
502
+ # Transformer blocks
503
+ self.h = nn.ModuleList([DecoderLayer(config) for _ in range(config.num_hidden_layers)])
504
+
505
+ # Final Layer Norm
506
+ self.ln_f = LayerNorm(self.embed_dim, eps=config.layer_norm_epsilon)
507
+
508
+ self.gradient_checkpointing = False
509
+
510
+ # Initialize weights and apply final processing
511
+ self.post_init()
512
+
513
+ def get_input_embeddings(self):
514
+ return self.word_embeddings
515
+
516
+ def _prepare_attn_mask(
517
+ self, attention_mask: torch.Tensor, input_shape: Tuple[int, int], past_key_values_length: int
518
+ ) -> torch.BoolTensor:
519
+ # create causal mask
520
+ # [batch_size, seq_length] -> [batch_size, 1, tgt_length, src_length]
521
+ combined_attention_mask = None
522
+ device = attention_mask.device
523
+ _, src_length = input_shape
524
+
525
+ if src_length > 1:
526
+ combined_attention_mask = _make_causal_mask(
527
+ input_shape, device=device, past_key_values_length=past_key_values_length
528
+ )
529
+
530
+ # [batch_size, seq_length] -> [batch_size, 1, tgt_length, src_length]
531
+ expanded_attn_mask = _expand_mask(attention_mask, tgt_length=src_length)
532
+ combined_attention_mask = (
533
+ expanded_attn_mask if combined_attention_mask is None else expanded_attn_mask | combined_attention_mask
534
+ )
535
+
536
+ return combined_attention_mask
537
+
538
+ def set_input_embeddings(self, new_embeddings: torch.Tensor):
539
+ self.word_embeddings = new_embeddings
540
+
541
+ def forward(
542
+ self,
543
+ input_ids: Optional[torch.LongTensor] = None,
544
+ past_key_values: Optional[Tuple[Tuple[torch.Tensor, torch.Tensor], ...]] = None,
545
+ attention_mask: Optional[torch.Tensor] = None,
546
+ head_mask: Optional[torch.LongTensor] = None,
547
+ inputs_embeds: Optional[torch.LongTensor] = None,
548
+ use_cache: Optional[bool] = None,
549
+ output_attentions: Optional[bool] = None,
550
+ output_hidden_states: Optional[bool] = None,
551
+ return_dict: Optional[bool] = None,
552
+ **deprecated_arguments,
553
+ ) -> Union[Tuple[torch.Tensor, ...], BaseModelOutputWithPastAndCrossAttentions]:
554
+ if deprecated_arguments.pop("position_ids", False) is not False:
555
+ # `position_ids` could have been `torch.Tensor` or `None` so defaulting pop to `False` allows to detect if users were passing explicitly `None`
556
+ warnings.warn(
557
+ "`position_ids` have no functionality in BLOOM and will be removed in v5.0.0. You can safely ignore"
558
+ " passing `position_ids`.",
559
+ FutureWarning,
560
+ )
561
+ if len(deprecated_arguments) > 0:
562
+ raise ValueError(f"Got unexpected arguments: {deprecated_arguments}")
563
+
564
+ output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
565
+ output_hidden_states = (
566
+ output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
567
+ )
568
+ use_cache = use_cache if use_cache is not None else self.config.use_cache
569
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
570
+
571
+ if input_ids is not None and inputs_embeds is not None:
572
+ raise ValueError("You cannot specify both input_ids and inputs_embeds at the same time")
573
+ elif input_ids is not None:
574
+ batch_size, seq_length = input_ids.shape
575
+ elif inputs_embeds is not None:
576
+ batch_size, seq_length, _ = inputs_embeds.shape
577
+ else:
578
+ raise ValueError("You have to specify either input_ids or inputs_embeds")
579
+
580
+ if past_key_values is None:
581
+ past_key_values = tuple([None] * len(self.h))
582
+
583
+ # Prepare head mask if needed
584
+ # 1.0 in head_mask indicate we keep the head
585
+ # attention_probs has shape batch_size x num_heads x N x N
586
+ # head_mask has shape n_layer x batch x num_heads x N x N
587
+ head_mask = self.get_head_mask(head_mask, self.config.n_layer)
588
+
589
+ if inputs_embeds is None:
590
+ inputs_embeds = self.word_embeddings(input_ids)
591
+
592
+ hidden_states = inputs_embeds
593
+
594
+ presents = () if use_cache else None
595
+ all_self_attentions = () if output_attentions else None
596
+ all_hidden_states = () if output_hidden_states else None
597
+
598
+ # Compute alibi tensor: check build_alibi_tensor documentation
599
+ seq_length_with_past = seq_length
600
+ past_key_values_length = 0
601
+ if past_key_values[0] is not None:
602
+ past_key_values_length = past_key_values[0][0].shape[2]
603
+ seq_length_with_past = seq_length_with_past + past_key_values_length
604
+ if attention_mask is None:
605
+ attention_mask = torch.ones((batch_size, seq_length_with_past), device=hidden_states.device)
606
+ else:
607
+ attention_mask = attention_mask.to(hidden_states.device)
608
+
609
+ if self.alibi:
610
+ alibi = build_alibi_tensor(attention_mask, self.num_heads, dtype=hidden_states.dtype)
611
+ else:
612
+ alibi = None
613
+
614
+ causal_mask = self._prepare_attn_mask(
615
+ attention_mask,
616
+ input_shape=(batch_size, seq_length),
617
+ past_key_values_length=past_key_values_length,
618
+ )
619
+
620
+ for i, (block, layer_past) in enumerate(zip(self.h, past_key_values)):
621
+
622
+ if output_hidden_states:
623
+ all_hidden_states = all_hidden_states + (hidden_states,)
624
+
625
+ if self.gradient_checkpointing and self.training:
626
+
627
+ if use_cache:
628
+ logger.warning(
629
+ "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..."
630
+ )
631
+ use_cache = False
632
+
633
+ def create_custom_forward(module):
634
+ def custom_forward(*inputs):
635
+ # None for past_key_value
636
+ return module(*inputs, use_cache=use_cache, output_attentions=output_attentions)
637
+
638
+ return custom_forward
639
+
640
+ outputs = torch.utils.checkpoint.checkpoint(
641
+ create_custom_forward(block),
642
+ hidden_states,
643
+ alibi,
644
+ causal_mask,
645
+ head_mask[i],
646
+ )
647
+ else:
648
+ outputs = block(
649
+ hidden_states,
650
+ layer_past=layer_past,
651
+ attention_mask=causal_mask,
652
+ head_mask=head_mask[i],
653
+ use_cache=use_cache,
654
+ output_attentions=output_attentions,
655
+ alibi=alibi,
656
+ )
657
+
658
+ hidden_states = outputs[0]
659
+ if use_cache is True:
660
+ presents = presents + (outputs[1],)
661
+
662
+ if output_attentions:
663
+ all_self_attentions = all_self_attentions + (outputs[2 if use_cache else 1],)
664
+
665
+ # Add last hidden state
666
+ hidden_states = self.ln_f(hidden_states)
667
+
668
+ if output_hidden_states:
669
+ all_hidden_states = all_hidden_states + (hidden_states,)
670
+
671
+ if not return_dict:
672
+ return tuple(v for v in [hidden_states, presents, all_hidden_states, all_self_attentions] if v is not None)
673
+
674
+ return BaseModelOutputWithPastAndCrossAttentions(
675
+ last_hidden_state=hidden_states,
676
+ past_key_values=presents,
677
+ hidden_states=all_hidden_states,
678
+ attentions=all_self_attentions,
679
+ )
680
+
681
+
682
+ class MegLMForCausalLM(MegLMPreTrainedModel):
683
+ _keys_to_ignore_on_load_missing = [r"h.*.self_attention.scale_mask_softmax.causal_mask", r"lm_head.weight"]
684
+
685
+ def __init__(self, config: MegLMConfig):
686
+ super().__init__(config)
687
+ self.transformer = MegLMModel(config)
688
+ self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
689
+
690
+ # Initialize weights and apply final processing
691
+ self.post_init()
692
+
693
+ def get_output_embeddings(self):
694
+ return self.lm_head
695
+
696
+ def set_output_embeddings(self, new_embeddings: torch.Tensor):
697
+ self.lm_head = new_embeddings
698
+
699
+ def prepare_inputs_for_generation(
700
+ self,
701
+ input_ids: torch.LongTensor,
702
+ past: Optional[torch.Tensor] = None,
703
+ attention_mask: Optional[torch.Tensor] = None,
704
+ **kwargs,
705
+ ) -> dict:
706
+ # only last token for input_ids if past is not None
707
+ if past:
708
+ input_ids = input_ids[:, -1].unsqueeze(-1)
709
+
710
+ # the cache may be in the stardard format (e.g. in contrastive search), convert to our's format if needed
711
+ if past[0][0].shape[0] == input_ids.shape[0]:
712
+ past = self._convert_to_rw_cache(past)
713
+
714
+ return {
715
+ "input_ids": input_ids,
716
+ "past_key_values": past,
717
+ "use_cache": kwargs.get("use_cache"),
718
+ "attention_mask": attention_mask,
719
+ }
720
+
721
+ def forward(
722
+ self,
723
+ input_ids: Optional[torch.LongTensor] = None,
724
+ past_key_values: Optional[Tuple[Tuple[torch.Tensor, torch.Tensor], ...]] = None,
725
+ attention_mask: Optional[torch.Tensor] = None,
726
+ head_mask: Optional[torch.Tensor] = None,
727
+ inputs_embeds: Optional[torch.Tensor] = None,
728
+ labels: Optional[torch.Tensor] = None,
729
+ use_cache: Optional[bool] = None,
730
+ output_attentions: Optional[bool] = None,
731
+ output_hidden_states: Optional[bool] = None,
732
+ return_dict: Optional[bool] = None,
733
+ **deprecated_arguments,
734
+ ) -> Union[Tuple[torch.Tensor], CausalLMOutputWithCrossAttentions]:
735
+ r"""
736
+ labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
737
+ Labels for language modeling. Note that the labels **are shifted** inside the model, i.e. you can set
738
+ `labels = input_ids` Indices are selected in `[-100, 0, ..., config.vocab_size]` All labels set to `-100`
739
+ are ignored (masked), the loss is only computed for labels in `[0, ..., config.vocab_size]`
740
+ """
741
+ if deprecated_arguments.pop("position_ids", False) is not False:
742
+ # `position_ids` could have been `torch.Tensor` or `None` so defaulting pop to `False` allows to detect if users were passing explicitly `None`
743
+ warnings.warn(
744
+ "`position_ids` have no functionality in BLOOM and will be removed in v5.0.0. You can safely ignore"
745
+ " passing `position_ids`.",
746
+ FutureWarning,
747
+ )
748
+ if len(deprecated_arguments) > 0:
749
+ raise ValueError(f"Got unexpected arguments: {deprecated_arguments}")
750
+
751
+ return_dict = return_dict if return_dict is not None else self.config.use_return_dict
752
+
753
+ transformer_outputs = self.transformer(
754
+ input_ids,
755
+ past_key_values=past_key_values,
756
+ attention_mask=attention_mask,
757
+ head_mask=head_mask,
758
+ inputs_embeds=inputs_embeds,
759
+ use_cache=use_cache,
760
+ output_attentions=output_attentions,
761
+ output_hidden_states=output_hidden_states,
762
+ return_dict=return_dict,
763
+ )
764
+ hidden_states = transformer_outputs[0]
765
+
766
+ lm_logits = self.lm_head(hidden_states)
767
+
768
+ loss = None
769
+ if labels is not None:
770
+ # Shift so that tokens < n predict n
771
+ shift_logits = lm_logits[..., :-1, :].contiguous()
772
+ shift_labels = labels[..., 1:].contiguous()
773
+ batch_size, seq_length, vocab_size = shift_logits.shape
774
+ # Flatten the tokens
775
+ loss_fct = CrossEntropyLoss()
776
+ loss = loss_fct(
777
+ shift_logits.view(batch_size * seq_length, vocab_size), shift_labels.view(batch_size * seq_length)
778
+ )
779
+
780
+ if not return_dict:
781
+ output = (lm_logits,) + transformer_outputs[1:]
782
+ return ((loss,) + output) if loss is not None else output
783
+
784
+ return CausalLMOutputWithCrossAttentions(
785
+ loss=loss,
786
+ logits=lm_logits,
787
+ past_key_values=transformer_outputs.past_key_values,
788
+ hidden_states=transformer_outputs.hidden_states,
789
+ attentions=transformer_outputs.attentions,
790
+ )
791
+
792
+ def _reorder_cache(
793
+ self, past: Tuple[Tuple[torch.Tensor, torch.Tensor], ...], beam_idx: torch.LongTensor
794
+ ) -> Tuple[Tuple[torch.Tensor, torch.Tensor], ...]:
795
+ """
796
+ This function is used to re-order the `past_key_values` cache if [`~PreTrainedModel.beam_search`] or
797
+ [`~PreTrainedModel.beam_sample`] is called. This is required to match `past_key_values` with the correct
798
+ beam_idx at every generation step.
799
+
800
+ Output shares the same memory storage as `past`.
801
+ """
802
+ standardized_past = self._convert_to_standard_cache(past, batch_size=len(beam_idx))
803
+
804
+ # Get a copy of `beam_idx` on all the devices where we need those indices.
805
+ device_to_beam_idx = {
806
+ past_state.device: beam_idx.to(past_state.device) for layer_past in past for past_state in layer_past
807
+ }
808
+ reordered_past = tuple(
809
+ (
810
+ layer_past[0].index_select(0, device_to_beam_idx[layer_past[0].device]),
811
+ layer_past[1].index_select(0, device_to_beam_idx[layer_past[0].device]),
812
+ )
813
+ for layer_past in standardized_past
814
+ )
815
+ return self._convert_to_rw_cache(reordered_past)
816
+
817
+
818
+
pytorch_model.bin.index.json ADDED
@@ -0,0 +1,395 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "metadata": {
3
+ "total_size": 5370849280
4
+ },
5
+ "weight_map": {
6
+ "lm_head.weight": "pytorch_model-00002-of-00002.bin",
7
+ "transformer.h.0.input_layernorm.bias": "pytorch_model-00001-of-00002.bin",
8
+ "transformer.h.0.input_layernorm.weight": "pytorch_model-00001-of-00002.bin",
9
+ "transformer.h.0.mlp.dense_4h_to_h.bias": "pytorch_model-00001-of-00002.bin",
10
+ "transformer.h.0.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00002.bin",
11
+ "transformer.h.0.mlp.dense_h_to_4h.bias": "pytorch_model-00001-of-00002.bin",
12
+ "transformer.h.0.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00002.bin",
13
+ "transformer.h.0.post_attention_layernorm.bias": "pytorch_model-00001-of-00002.bin",
14
+ "transformer.h.0.post_attention_layernorm.weight": "pytorch_model-00001-of-00002.bin",
15
+ "transformer.h.0.self_attention.dense.bias": "pytorch_model-00001-of-00002.bin",
16
+ "transformer.h.0.self_attention.dense.weight": "pytorch_model-00001-of-00002.bin",
17
+ "transformer.h.0.self_attention.query_key_value.bias": "pytorch_model-00001-of-00002.bin",
18
+ "transformer.h.0.self_attention.query_key_value.weight": "pytorch_model-00001-of-00002.bin",
19
+ "transformer.h.1.input_layernorm.bias": "pytorch_model-00001-of-00002.bin",
20
+ "transformer.h.1.input_layernorm.weight": "pytorch_model-00001-of-00002.bin",
21
+ "transformer.h.1.mlp.dense_4h_to_h.bias": "pytorch_model-00001-of-00002.bin",
22
+ "transformer.h.1.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00002.bin",
23
+ "transformer.h.1.mlp.dense_h_to_4h.bias": "pytorch_model-00001-of-00002.bin",
24
+ "transformer.h.1.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00002.bin",
25
+ "transformer.h.1.post_attention_layernorm.bias": "pytorch_model-00001-of-00002.bin",
26
+ "transformer.h.1.post_attention_layernorm.weight": "pytorch_model-00001-of-00002.bin",
27
+ "transformer.h.1.self_attention.dense.bias": "pytorch_model-00001-of-00002.bin",
28
+ "transformer.h.1.self_attention.dense.weight": "pytorch_model-00001-of-00002.bin",
29
+ "transformer.h.1.self_attention.query_key_value.bias": "pytorch_model-00001-of-00002.bin",
30
+ "transformer.h.1.self_attention.query_key_value.weight": "pytorch_model-00001-of-00002.bin",
31
+ "transformer.h.10.input_layernorm.bias": "pytorch_model-00001-of-00002.bin",
32
+ "transformer.h.10.input_layernorm.weight": "pytorch_model-00001-of-00002.bin",
33
+ "transformer.h.10.mlp.dense_4h_to_h.bias": "pytorch_model-00001-of-00002.bin",
34
+ "transformer.h.10.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00002.bin",
35
+ "transformer.h.10.mlp.dense_h_to_4h.bias": "pytorch_model-00001-of-00002.bin",
36
+ "transformer.h.10.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00002.bin",
37
+ "transformer.h.10.post_attention_layernorm.bias": "pytorch_model-00001-of-00002.bin",
38
+ "transformer.h.10.post_attention_layernorm.weight": "pytorch_model-00001-of-00002.bin",
39
+ "transformer.h.10.self_attention.dense.bias": "pytorch_model-00001-of-00002.bin",
40
+ "transformer.h.10.self_attention.dense.weight": "pytorch_model-00001-of-00002.bin",
41
+ "transformer.h.10.self_attention.query_key_value.bias": "pytorch_model-00001-of-00002.bin",
42
+ "transformer.h.10.self_attention.query_key_value.weight": "pytorch_model-00001-of-00002.bin",
43
+ "transformer.h.11.input_layernorm.bias": "pytorch_model-00001-of-00002.bin",
44
+ "transformer.h.11.input_layernorm.weight": "pytorch_model-00001-of-00002.bin",
45
+ "transformer.h.11.mlp.dense_4h_to_h.bias": "pytorch_model-00001-of-00002.bin",
46
+ "transformer.h.11.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00002.bin",
47
+ "transformer.h.11.mlp.dense_h_to_4h.bias": "pytorch_model-00001-of-00002.bin",
48
+ "transformer.h.11.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00002.bin",
49
+ "transformer.h.11.post_attention_layernorm.bias": "pytorch_model-00001-of-00002.bin",
50
+ "transformer.h.11.post_attention_layernorm.weight": "pytorch_model-00001-of-00002.bin",
51
+ "transformer.h.11.self_attention.dense.bias": "pytorch_model-00001-of-00002.bin",
52
+ "transformer.h.11.self_attention.dense.weight": "pytorch_model-00001-of-00002.bin",
53
+ "transformer.h.11.self_attention.query_key_value.bias": "pytorch_model-00001-of-00002.bin",
54
+ "transformer.h.11.self_attention.query_key_value.weight": "pytorch_model-00001-of-00002.bin",
55
+ "transformer.h.12.input_layernorm.bias": "pytorch_model-00001-of-00002.bin",
56
+ "transformer.h.12.input_layernorm.weight": "pytorch_model-00001-of-00002.bin",
57
+ "transformer.h.12.mlp.dense_4h_to_h.bias": "pytorch_model-00001-of-00002.bin",
58
+ "transformer.h.12.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00002.bin",
59
+ "transformer.h.12.mlp.dense_h_to_4h.bias": "pytorch_model-00001-of-00002.bin",
60
+ "transformer.h.12.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00002.bin",
61
+ "transformer.h.12.post_attention_layernorm.bias": "pytorch_model-00001-of-00002.bin",
62
+ "transformer.h.12.post_attention_layernorm.weight": "pytorch_model-00001-of-00002.bin",
63
+ "transformer.h.12.self_attention.dense.bias": "pytorch_model-00001-of-00002.bin",
64
+ "transformer.h.12.self_attention.dense.weight": "pytorch_model-00001-of-00002.bin",
65
+ "transformer.h.12.self_attention.query_key_value.bias": "pytorch_model-00001-of-00002.bin",
66
+ "transformer.h.12.self_attention.query_key_value.weight": "pytorch_model-00001-of-00002.bin",
67
+ "transformer.h.13.input_layernorm.bias": "pytorch_model-00001-of-00002.bin",
68
+ "transformer.h.13.input_layernorm.weight": "pytorch_model-00001-of-00002.bin",
69
+ "transformer.h.13.mlp.dense_4h_to_h.bias": "pytorch_model-00001-of-00002.bin",
70
+ "transformer.h.13.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00002.bin",
71
+ "transformer.h.13.mlp.dense_h_to_4h.bias": "pytorch_model-00001-of-00002.bin",
72
+ "transformer.h.13.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00002.bin",
73
+ "transformer.h.13.post_attention_layernorm.bias": "pytorch_model-00001-of-00002.bin",
74
+ "transformer.h.13.post_attention_layernorm.weight": "pytorch_model-00001-of-00002.bin",
75
+ "transformer.h.13.self_attention.dense.bias": "pytorch_model-00001-of-00002.bin",
76
+ "transformer.h.13.self_attention.dense.weight": "pytorch_model-00001-of-00002.bin",
77
+ "transformer.h.13.self_attention.query_key_value.bias": "pytorch_model-00001-of-00002.bin",
78
+ "transformer.h.13.self_attention.query_key_value.weight": "pytorch_model-00001-of-00002.bin",
79
+ "transformer.h.14.input_layernorm.bias": "pytorch_model-00001-of-00002.bin",
80
+ "transformer.h.14.input_layernorm.weight": "pytorch_model-00001-of-00002.bin",
81
+ "transformer.h.14.mlp.dense_4h_to_h.bias": "pytorch_model-00001-of-00002.bin",
82
+ "transformer.h.14.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00002.bin",
83
+ "transformer.h.14.mlp.dense_h_to_4h.bias": "pytorch_model-00001-of-00002.bin",
84
+ "transformer.h.14.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00002.bin",
85
+ "transformer.h.14.post_attention_layernorm.bias": "pytorch_model-00001-of-00002.bin",
86
+ "transformer.h.14.post_attention_layernorm.weight": "pytorch_model-00001-of-00002.bin",
87
+ "transformer.h.14.self_attention.dense.bias": "pytorch_model-00001-of-00002.bin",
88
+ "transformer.h.14.self_attention.dense.weight": "pytorch_model-00001-of-00002.bin",
89
+ "transformer.h.14.self_attention.query_key_value.bias": "pytorch_model-00001-of-00002.bin",
90
+ "transformer.h.14.self_attention.query_key_value.weight": "pytorch_model-00001-of-00002.bin",
91
+ "transformer.h.15.input_layernorm.bias": "pytorch_model-00001-of-00002.bin",
92
+ "transformer.h.15.input_layernorm.weight": "pytorch_model-00001-of-00002.bin",
93
+ "transformer.h.15.mlp.dense_4h_to_h.bias": "pytorch_model-00001-of-00002.bin",
94
+ "transformer.h.15.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00002.bin",
95
+ "transformer.h.15.mlp.dense_h_to_4h.bias": "pytorch_model-00001-of-00002.bin",
96
+ "transformer.h.15.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00002.bin",
97
+ "transformer.h.15.post_attention_layernorm.bias": "pytorch_model-00001-of-00002.bin",
98
+ "transformer.h.15.post_attention_layernorm.weight": "pytorch_model-00001-of-00002.bin",
99
+ "transformer.h.15.self_attention.dense.bias": "pytorch_model-00001-of-00002.bin",
100
+ "transformer.h.15.self_attention.dense.weight": "pytorch_model-00001-of-00002.bin",
101
+ "transformer.h.15.self_attention.query_key_value.bias": "pytorch_model-00001-of-00002.bin",
102
+ "transformer.h.15.self_attention.query_key_value.weight": "pytorch_model-00001-of-00002.bin",
103
+ "transformer.h.16.input_layernorm.bias": "pytorch_model-00001-of-00002.bin",
104
+ "transformer.h.16.input_layernorm.weight": "pytorch_model-00001-of-00002.bin",
105
+ "transformer.h.16.mlp.dense_4h_to_h.bias": "pytorch_model-00001-of-00002.bin",
106
+ "transformer.h.16.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00002.bin",
107
+ "transformer.h.16.mlp.dense_h_to_4h.bias": "pytorch_model-00001-of-00002.bin",
108
+ "transformer.h.16.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00002.bin",
109
+ "transformer.h.16.post_attention_layernorm.bias": "pytorch_model-00001-of-00002.bin",
110
+ "transformer.h.16.post_attention_layernorm.weight": "pytorch_model-00001-of-00002.bin",
111
+ "transformer.h.16.self_attention.dense.bias": "pytorch_model-00001-of-00002.bin",
112
+ "transformer.h.16.self_attention.dense.weight": "pytorch_model-00001-of-00002.bin",
113
+ "transformer.h.16.self_attention.query_key_value.bias": "pytorch_model-00001-of-00002.bin",
114
+ "transformer.h.16.self_attention.query_key_value.weight": "pytorch_model-00001-of-00002.bin",
115
+ "transformer.h.17.input_layernorm.bias": "pytorch_model-00001-of-00002.bin",
116
+ "transformer.h.17.input_layernorm.weight": "pytorch_model-00001-of-00002.bin",
117
+ "transformer.h.17.mlp.dense_4h_to_h.bias": "pytorch_model-00001-of-00002.bin",
118
+ "transformer.h.17.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00002.bin",
119
+ "transformer.h.17.mlp.dense_h_to_4h.bias": "pytorch_model-00001-of-00002.bin",
120
+ "transformer.h.17.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00002.bin",
121
+ "transformer.h.17.post_attention_layernorm.bias": "pytorch_model-00001-of-00002.bin",
122
+ "transformer.h.17.post_attention_layernorm.weight": "pytorch_model-00001-of-00002.bin",
123
+ "transformer.h.17.self_attention.dense.bias": "pytorch_model-00001-of-00002.bin",
124
+ "transformer.h.17.self_attention.dense.weight": "pytorch_model-00001-of-00002.bin",
125
+ "transformer.h.17.self_attention.query_key_value.bias": "pytorch_model-00001-of-00002.bin",
126
+ "transformer.h.17.self_attention.query_key_value.weight": "pytorch_model-00001-of-00002.bin",
127
+ "transformer.h.18.input_layernorm.bias": "pytorch_model-00001-of-00002.bin",
128
+ "transformer.h.18.input_layernorm.weight": "pytorch_model-00001-of-00002.bin",
129
+ "transformer.h.18.mlp.dense_4h_to_h.bias": "pytorch_model-00001-of-00002.bin",
130
+ "transformer.h.18.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00002.bin",
131
+ "transformer.h.18.mlp.dense_h_to_4h.bias": "pytorch_model-00001-of-00002.bin",
132
+ "transformer.h.18.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00002.bin",
133
+ "transformer.h.18.post_attention_layernorm.bias": "pytorch_model-00001-of-00002.bin",
134
+ "transformer.h.18.post_attention_layernorm.weight": "pytorch_model-00001-of-00002.bin",
135
+ "transformer.h.18.self_attention.dense.bias": "pytorch_model-00001-of-00002.bin",
136
+ "transformer.h.18.self_attention.dense.weight": "pytorch_model-00001-of-00002.bin",
137
+ "transformer.h.18.self_attention.query_key_value.bias": "pytorch_model-00001-of-00002.bin",
138
+ "transformer.h.18.self_attention.query_key_value.weight": "pytorch_model-00001-of-00002.bin",
139
+ "transformer.h.19.input_layernorm.bias": "pytorch_model-00001-of-00002.bin",
140
+ "transformer.h.19.input_layernorm.weight": "pytorch_model-00001-of-00002.bin",
141
+ "transformer.h.19.mlp.dense_4h_to_h.bias": "pytorch_model-00001-of-00002.bin",
142
+ "transformer.h.19.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00002.bin",
143
+ "transformer.h.19.mlp.dense_h_to_4h.bias": "pytorch_model-00001-of-00002.bin",
144
+ "transformer.h.19.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00002.bin",
145
+ "transformer.h.19.post_attention_layernorm.bias": "pytorch_model-00001-of-00002.bin",
146
+ "transformer.h.19.post_attention_layernorm.weight": "pytorch_model-00001-of-00002.bin",
147
+ "transformer.h.19.self_attention.dense.bias": "pytorch_model-00001-of-00002.bin",
148
+ "transformer.h.19.self_attention.dense.weight": "pytorch_model-00001-of-00002.bin",
149
+ "transformer.h.19.self_attention.query_key_value.bias": "pytorch_model-00001-of-00002.bin",
150
+ "transformer.h.19.self_attention.query_key_value.weight": "pytorch_model-00001-of-00002.bin",
151
+ "transformer.h.2.input_layernorm.bias": "pytorch_model-00001-of-00002.bin",
152
+ "transformer.h.2.input_layernorm.weight": "pytorch_model-00001-of-00002.bin",
153
+ "transformer.h.2.mlp.dense_4h_to_h.bias": "pytorch_model-00001-of-00002.bin",
154
+ "transformer.h.2.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00002.bin",
155
+ "transformer.h.2.mlp.dense_h_to_4h.bias": "pytorch_model-00001-of-00002.bin",
156
+ "transformer.h.2.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00002.bin",
157
+ "transformer.h.2.post_attention_layernorm.bias": "pytorch_model-00001-of-00002.bin",
158
+ "transformer.h.2.post_attention_layernorm.weight": "pytorch_model-00001-of-00002.bin",
159
+ "transformer.h.2.self_attention.dense.bias": "pytorch_model-00001-of-00002.bin",
160
+ "transformer.h.2.self_attention.dense.weight": "pytorch_model-00001-of-00002.bin",
161
+ "transformer.h.2.self_attention.query_key_value.bias": "pytorch_model-00001-of-00002.bin",
162
+ "transformer.h.2.self_attention.query_key_value.weight": "pytorch_model-00001-of-00002.bin",
163
+ "transformer.h.20.input_layernorm.bias": "pytorch_model-00001-of-00002.bin",
164
+ "transformer.h.20.input_layernorm.weight": "pytorch_model-00001-of-00002.bin",
165
+ "transformer.h.20.mlp.dense_4h_to_h.bias": "pytorch_model-00001-of-00002.bin",
166
+ "transformer.h.20.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00002.bin",
167
+ "transformer.h.20.mlp.dense_h_to_4h.bias": "pytorch_model-00001-of-00002.bin",
168
+ "transformer.h.20.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00002.bin",
169
+ "transformer.h.20.post_attention_layernorm.bias": "pytorch_model-00001-of-00002.bin",
170
+ "transformer.h.20.post_attention_layernorm.weight": "pytorch_model-00001-of-00002.bin",
171
+ "transformer.h.20.self_attention.dense.bias": "pytorch_model-00001-of-00002.bin",
172
+ "transformer.h.20.self_attention.dense.weight": "pytorch_model-00001-of-00002.bin",
173
+ "transformer.h.20.self_attention.query_key_value.bias": "pytorch_model-00001-of-00002.bin",
174
+ "transformer.h.20.self_attention.query_key_value.weight": "pytorch_model-00001-of-00002.bin",
175
+ "transformer.h.21.input_layernorm.bias": "pytorch_model-00001-of-00002.bin",
176
+ "transformer.h.21.input_layernorm.weight": "pytorch_model-00001-of-00002.bin",
177
+ "transformer.h.21.mlp.dense_4h_to_h.bias": "pytorch_model-00001-of-00002.bin",
178
+ "transformer.h.21.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00002.bin",
179
+ "transformer.h.21.mlp.dense_h_to_4h.bias": "pytorch_model-00001-of-00002.bin",
180
+ "transformer.h.21.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00002.bin",
181
+ "transformer.h.21.post_attention_layernorm.bias": "pytorch_model-00001-of-00002.bin",
182
+ "transformer.h.21.post_attention_layernorm.weight": "pytorch_model-00001-of-00002.bin",
183
+ "transformer.h.21.self_attention.dense.bias": "pytorch_model-00001-of-00002.bin",
184
+ "transformer.h.21.self_attention.dense.weight": "pytorch_model-00001-of-00002.bin",
185
+ "transformer.h.21.self_attention.query_key_value.bias": "pytorch_model-00001-of-00002.bin",
186
+ "transformer.h.21.self_attention.query_key_value.weight": "pytorch_model-00001-of-00002.bin",
187
+ "transformer.h.22.input_layernorm.bias": "pytorch_model-00001-of-00002.bin",
188
+ "transformer.h.22.input_layernorm.weight": "pytorch_model-00001-of-00002.bin",
189
+ "transformer.h.22.mlp.dense_4h_to_h.bias": "pytorch_model-00001-of-00002.bin",
190
+ "transformer.h.22.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00002.bin",
191
+ "transformer.h.22.mlp.dense_h_to_4h.bias": "pytorch_model-00001-of-00002.bin",
192
+ "transformer.h.22.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00002.bin",
193
+ "transformer.h.22.post_attention_layernorm.bias": "pytorch_model-00001-of-00002.bin",
194
+ "transformer.h.22.post_attention_layernorm.weight": "pytorch_model-00001-of-00002.bin",
195
+ "transformer.h.22.self_attention.dense.bias": "pytorch_model-00001-of-00002.bin",
196
+ "transformer.h.22.self_attention.dense.weight": "pytorch_model-00001-of-00002.bin",
197
+ "transformer.h.22.self_attention.query_key_value.bias": "pytorch_model-00001-of-00002.bin",
198
+ "transformer.h.22.self_attention.query_key_value.weight": "pytorch_model-00001-of-00002.bin",
199
+ "transformer.h.23.input_layernorm.bias": "pytorch_model-00001-of-00002.bin",
200
+ "transformer.h.23.input_layernorm.weight": "pytorch_model-00001-of-00002.bin",
201
+ "transformer.h.23.mlp.dense_4h_to_h.bias": "pytorch_model-00001-of-00002.bin",
202
+ "transformer.h.23.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00002.bin",
203
+ "transformer.h.23.mlp.dense_h_to_4h.bias": "pytorch_model-00001-of-00002.bin",
204
+ "transformer.h.23.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00002.bin",
205
+ "transformer.h.23.post_attention_layernorm.bias": "pytorch_model-00001-of-00002.bin",
206
+ "transformer.h.23.post_attention_layernorm.weight": "pytorch_model-00001-of-00002.bin",
207
+ "transformer.h.23.self_attention.dense.bias": "pytorch_model-00001-of-00002.bin",
208
+ "transformer.h.23.self_attention.dense.weight": "pytorch_model-00001-of-00002.bin",
209
+ "transformer.h.23.self_attention.query_key_value.bias": "pytorch_model-00001-of-00002.bin",
210
+ "transformer.h.23.self_attention.query_key_value.weight": "pytorch_model-00001-of-00002.bin",
211
+ "transformer.h.24.input_layernorm.bias": "pytorch_model-00001-of-00002.bin",
212
+ "transformer.h.24.input_layernorm.weight": "pytorch_model-00001-of-00002.bin",
213
+ "transformer.h.24.mlp.dense_4h_to_h.bias": "pytorch_model-00001-of-00002.bin",
214
+ "transformer.h.24.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00002.bin",
215
+ "transformer.h.24.mlp.dense_h_to_4h.bias": "pytorch_model-00001-of-00002.bin",
216
+ "transformer.h.24.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00002.bin",
217
+ "transformer.h.24.post_attention_layernorm.bias": "pytorch_model-00001-of-00002.bin",
218
+ "transformer.h.24.post_attention_layernorm.weight": "pytorch_model-00001-of-00002.bin",
219
+ "transformer.h.24.self_attention.dense.bias": "pytorch_model-00001-of-00002.bin",
220
+ "transformer.h.24.self_attention.dense.weight": "pytorch_model-00001-of-00002.bin",
221
+ "transformer.h.24.self_attention.query_key_value.bias": "pytorch_model-00001-of-00002.bin",
222
+ "transformer.h.24.self_attention.query_key_value.weight": "pytorch_model-00001-of-00002.bin",
223
+ "transformer.h.25.input_layernorm.bias": "pytorch_model-00001-of-00002.bin",
224
+ "transformer.h.25.input_layernorm.weight": "pytorch_model-00001-of-00002.bin",
225
+ "transformer.h.25.mlp.dense_4h_to_h.bias": "pytorch_model-00001-of-00002.bin",
226
+ "transformer.h.25.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00002.bin",
227
+ "transformer.h.25.mlp.dense_h_to_4h.bias": "pytorch_model-00001-of-00002.bin",
228
+ "transformer.h.25.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00002.bin",
229
+ "transformer.h.25.post_attention_layernorm.bias": "pytorch_model-00001-of-00002.bin",
230
+ "transformer.h.25.post_attention_layernorm.weight": "pytorch_model-00001-of-00002.bin",
231
+ "transformer.h.25.self_attention.dense.bias": "pytorch_model-00001-of-00002.bin",
232
+ "transformer.h.25.self_attention.dense.weight": "pytorch_model-00001-of-00002.bin",
233
+ "transformer.h.25.self_attention.query_key_value.bias": "pytorch_model-00001-of-00002.bin",
234
+ "transformer.h.25.self_attention.query_key_value.weight": "pytorch_model-00001-of-00002.bin",
235
+ "transformer.h.26.input_layernorm.bias": "pytorch_model-00001-of-00002.bin",
236
+ "transformer.h.26.input_layernorm.weight": "pytorch_model-00001-of-00002.bin",
237
+ "transformer.h.26.mlp.dense_4h_to_h.bias": "pytorch_model-00001-of-00002.bin",
238
+ "transformer.h.26.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00002.bin",
239
+ "transformer.h.26.mlp.dense_h_to_4h.bias": "pytorch_model-00001-of-00002.bin",
240
+ "transformer.h.26.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00002.bin",
241
+ "transformer.h.26.post_attention_layernorm.bias": "pytorch_model-00001-of-00002.bin",
242
+ "transformer.h.26.post_attention_layernorm.weight": "pytorch_model-00001-of-00002.bin",
243
+ "transformer.h.26.self_attention.dense.bias": "pytorch_model-00001-of-00002.bin",
244
+ "transformer.h.26.self_attention.dense.weight": "pytorch_model-00001-of-00002.bin",
245
+ "transformer.h.26.self_attention.query_key_value.bias": "pytorch_model-00001-of-00002.bin",
246
+ "transformer.h.26.self_attention.query_key_value.weight": "pytorch_model-00001-of-00002.bin",
247
+ "transformer.h.27.input_layernorm.bias": "pytorch_model-00001-of-00002.bin",
248
+ "transformer.h.27.input_layernorm.weight": "pytorch_model-00001-of-00002.bin",
249
+ "transformer.h.27.mlp.dense_4h_to_h.bias": "pytorch_model-00001-of-00002.bin",
250
+ "transformer.h.27.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00002.bin",
251
+ "transformer.h.27.mlp.dense_h_to_4h.bias": "pytorch_model-00001-of-00002.bin",
252
+ "transformer.h.27.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00002.bin",
253
+ "transformer.h.27.post_attention_layernorm.bias": "pytorch_model-00001-of-00002.bin",
254
+ "transformer.h.27.post_attention_layernorm.weight": "pytorch_model-00001-of-00002.bin",
255
+ "transformer.h.27.self_attention.dense.bias": "pytorch_model-00001-of-00002.bin",
256
+ "transformer.h.27.self_attention.dense.weight": "pytorch_model-00001-of-00002.bin",
257
+ "transformer.h.27.self_attention.query_key_value.bias": "pytorch_model-00001-of-00002.bin",
258
+ "transformer.h.27.self_attention.query_key_value.weight": "pytorch_model-00001-of-00002.bin",
259
+ "transformer.h.28.input_layernorm.bias": "pytorch_model-00001-of-00002.bin",
260
+ "transformer.h.28.input_layernorm.weight": "pytorch_model-00001-of-00002.bin",
261
+ "transformer.h.28.mlp.dense_4h_to_h.bias": "pytorch_model-00001-of-00002.bin",
262
+ "transformer.h.28.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00002.bin",
263
+ "transformer.h.28.mlp.dense_h_to_4h.bias": "pytorch_model-00001-of-00002.bin",
264
+ "transformer.h.28.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00002.bin",
265
+ "transformer.h.28.post_attention_layernorm.bias": "pytorch_model-00001-of-00002.bin",
266
+ "transformer.h.28.post_attention_layernorm.weight": "pytorch_model-00001-of-00002.bin",
267
+ "transformer.h.28.self_attention.dense.bias": "pytorch_model-00001-of-00002.bin",
268
+ "transformer.h.28.self_attention.dense.weight": "pytorch_model-00001-of-00002.bin",
269
+ "transformer.h.28.self_attention.query_key_value.bias": "pytorch_model-00001-of-00002.bin",
270
+ "transformer.h.28.self_attention.query_key_value.weight": "pytorch_model-00001-of-00002.bin",
271
+ "transformer.h.29.input_layernorm.bias": "pytorch_model-00001-of-00002.bin",
272
+ "transformer.h.29.input_layernorm.weight": "pytorch_model-00001-of-00002.bin",
273
+ "transformer.h.29.mlp.dense_4h_to_h.bias": "pytorch_model-00001-of-00002.bin",
274
+ "transformer.h.29.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00002.bin",
275
+ "transformer.h.29.mlp.dense_h_to_4h.bias": "pytorch_model-00001-of-00002.bin",
276
+ "transformer.h.29.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00002.bin",
277
+ "transformer.h.29.post_attention_layernorm.bias": "pytorch_model-00001-of-00002.bin",
278
+ "transformer.h.29.post_attention_layernorm.weight": "pytorch_model-00001-of-00002.bin",
279
+ "transformer.h.29.self_attention.dense.bias": "pytorch_model-00001-of-00002.bin",
280
+ "transformer.h.29.self_attention.dense.weight": "pytorch_model-00001-of-00002.bin",
281
+ "transformer.h.29.self_attention.query_key_value.bias": "pytorch_model-00001-of-00002.bin",
282
+ "transformer.h.29.self_attention.query_key_value.weight": "pytorch_model-00001-of-00002.bin",
283
+ "transformer.h.3.input_layernorm.bias": "pytorch_model-00001-of-00002.bin",
284
+ "transformer.h.3.input_layernorm.weight": "pytorch_model-00001-of-00002.bin",
285
+ "transformer.h.3.mlp.dense_4h_to_h.bias": "pytorch_model-00001-of-00002.bin",
286
+ "transformer.h.3.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00002.bin",
287
+ "transformer.h.3.mlp.dense_h_to_4h.bias": "pytorch_model-00001-of-00002.bin",
288
+ "transformer.h.3.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00002.bin",
289
+ "transformer.h.3.post_attention_layernorm.bias": "pytorch_model-00001-of-00002.bin",
290
+ "transformer.h.3.post_attention_layernorm.weight": "pytorch_model-00001-of-00002.bin",
291
+ "transformer.h.3.self_attention.dense.bias": "pytorch_model-00001-of-00002.bin",
292
+ "transformer.h.3.self_attention.dense.weight": "pytorch_model-00001-of-00002.bin",
293
+ "transformer.h.3.self_attention.query_key_value.bias": "pytorch_model-00001-of-00002.bin",
294
+ "transformer.h.3.self_attention.query_key_value.weight": "pytorch_model-00001-of-00002.bin",
295
+ "transformer.h.30.input_layernorm.bias": "pytorch_model-00001-of-00002.bin",
296
+ "transformer.h.30.input_layernorm.weight": "pytorch_model-00001-of-00002.bin",
297
+ "transformer.h.30.mlp.dense_4h_to_h.bias": "pytorch_model-00001-of-00002.bin",
298
+ "transformer.h.30.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00002.bin",
299
+ "transformer.h.30.mlp.dense_h_to_4h.bias": "pytorch_model-00001-of-00002.bin",
300
+ "transformer.h.30.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00002.bin",
301
+ "transformer.h.30.post_attention_layernorm.bias": "pytorch_model-00001-of-00002.bin",
302
+ "transformer.h.30.post_attention_layernorm.weight": "pytorch_model-00001-of-00002.bin",
303
+ "transformer.h.30.self_attention.dense.bias": "pytorch_model-00001-of-00002.bin",
304
+ "transformer.h.30.self_attention.dense.weight": "pytorch_model-00001-of-00002.bin",
305
+ "transformer.h.30.self_attention.query_key_value.bias": "pytorch_model-00001-of-00002.bin",
306
+ "transformer.h.30.self_attention.query_key_value.weight": "pytorch_model-00001-of-00002.bin",
307
+ "transformer.h.31.input_layernorm.bias": "pytorch_model-00001-of-00002.bin",
308
+ "transformer.h.31.input_layernorm.weight": "pytorch_model-00001-of-00002.bin",
309
+ "transformer.h.31.mlp.dense_4h_to_h.bias": "pytorch_model-00001-of-00002.bin",
310
+ "transformer.h.31.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00002.bin",
311
+ "transformer.h.31.mlp.dense_h_to_4h.bias": "pytorch_model-00001-of-00002.bin",
312
+ "transformer.h.31.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00002.bin",
313
+ "transformer.h.31.post_attention_layernorm.bias": "pytorch_model-00001-of-00002.bin",
314
+ "transformer.h.31.post_attention_layernorm.weight": "pytorch_model-00001-of-00002.bin",
315
+ "transformer.h.31.self_attention.dense.bias": "pytorch_model-00001-of-00002.bin",
316
+ "transformer.h.31.self_attention.dense.weight": "pytorch_model-00001-of-00002.bin",
317
+ "transformer.h.31.self_attention.query_key_value.bias": "pytorch_model-00001-of-00002.bin",
318
+ "transformer.h.31.self_attention.query_key_value.weight": "pytorch_model-00001-of-00002.bin",
319
+ "transformer.h.4.input_layernorm.bias": "pytorch_model-00001-of-00002.bin",
320
+ "transformer.h.4.input_layernorm.weight": "pytorch_model-00001-of-00002.bin",
321
+ "transformer.h.4.mlp.dense_4h_to_h.bias": "pytorch_model-00001-of-00002.bin",
322
+ "transformer.h.4.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00002.bin",
323
+ "transformer.h.4.mlp.dense_h_to_4h.bias": "pytorch_model-00001-of-00002.bin",
324
+ "transformer.h.4.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00002.bin",
325
+ "transformer.h.4.post_attention_layernorm.bias": "pytorch_model-00001-of-00002.bin",
326
+ "transformer.h.4.post_attention_layernorm.weight": "pytorch_model-00001-of-00002.bin",
327
+ "transformer.h.4.self_attention.dense.bias": "pytorch_model-00001-of-00002.bin",
328
+ "transformer.h.4.self_attention.dense.weight": "pytorch_model-00001-of-00002.bin",
329
+ "transformer.h.4.self_attention.query_key_value.bias": "pytorch_model-00001-of-00002.bin",
330
+ "transformer.h.4.self_attention.query_key_value.weight": "pytorch_model-00001-of-00002.bin",
331
+ "transformer.h.5.input_layernorm.bias": "pytorch_model-00001-of-00002.bin",
332
+ "transformer.h.5.input_layernorm.weight": "pytorch_model-00001-of-00002.bin",
333
+ "transformer.h.5.mlp.dense_4h_to_h.bias": "pytorch_model-00001-of-00002.bin",
334
+ "transformer.h.5.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00002.bin",
335
+ "transformer.h.5.mlp.dense_h_to_4h.bias": "pytorch_model-00001-of-00002.bin",
336
+ "transformer.h.5.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00002.bin",
337
+ "transformer.h.5.post_attention_layernorm.bias": "pytorch_model-00001-of-00002.bin",
338
+ "transformer.h.5.post_attention_layernorm.weight": "pytorch_model-00001-of-00002.bin",
339
+ "transformer.h.5.self_attention.dense.bias": "pytorch_model-00001-of-00002.bin",
340
+ "transformer.h.5.self_attention.dense.weight": "pytorch_model-00001-of-00002.bin",
341
+ "transformer.h.5.self_attention.query_key_value.bias": "pytorch_model-00001-of-00002.bin",
342
+ "transformer.h.5.self_attention.query_key_value.weight": "pytorch_model-00001-of-00002.bin",
343
+ "transformer.h.6.input_layernorm.bias": "pytorch_model-00001-of-00002.bin",
344
+ "transformer.h.6.input_layernorm.weight": "pytorch_model-00001-of-00002.bin",
345
+ "transformer.h.6.mlp.dense_4h_to_h.bias": "pytorch_model-00001-of-00002.bin",
346
+ "transformer.h.6.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00002.bin",
347
+ "transformer.h.6.mlp.dense_h_to_4h.bias": "pytorch_model-00001-of-00002.bin",
348
+ "transformer.h.6.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00002.bin",
349
+ "transformer.h.6.post_attention_layernorm.bias": "pytorch_model-00001-of-00002.bin",
350
+ "transformer.h.6.post_attention_layernorm.weight": "pytorch_model-00001-of-00002.bin",
351
+ "transformer.h.6.self_attention.dense.bias": "pytorch_model-00001-of-00002.bin",
352
+ "transformer.h.6.self_attention.dense.weight": "pytorch_model-00001-of-00002.bin",
353
+ "transformer.h.6.self_attention.query_key_value.bias": "pytorch_model-00001-of-00002.bin",
354
+ "transformer.h.6.self_attention.query_key_value.weight": "pytorch_model-00001-of-00002.bin",
355
+ "transformer.h.7.input_layernorm.bias": "pytorch_model-00001-of-00002.bin",
356
+ "transformer.h.7.input_layernorm.weight": "pytorch_model-00001-of-00002.bin",
357
+ "transformer.h.7.mlp.dense_4h_to_h.bias": "pytorch_model-00001-of-00002.bin",
358
+ "transformer.h.7.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00002.bin",
359
+ "transformer.h.7.mlp.dense_h_to_4h.bias": "pytorch_model-00001-of-00002.bin",
360
+ "transformer.h.7.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00002.bin",
361
+ "transformer.h.7.post_attention_layernorm.bias": "pytorch_model-00001-of-00002.bin",
362
+ "transformer.h.7.post_attention_layernorm.weight": "pytorch_model-00001-of-00002.bin",
363
+ "transformer.h.7.self_attention.dense.bias": "pytorch_model-00001-of-00002.bin",
364
+ "transformer.h.7.self_attention.dense.weight": "pytorch_model-00001-of-00002.bin",
365
+ "transformer.h.7.self_attention.query_key_value.bias": "pytorch_model-00001-of-00002.bin",
366
+ "transformer.h.7.self_attention.query_key_value.weight": "pytorch_model-00001-of-00002.bin",
367
+ "transformer.h.8.input_layernorm.bias": "pytorch_model-00001-of-00002.bin",
368
+ "transformer.h.8.input_layernorm.weight": "pytorch_model-00001-of-00002.bin",
369
+ "transformer.h.8.mlp.dense_4h_to_h.bias": "pytorch_model-00001-of-00002.bin",
370
+ "transformer.h.8.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00002.bin",
371
+ "transformer.h.8.mlp.dense_h_to_4h.bias": "pytorch_model-00001-of-00002.bin",
372
+ "transformer.h.8.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00002.bin",
373
+ "transformer.h.8.post_attention_layernorm.bias": "pytorch_model-00001-of-00002.bin",
374
+ "transformer.h.8.post_attention_layernorm.weight": "pytorch_model-00001-of-00002.bin",
375
+ "transformer.h.8.self_attention.dense.bias": "pytorch_model-00001-of-00002.bin",
376
+ "transformer.h.8.self_attention.dense.weight": "pytorch_model-00001-of-00002.bin",
377
+ "transformer.h.8.self_attention.query_key_value.bias": "pytorch_model-00001-of-00002.bin",
378
+ "transformer.h.8.self_attention.query_key_value.weight": "pytorch_model-00001-of-00002.bin",
379
+ "transformer.h.9.input_layernorm.bias": "pytorch_model-00001-of-00002.bin",
380
+ "transformer.h.9.input_layernorm.weight": "pytorch_model-00001-of-00002.bin",
381
+ "transformer.h.9.mlp.dense_4h_to_h.bias": "pytorch_model-00001-of-00002.bin",
382
+ "transformer.h.9.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00002.bin",
383
+ "transformer.h.9.mlp.dense_h_to_4h.bias": "pytorch_model-00001-of-00002.bin",
384
+ "transformer.h.9.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00002.bin",
385
+ "transformer.h.9.post_attention_layernorm.bias": "pytorch_model-00001-of-00002.bin",
386
+ "transformer.h.9.post_attention_layernorm.weight": "pytorch_model-00001-of-00002.bin",
387
+ "transformer.h.9.self_attention.dense.bias": "pytorch_model-00001-of-00002.bin",
388
+ "transformer.h.9.self_attention.dense.weight": "pytorch_model-00001-of-00002.bin",
389
+ "transformer.h.9.self_attention.query_key_value.bias": "pytorch_model-00001-of-00002.bin",
390
+ "transformer.h.9.self_attention.query_key_value.weight": "pytorch_model-00001-of-00002.bin",
391
+ "transformer.ln_f.bias": "pytorch_model-00001-of-00002.bin",
392
+ "transformer.ln_f.weight": "pytorch_model-00001-of-00002.bin",
393
+ "transformer.word_embeddings.weight": "pytorch_model-00001-of-00002.bin"
394
+ }
395
+ }