init

config.json

@@ -0,0 +1,40 @@
+{
+  "apply_residual_connection_post_layernorm": false,
+  "architectures": [
+    "TelechatForCausalLM"
+  ],
+  "auto_map": {
+	"AutoConfig": "configuration_telechat.TelechatConfig",
+	"AutoModelForCausalLM": "modeling_telechat.TelechatForCausalLM"
+  },
+  "attention_dropout": 0.0,
+  "attention_softmax_in_fp32": true,
+  "bias_dropout_fusion": true,
+  "bos_token_id": 1,
+  "eos_token_id": 2,
+  "hidden_dropout": 0.0,
+  "hidden_size": 5120,
+  "initializer_range": 0.02,
+  "layer_norm_epsilon": 1e-05,
+  "masked_softmax_fusion": true,
+  "model_type": "telechat",
+  "n_head": 32,
+  "n_inner": null,
+  "n_layer": 38,
+  "offset_alibi": 100,
+  "pad_token_id": 3,
+  "pretraining_tp": 2,
+  "skip_bias_add": true,
+  "skip_bias_add_qkv": false,
+  "slow_but_exact": false,
+  "transformers_version": "4.24.0",
+  "unk_token_id": 0,
+  "use_cache": true,
+  "vocab_size": 120000,
+  "ffn_hidden_size": 12288,
+  "flash_attn":true,
+  "tie_word_embeddings":false,
+  "training_seqlen":8192,
+  "base_seqlen":8192
+}
+

configuration_telechat.py

@@ -0,0 +1,93 @@
+# coding=utf-8
+# Copyright 2022 the Big Science Workshop and HuggingFace Inc. team.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""" Telechat configuration"""
+
+from packaging import version
+from collections import OrderedDict
+from transformers.utils import is_torch_available, logging
+from transformers.configuration_utils import PretrainedConfig
+from typing import TYPE_CHECKING, Any, List, Mapping, Optional
+
+logger = logging.get_logger(__name__)
+
+class TelechatConfig(PretrainedConfig):
+    """
+    Args:
+        vocab_size (`int`, *optional*, defaults to 160256): Vocabulary size of the Telechat model.
+        hidden_size (`int`, *optional*, defaults to 4096): Dimensionality of the embeddings and hidden states.
+        ffn_hidden_size (`int`, *optional*, defaults to 12288): Dimensionality of the feed-forward hidden states.
+        n_layer (`int`, *optional*, defaults to 30): Number of hidden layers in the Transformer
+        n_head (`int`, *optional*, defaults to 32): Number of attention heads for each attention layer.
+        layer_norm_epsilon (`float`, *optional*, defaults to 1e-5): The epsilon to use in the layer normalization layers.
+        initializer_range (`float`, *optional*, defaults to 0.02): The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
+        apply_residual_connection_post_layernorm (`bool`, *optional*, defaults to `False`): If enabled, use the layer norm of the hidden states as the residual in the transformer blocks
+        hidden_dropout (`float`, *optional*, defaults to 0.0): Dropout rate of the dropout function on the bias dropout.
+        attention_dropout (`float`, *optional*, defaults to 0.0): Dropout rate applied to the attention probs
+        use_cache (`bool`, *optional*, defaults to `True`): Whether or not the model should return the last key/values attentions.
+        training_seqlen (`int`, *optional*, defaults to 8192): Sequence length during last finetuning.
+        logn (`bool`, *optional*, defaults to `True`): Whether or not to use logN during extrapolation.
+        embed_layernorm (`bool`, *optional*, defaults to `True`): Whether or not to use embedding layernorm.
+
+    """
+
+    model_type = "telechat"
+    keys_to_ignore_at_inference = ["past_key_values"]
+    attribute_map = {
+        "num_hidden_layers": "n_layer",
+        "num_attention_heads": "n_head",
+    }
+
+    def __init__(
+        self,
+        vocab_size=160256,
+        hidden_size=4096,
+        n_layer=30,
+        n_head=32,
+        layer_norm_epsilon=1e-5,
+        initializer_range=0.02,
+        use_cache=True,
+        bos_token_id=1,
+        eos_token_id=2,
+        apply_residual_connection_post_layernorm=False,
+        hidden_dropout=0.0,
+        attention_dropout=0.0,
+        ffn_hidden_size=12288,
+        training_seqlen = 8192,
+        logn = True,
+        embed_layernorm = False,
+        **kwargs,
+    ):
+        self.vocab_size = vocab_size
+        n_embed = kwargs.pop("n_embed", None)
+        self.hidden_size = hidden_size if n_embed is None else n_embed
+        self.n_layer = n_layer
+        self.n_head = n_head
+        self.layer_norm_epsilon = layer_norm_epsilon
+        self.initializer_range = initializer_range
+        self.use_cache = use_cache
+        self.apply_residual_connection_post_layernorm = apply_residual_connection_post_layernorm
+        self.hidden_dropout = hidden_dropout
+        self.attention_dropout = attention_dropout
+        self.bos_token_id = bos_token_id
+        self.eos_token_id = eos_token_id
+        self.logn = logn
+        self.ffn_hidden_size = ffn_hidden_size
+        self.training_seqlen = training_seqlen
+        self.embed_layernorm = embed_layernorm
+
+
+        super().__init__(bos_token_id=bos_token_id, eos_token_id=eos_token_id, **kwargs)
+

modeling_telechat.py

@@ -0,0 +1,840 @@
+
+# coding=utf-8
+# Copyright 2022 HuggingFace Inc. team and BigScience workshop.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Copyright (c) 2023, NVIDIA CORPORATION.  All rights reserved.
+
+# Copyright (c) 2021 EleutherAI
+# This file is based on code by the authors denoted below and has been modified from its original version.
+#
+# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+
+
+"""PyTorch TELECHAT model."""
+
+import warnings
+from typing import Optional, Tuple, Union
+
+import torch
+import math
+from torch import nn
+import torch.utils.checkpoint
+from torch.nn import functional as F
+from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, LayerNorm, MSELoss
+from transformers.modeling_outputs import (
+    BaseModelOutputWithPastAndCrossAttentions,
+    CausalLMOutputWithCrossAttentions
+)
+from transformers.modeling_utils import PreTrainedModel
+from transformers.utils import logging
+
+from .configuration_telechat import TelechatConfig
+
+logger = logging.get_logger(__name__)
+
+_CHECKPOINT_FOR_DOC = "telechat"
+_CONFIG_FOR_DOC = "TelechatConfig"
+
+TELECHAT_PRETRAINED_MODEL_ARCHIVE_LIST = []
+
+try:
+    from einops import rearrange
+except ImportError:
+    rearrange = None
+
+use_flash_attn = True
+try:
+    from flash_attn.flash_attn_interface import flash_attn_unpadded_func
+except ImportError:
+    try:
+        from flash_attn.flash_attn_interface import flash_attn_varlen_func as flash_attn_unpadded_func
+    except ImportError:
+        flash_attn_unpadded_func = None
+
+
+
+class RotaryEmbedding(torch.nn.Module):
+    # Extracted from: https://github.com/EleutherAI/gpt-neox
+    def __init__(self, dim ,config, base=10000, precision=torch.half):
+        super().__init__()
+        self.config = config
+        self.dim = dim
+        self.base = base
+        self.inv_freq = 1. / (base ** (torch.arange(0, dim, 2).float().half() / dim)).cuda()
+        self.max_seq_len_cached = None
+        self.cos_cached = None
+        self.sin_cached = None
+        self.precision = precision
+
+    def get_mscale(self,scale=1):
+        if scale <= 1:
+            return 1.0
+        return 0.1 * math.log(scale) + 1.0
+
+    def get_ntk_alpha(self, true_seq_len):
+        context_value = math.log(true_seq_len / self.config.base_seqlen, 2) + 1
+        # ntk_alpha = 2 ** context_value - 1
+        ntk_alpha = 2 ** math.ceil(context_value) - 1
+        ntk_alpha = max(ntk_alpha, 1)
+        return ntk_alpha
+
+    def forward(self, x, seq_dim=0, seq_len=None):
+        if seq_len is None:
+            seq_len = x.shape[seq_dim]
+        seq_len = max(seq_len, self.config.training_seqlen)
+        ntk_alpha = self.get_ntk_alpha(seq_len)
+        self.mscale = float(self.get_mscale(seq_len / self.config.training_seqlen))
+        if True:
+            base = self.base * ntk_alpha ** (self.dim / (self.dim - 2))
+            self.inv_freq = 1.0 / (base ** (torch.arange(0, self.dim, 2, device=x.device).float( )/ self.dim ))
+            self.max_seq_len_cached = seq_len
+            t = torch.arange(self.max_seq_len_cached, device=x.device, dtype=self.inv_freq.dtype)
+            freqs = torch.einsum('i,j->ij', t, self.inv_freq)
+            # Different from paper, but it uses a different permutation in order to obtain the same calculation
+            emb = torch.cat((freqs, freqs), dim=-1).to(x.device)
+            if self.precision == torch.bfloat16:
+                emb = emb.float()
+            # [sx, 1 (b * np), hn]
+            self.cos_cached = self.mscale *emb.cos()[:, None, :].half()
+            self.sin_cached = self.mscale *emb.sin()[:, None, :].half()
+            if self.precision == torch.bfloat16:
+                self.cos_cached = self.cos_cached.bfloat16()
+                self.sin_cached = self.sin_cached.bfloat16()
+        return self.cos_cached[:seq_len, ...], self.sin_cached[:seq_len, ...]
+
+
+
+# rotary pos emb helpers:
+def rotate_half(x):
+    x1, x2 = x[..., :x.shape[-1] // 2], x[..., x.shape[-1] // 2:]
+    return torch.cat((-x2, x1), dim=x1.ndim - 1)  # dim=-1 triggers a bug in earlier torch versions
+
+def apply_rotary_pos_emb_torch(q, k, cos, sin, offset: int = 0):  # jitting fails with bf16
+    cos, sin = cos[offset:q.shape[0] + offset, ...], sin[offset:q.shape[0] + offset, ...]
+    return (q * cos) + (rotate_half(q) * sin), (k * cos) + (rotate_half(k) * sin)
+
+
+class MixedFusedRMSNorm(nn.Module):
+    # Extracted from https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama/modeling_llama.py
+    def __init__(self, hidden_size, eps=1e-6):
+        super().__init__()
+        self.weight = nn.Parameter(torch.ones(hidden_size))
+        self.variance_epsilon = eps
+
+    def forward(self, hidden_states):
+        input_dtype = hidden_states.dtype
+        hidden_states = hidden_states.to(torch.float32)
+        variance = hidden_states.pow(2).mean(-1, keepdim=True)
+        hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)
+        return self.weight * hidden_states.to(input_dtype)
+
+
+class FlashSelfAttention(torch.nn.Module):
+    # Extracted from https://github.com/microsoft/Megatron-DeepSpeed/blob/main/megatron/model/transformer.py
+    """Implement the scaled dot product attention with softmax.
+    Arguments
+    ---------
+        softmax_scale: The temperature to use for the softmax attention.
+                      (default: 1/sqrt(d_keys) where d_keys is computed at
+                      runtime)
+        attention_dropout: The dropout rate to apply to the attention
+                           (default: 0.0)
+    """
+
+    def __init__(self, causal=False, softmax_scale=None, attention_dropout=0.0,
+                 device=None, dtype=None):
+        super().__init__()
+        assert flash_attn_unpadded_func is not None, ('Please install FlashAttention first, '
+                                                      'e.g., with pip install flash-attn')
+        assert rearrange is not None, 'Please install einops first, e.g., with pip install einops'
+        self.causal = causal
+        self.softmax_scale = softmax_scale
+        self.dropout_p = attention_dropout
+
+    def forward(self, q, k, v):
+        """Implements the multihead softmax attention.
+        Arguments
+        ---------
+            q, k, v: The tensor containing the query, key, and value. (B, S, H, D)
+        """
+        assert all((i.dtype in [torch.float16, torch.bfloat16] for i in (q, k, v)))
+        assert all((i.is_cuda for i in (q, k, v)))
+
+        batch_size, seqlen_q = q.shape[0], q.shape[1]
+        seqlen_k = k.shape[1]
+
+        q, k, v = [rearrange(x, 'b s ... -> (b s) ...') for x in [q, k, v]]
+        cu_seqlens_q = torch.arange(0, (batch_size + 1) * seqlen_q, step=seqlen_q, dtype=torch.int32,
+                                    device=q.device)
+        self.training = False
+        if self.training:
+            # during training q,k,v always have same seqlen
+            assert seqlen_k == seqlen_q
+
+            is_causal = self.causal
+            cu_seqlens_k = cu_seqlens_q
+            dropout_p = self.dropout_p
+        else:
+            # turn off FA causal mask after first inference autoregressive iteration
+            # only on first autoregressive step q,k,v have same seqlen
+            is_causal = seqlen_q == seqlen_k
+            cu_seqlens_k = torch.arange(0, (batch_size + 1) * seqlen_k, step=seqlen_k, dtype=torch.int32,
+                                        device=q.device)
+            dropout_p = 0
+
+        output = flash_attn_unpadded_func(
+            q, k, v, cu_seqlens_q, cu_seqlens_k, seqlen_q, seqlen_k,
+            dropout_p=dropout_p,
+            softmax_scale=self.softmax_scale, causal=is_causal
+        )
+
+        output = rearrange(output, '(b s) ... -> b s ...', b=batch_size)
+        return output
+
+
+
+def _make_causal_mask(
+        input_ids_shape: torch.Size, device: torch.device, past_key_values_length: int
+) -> torch.BoolTensor:
+    """
+    Make causal mask used for self-attention.
+    """
+    batch_size, target_length = input_ids_shape
+    mask = torch.empty((target_length, target_length + past_key_values_length), dtype=torch.bool, device=device)
+    # ONNX doesn't support `torch.Tensor.triu` properly, thus we use this workaround
+    seq_ids = torch.arange(target_length, device=device)
+    mask[:, past_key_values_length:] = seq_ids[:, None] < seq_ids[None, :]
+
+    if past_key_values_length > 0:
+        mask[:, :past_key_values_length] = False
+
+    expanded_mask = mask[None, None, :, :].expand(batch_size, 1, target_length, target_length + past_key_values_length)
+    return expanded_mask
+
+
+def _expand_mask(mask: torch.Tensor, tgt_length: int) -> torch.BoolTensor:
+    """
+    Expands attention_mask from `[batch_size, src_length]` to `[batch_size, 1, tgt_length, src_length]`.
+    """
+    batch_size, src_length = mask.shape
+    tgt_length = tgt_length if tgt_length is not None else src_length
+
+    expanded_mask = ~(mask[:, None, None, :].to(torch.bool))
+    return expanded_mask.expand(batch_size, 1, tgt_length, src_length)
+
+
+
+def dropout_add(x: torch.Tensor, residual: torch.Tensor, prob: float, training: bool) -> torch.Tensor:
+    """
+    Dropout add function
+
+    Args:
+        x (`torch.tensor`, *required*):
+            input tensor
+        residual (`torch.tensor`, *required*):
+            residual tensor
+        prob (`float`, *required*):
+            dropout probability
+        training (`bool`, *required*):
+            training mode
+    """
+    out = F.dropout(x, p=prob, training=training)
+    out = residual + out
+    return out
+
+
+def telechat_gelu_forward(x: torch.Tensor) -> torch.Tensor:
+    """
+    Custom bias GELU function. Adapted from Megatron-DeepSpeed code. Here we use a simple implementation (inference) to
+    make the model jitable.
+
+    Args:
+        x (`torch.tensor`, *required*):
+            input hidden states
+    """
+    return x * 0.5 * (1.0 + torch.tanh(0.79788456 * x * (1 + 0.044715 * x * x)))
+
+
+def telechat_gelu_back(g: torch.Tensor, x: torch.Tensor) -> torch.Tensor:
+    """
+    gradient of tanh approximation of gelu gradient of actual gelu is: 0.5 * (1. + torch.erf(x * 0.70710678)) +
+    0.3989423 * x * torch.exp(-0.5 * x * x)
+
+    Args:
+        g (`torch.tensor`, *required*):
+            gradient output tensor
+        x (`torch.tensor`, *required*):
+            input tensor
+    """
+    x = x[0]  # x is a tuple of 1 element, needs to unpack it first
+    tanh_out = torch.tanh(0.79788456 * x * (1 + 0.044715 * x * x))
+    # sqrt(2/pi) * 3 * 0.044715 -> 0.1070322243
+    ff = 0.5 * x * ((1 - tanh_out * tanh_out) * (0.79788456 + 0.1070322243 * x * x)) + 0.5 * (1 + tanh_out)
+    return ff * g
+
+
+class GeLUFunction(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, input: torch.Tensor) -> torch.Tensor:
+        ctx.save_for_backward(input)
+        return telechat_gelu_forward(input)
+
+    @staticmethod
+    def backward(ctx, grad_output: torch.Tensor) -> torch.Tensor:
+        input = ctx.saved_tensors
+        tmp = telechat_gelu_back(grad_output, input)
+        return tmp
+
+
+class TelechatGelu(nn.Module):
+    """
+    TelechatBiasGelu wrapper function that make use of the simple function on inference mode to make the model
+    torchscriptable and use the autograd function in training mode to get the accurate results of the gradients Partly
+    copied from Megatron-DeepSpeed code and adapted for our needs
+
+    See here why autograd functions are not torchscriptable: https://github.com/pytorch/pytorch/issues/22329
+    """
+
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        if self.training:
+            return GeLUFunction.apply(x)
+        else:
+            return telechat_gelu_forward(x)
+
+
+class TelechatAttention(nn.Module):
+    def __init__(self, config: TelechatConfig ,layer_idx):
+        super().__init__()
+        self.kv_cache = None
+        self.layer_idx = layer_idx
+
+        self.hidden_size = config.hidden_size
+        self.num_heads = config.n_head
+        self.head_dim = self.hidden_size // self.num_heads
+        self.split_size = self.hidden_size
+        self.hidden_dropout = config.hidden_dropout
+        self.config = config
+
+        if self.head_dim * self.num_heads != self.hidden_size:
+            raise ValueError(
+                f"`hidden_size` must be divisible by num_heads (got `hidden_size`: {self.hidden_size} and `num_heads`:"
+                f" {self.num_heads})."
+            )
+
+        # Layer-wise attention scaling
+        self.inv_norm_factor = 1.0 / math.sqrt(self.head_dim)
+        self.beta = 1.0
+
+        self.num_key_value_heads = self.num_heads
+        kv_projection_size = self.head_dim * self.num_key_value_heads
+        self.num_key_value_groups = self.num_heads // self.num_key_value_heads
+        self.query = nn.Linear(self.hidden_size, self.hidden_size, bias=False)
+        self.key_value = nn.Linear(self.hidden_size, kv_projection_size * 2, bias=False)
+        self.dense = nn.Linear(self.hidden_size, self.hidden_size)
+        self.attention_dropout = nn.Dropout(config.attention_dropout)
+        self.rotary_emb = RotaryEmbedding(self.head_dim ,config=config)
+
+        self.core_attention_flash = FlashSelfAttention(
+            causal=True, attention_dropout=config.attention_dropout
+        )
+
+        self.last_key_layer = None
+        #logn_list = [math.log(i, 4096) if i > 4096 else 1 for i in range(1, 32768)]
+        #self.logn_tensor = torch.tensor(logn_list)[None, :, None, None].half().cuda()
+
+
+    def repeat_kv(self, hidden_states, n_rep):
+        slen, batch, num_key_value_heads_per_partition, head_dim = hidden_states.shape
+        if n_rep == 1:
+            return hidden_states
+        hidden_states = hidden_states[:, :, :, None, :].expand(slen, batch, num_key_value_heads_per_partition, n_rep,
+                                                               head_dim)
+        return hidden_states.reshape(slen, batch, num_key_value_heads_per_partition * n_rep, head_dim)
+
+    def split_tensor_along_last_dim(self,
+                                    tensor: torch.Tensor,
+                                    num_partitions: int,
+                                    contiguous_split_chunks: bool = False,
+                                    ):
+
+        # Get the size and dimension.
+        last_dim = tensor.dim() - 1
+        last_dim_size = tensor.size()[last_dim] // num_partitions
+        # Split.
+        tensor_list = torch.split(tensor, last_dim_size, dim=last_dim)
+        # Note: torch.split does not create contiguous tensors by default.
+        if contiguous_split_chunks:
+            return tuple(chunk.contiguous() for chunk in tensor_list)
+
+        return tensor_list
+
+    def _merge_heads(self, x: torch.Tensor) -> torch.Tensor:
+        batch_size_and_num_heads, seq_length, _ = x.shape
+        batch_size = batch_size_and_num_heads // self.num_heads
+        x = x.view(batch_size, self.num_heads, seq_length, self.head_dim)
+        x = x.permute(0, 2, 1, 3)
+        return x.reshape(batch_size, seq_length, self.num_heads * self.head_dim)
+
+    def forward(
+            self,
+            hidden_states: torch.Tensor,
+            residual: torch.Tensor,
+            attention_mask: torch.Tensor,
+            layer_past: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,
+            use_cache: bool = False,
+            output_attentions: bool = False,
+    ):
+        hidden_states = hidden_states.transpose(1, 0)
+        query_layer = self.query(hidden_states)
+        new_tensor_shape = query_layer.size()[:-1] + \
+                           (self.num_heads,
+                            self.head_dim)
+        query_layer = query_layer.view(*new_tensor_shape)
+
+        mixed_kv_layer = self.key_value(hidden_states)
+        new_tensor_shape = mixed_kv_layer.size()[:-1] + \
+                           (self.num_key_value_heads,
+                            2 * self.head_dim)
+        mixed_kv_layer = mixed_kv_layer.view(*new_tensor_shape)
+        (key_layer, value_layer) = self.split_tensor_along_last_dim(mixed_kv_layer, 2)
+
+        output_size = (query_layer.size(1),
+                       query_layer.size(2),
+                       query_layer.size(0),
+                       key_layer.size(0))
+
+        query_layer = query_layer.view(output_size[2], output_size[0] * output_size[1], -1)
+        key_layer = key_layer.view(output_size[3], output_size[0] * output_size[1], -1)
+
+        apply_rotary_fn = apply_rotary_pos_emb_torch
+
+        seq_len = key_layer.shape[0]
+        offset = 0
+
+        if  use_cache and layer_past != None:
+            past_key, past_value  = layer_past
+            offset = past_key.shape[0]
+            seq_len += offset
+
+        cos, sin = self.rotary_emb(value_layer, seq_len=seq_len)
+
+        query_layer, key_layer = apply_rotary_fn(query_layer, key_layer, cos, sin, offset=offset)
+        if use_cache:
+            if layer_past != None:
+                past_key, past_value = layer_past
+                key_layer = torch.cat((past_key, key_layer[-1, ...].unsqueeze(0)) ,dim=0)
+                value_layer = torch.cat((past_value ,value_layer[-1 ,...].unsqueeze(0)) ,dim = 0)
+            layer_past = key_layer ,value_layer
+        s, bz, head, dim = value_layer.shape
+        s_key = key_layer.shape[0]
+        s_query = query_layer.shape[0]
+        query_layer = query_layer.reshape((s_query, bz, head, dim))
+        key_layer = key_layer.reshape((s_key, bz, head, dim))
+
+
+        if self.config.flash_attn:
+            q, k, v = [rearrange(x, 's b ... -> b s ...').contiguous() for x in
+                       (query_layer, key_layer, value_layer)]
+            context_layer = self.core_attention_flash(q, k, v)
+            context_layer = rearrange(context_layer, 'b s h d -> b s (h d)').contiguous()
+        else:
+            ##[sq, b, np, hn] -> [sq, b * np, hn]
+            query_layer = query_layer.reshape(s_query ,bz * self.num_heads, dim)
+            # [sk, b, np, hn] -> [sk, b * np, hn]
+            key_layer = key_layer.reshape(s_key, bz * self.num_heads, dim)
+            matmul_result = self.inv_norm_factor * torch.einsum('bik,bkj->bij', query_layer.transpose(0, 1), key_layer.transpose(0, 1).transpose(1, 2))
+
+            attention_scores = matmul_result.view(bz, self.num_heads, s_query, s_key)
+
+            input_dtype = attention_scores.dtype
+            if input_dtype == torch.float16:
+                attention_scores = attention_scores.to(torch.float)
+            attn_weights = torch.masked_fill(attention_scores, attention_mask, torch.finfo(attention_scores.dtype).min)
+            attention_probs = F.softmax(attn_weights, dim=-1).to(input_dtype)  ##dtype = torch.float32
+            attention_probs = self.attention_dropout(attention_probs)
+            attention_probs_reshaped = attention_probs.view(bz * self.num_heads, s_query, s_key)
+
+            value_layer = value_layer.reshape(s_key ,bz * self.num_heads, dim)
+            context_layer = torch.bmm(attention_probs_reshaped, value_layer.transpose(0, 1))
+            context_layer = self._merge_heads(context_layer)
+
+        output_tensor = self.dense(context_layer)
+
+        output_tensor = dropout_add(output_tensor, residual, self.hidden_dropout, self.training)
+        present = None
+        outputs = (output_tensor, present)
+        if output_attentions:
+            outputs += (attention_probs,)
+
+        return output_tensor, layer_past
+
+class TelechatMLP(nn.Module):
+    def __init__(self, config: TelechatConfig):
+        super().__init__()
+        hidden_size = config.hidden_size
+        self.gate_proj = nn.Linear(hidden_size, config.ffn_hidden_size, bias=False)
+        self.up_proj = nn.Linear(hidden_size, config.ffn_hidden_size, bias=False)
+        self.down_proj = nn.Linear(config.ffn_hidden_size, hidden_size, bias=True)
+        self.hidden_dropout = config.hidden_dropout
+
+    def forward(self, hidden_states: torch.Tensor, residual: torch.Tensor) -> torch.Tensor:
+        intermediate_output = self.down_proj(F.silu(self.gate_proj(hidden_states)) * self.up_proj(hidden_states))
+        output = dropout_add(intermediate_output, residual, self.hidden_dropout, self.training)
+        return output
+
+
+class TelechatBlock(nn.Module):
+    def __init__(self, config: TelechatConfig ,layer_idx):
+        super().__init__()
+        hidden_size = config.hidden_size
+
+        self.input_layernorm = MixedFusedRMSNorm(hidden_size, eps=config.layer_norm_epsilon)
+        self.num_heads = config.n_head
+        self.layer_idx = layer_idx
+        self.self_attention = TelechatAttention(config ,layer_idx)
+        self.post_attention_layernorm = MixedFusedRMSNorm(hidden_size, eps=config.layer_norm_epsilon)
+
+        self.mlp = TelechatMLP(config)
+
+        self.apply_residual_connection_post_layernorm = config.apply_residual_connection_post_layernorm
+        self.hidden_dropout = config.hidden_dropout
+
+    def forward(
+            self,
+            hidden_states: torch.Tensor,
+            attention_mask: torch.Tensor,
+            layer_past: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,
+            use_cache: bool = False,
+            output_attentions: bool = False,
+    ):
+        layernorm_output = self.input_layernorm(hidden_states)
+        if self.apply_residual_connection_post_layernorm:
+            residual = layernorm_output
+        else:
+            residual = hidden_states
+
+        attn_outputs = self.self_attention(
+            layernorm_output,
+            residual,
+            layer_past=layer_past,
+            attention_mask=attention_mask,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+        )
+
+        attention_output = attn_outputs[0]
+        outputs = attn_outputs[1:]
+        layernorm_output = self.post_attention_layernorm(attention_output)
+
+        if self.apply_residual_connection_post_layernorm:
+            residual = layernorm_output
+        else:
+            residual = attention_output
+        output = self.mlp(layernorm_output, residual)
+
+        if use_cache:
+            outputs = (output,) + outputs
+        else:
+            outputs = (output,) + outputs[1:]
+
+        return outputs
+
+
+class TelechatPreTrainedModel(PreTrainedModel):
+    config_class = TelechatConfig
+    base_model_prefix = "transformer"
+    supports_gradient_checkpointing = True
+    _no_split_modules = ["TelechatBlock"]
+    _skip_keys_device_placement = "past_key_values"
+
+    def __init__(self, *inputs, **kwargs):
+        super().__init__(*inputs, **kwargs)
+
+    def _init_weights(self, module: nn.Module):
+        """Initialize the weights."""
+        if isinstance(module, nn.Linear):
+            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
+            if module.bias is not None:
+                module.bias.data.zero_()
+
+        elif isinstance(module, nn.Embedding):
+            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
+            if module.padding_idx is not None:
+                module.weight.data[module.padding_idx].zero_()
+
+        elif isinstance(module, LayerNorm):
+            module.bias.data.zero_()
+            module.weight.data.fill_(1.0)
+
+    def _set_gradient_checkpointing(self, module: nn.Module, value: bool = False):
+        if isinstance(module, TelechatModel):
+            module.gradient_checkpointing = value
+
+
+class TelechatModel(TelechatPreTrainedModel):
+    def __init__(self, config: TelechatConfig):
+        super().__init__(config)
+
+        self.embed_dim = config.hidden_size
+        self.num_heads = config.n_head
+        self.config = config
+        self.word_embeddings = nn.Embedding(config.vocab_size, self.embed_dim)
+        if self.config.embed_layernorm:
+            self.word_embeddings_layernorm = MixedFusedRMSNorm(self.embed_dim, eps=config.layer_norm_epsilon)
+
+        self.h = nn.ModuleList([TelechatBlock(config ,_) for _ in range(config.num_hidden_layers)])
+        self.ln_f = MixedFusedRMSNorm(self.embed_dim, eps=config.layer_norm_epsilon)
+        self.gradient_checkpointing = False
+        self.post_init()
+
+
+    def get_input_embeddings(self):
+        return self.word_embeddings
+
+    def _prepare_attn_mask(
+            self, attention_mask: torch.Tensor, input_shape: Tuple[int, int], past_key_values_length: int
+    ) -> torch.BoolTensor:
+        combined_attention_mask = None
+        device = attention_mask.device
+        _, src_length = input_shape
+
+        if src_length > 1:
+            combined_attention_mask = _make_causal_mask(
+                input_shape, device=device, past_key_values_length=past_key_values_length
+            )
+        expanded_attn_mask = _expand_mask(attention_mask, tgt_length=src_length)
+        combined_attention_mask = (
+            expanded_attn_mask if combined_attention_mask is None else expanded_attn_mask | combined_attention_mask
+        )
+
+        return combined_attention_mask
+
+    def set_input_embeddings(self, new_embeddings: torch.Tensor):
+        self.word_embeddings = new_embeddings
+
+    def forward(
+            self,
+            input_ids: Optional[torch.LongTensor] = None,
+            past_key_values: Optional[Tuple[Tuple[torch.Tensor, torch.Tensor], ...]] = None,
+            attention_mask: Optional[torch.Tensor] = None,
+            inputs_embeds: Optional[torch.LongTensor] = None,
+            use_cache: Optional[bool] = None,
+            output_attentions: Optional[bool] = None,
+            output_hidden_states: Optional[bool] = None,
+            return_dict: Optional[bool] = None,
+            **deprecated_arguments,
+    ) -> Union[Tuple[torch.Tensor, ...], BaseModelOutputWithPastAndCrossAttentions]:
+
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        output_hidden_states = (
+            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        )
+        use_cache = use_cache if use_cache is not None else self.config.use_cache
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+
+        if input_ids is not None:
+            batch_size, seq_length = input_ids.shape
+        elif inputs_embeds is not None:
+            batch_size, seq_length, _ = inputs_embeds.shape
+
+        if past_key_values is None:
+            past_key_values = tuple([None] * len(self.h))
+
+
+        if inputs_embeds is None:
+            inputs_embeds = self.word_embeddings(input_ids)
+        hidden_states = inputs_embeds
+
+        if self.config.embed_layernorm:
+            hidden_states = self.word_embeddings_layernorm(inputs_embeds)
+
+        presents = () if use_cache else None
+        all_self_attentions = () if output_attentions else None
+        all_hidden_states = () if output_hidden_states else None
+
+        if self.gradient_checkpointing and self.training:
+            if use_cache:
+                use_cache = False
+
+        seq_length_with_past = seq_length
+        past_key_values_length = 0
+        if past_key_values[0] is not None:
+            past_key_values_length = past_key_values[0][0].shape[2]
+            seq_length_with_past = seq_length_with_past + past_key_values_length
+        if attention_mask is None:
+            attention_mask = torch.ones((batch_size, seq_length_with_past), device=hidden_states.device)
+        else:
+            attention_mask = attention_mask.to(hidden_states.device)
+        causal_mask = self._prepare_attn_mask(
+            attention_mask,
+            input_shape=(batch_size, seq_length),
+            past_key_values_length=past_key_values_length,
+        )
+
+        for i, (block, layer_past) in enumerate(zip(self.h, past_key_values)):
+            if output_hidden_states:
+                all_hidden_states = all_hidden_states + (hidden_states,)
+
+            if self.gradient_checkpointing and self.training:
+
+                def create_custom_forward(module):
+                    def custom_forward(*inputs):
+                        # None for past_key_value
+                        return module(*inputs, use_cache=use_cache, output_attentions=output_attentions)
+
+                    return custom_forward
+
+                outputs = torch.utils.checkpoint.checkpoint(
+                    create_custom_forward(block),
+                    hidden_states,
+                    causal_mask,
+                    layer_past,
+                )
+            else:
+                outputs = block(
+                    hidden_states,
+                    layer_past=layer_past,
+                    attention_mask=causal_mask,
+                    use_cache=use_cache,
+                    output_attentions=output_attentions,
+                )
+
+            hidden_states = outputs[0]
+            if use_cache is True:
+                presents = presents + (outputs[1],)
+
+            if output_attentions:
+                all_self_attentions = all_self_attentions + (outputs[2 if use_cache else 1],)
+        hidden_states = self.ln_f(hidden_states)
+        if output_hidden_states:
+            all_hidden_states = all_hidden_states + (hidden_states,)
+        if not return_dict:
+            return tuple(v for v in [hidden_states, presents, all_hidden_states, all_self_attentions] if v is not None)
+        return BaseModelOutputWithPastAndCrossAttentions(
+            last_hidden_state=hidden_states,
+            past_key_values=presents,
+            hidden_states=all_hidden_states,
+            attentions=all_self_attentions,
+        )
+
+
+class TelechatForCausalLM(TelechatPreTrainedModel):
+    # _tied_weights_keys = ["lm_head.weight"]
+    _keys_to_ignore_on_load_missing = [ r"lm_head.weight"]
+    def __init__(self, config: TelechatConfig):
+        super().__init__(config)
+        self.transformer = TelechatModel(config)
+        self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
+        self.post_init()
+
+    def get_output_embeddings(self):
+        return self.lm_head
+
+    def set_output_embeddings(self, new_embeddings: torch.Tensor):
+        self.lm_head = new_embeddings
+
+    def prepare_inputs_for_generation(
+            self,
+            input_ids: torch.LongTensor,
+            past_key_values: Optional[torch.Tensor] = None,
+            attention_mask: Optional[torch.Tensor] = None,
+            inputs_embeds: Optional[torch.Tensor] = None,
+            **kwargs,
+    ) -> dict:
+        if past_key_values:
+            input_ids = input_ids[:, -1].unsqueeze(-1)
+        if inputs_embeds is not None and past_key_values is None:
+            model_inputs = {"inputs_embeds": inputs_embeds}
+        else:
+            model_inputs = {"input_ids": input_ids}
+
+        model_inputs.update(
+            {
+                "past_key_values": past_key_values,
+                "use_cache": kwargs.get("use_cache"),
+                "attention_mask": attention_mask,
+            }
+        )
+        return model_inputs
+
+    def forward(
+            self,
+            input_ids: Optional[torch.LongTensor] = None,
+            past_key_values: Optional[Tuple[Tuple[torch.Tensor, torch.Tensor], ...]] = None,
+            attention_mask: Optional[torch.Tensor] = None,
+            inputs_embeds: Optional[torch.Tensor] = None,
+            labels: Optional[torch.Tensor] = None,
+            use_cache: Optional[bool] = None,
+            output_attentions: Optional[bool] = None,
+            output_hidden_states: Optional[bool] = None,
+            return_dict: Optional[bool] = None,
+            **deprecated_arguments,
+    ) -> Union[Tuple[torch.Tensor], CausalLMOutputWithCrossAttentions]:
+
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        transformer_outputs = self.transformer(
+            input_ids,
+            past_key_values=past_key_values,
+            attention_mask=attention_mask,
+            inputs_embeds=inputs_embeds,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+        hidden_states = transformer_outputs[0]
+        lm_logits = self.lm_head(hidden_states)
+
+        loss = None
+        if labels is not None:
+            labels = labels.to(lm_logits.device)
+            shift_logits = lm_logits[..., :-1, :].contiguous()
+            shift_labels = labels[..., 1:].contiguous()
+            batch_size, seq_length, vocab_size = shift_logits.shape
+            loss_fct = CrossEntropyLoss()
+            loss = loss_fct(
+                shift_logits.view(batch_size * seq_length, vocab_size), shift_labels.view(batch_size * seq_length)
+            )
+
+        if not return_dict:
+            output = (lm_logits,) + transformer_outputs[1:]
+            return ((loss,) + output) if loss is not None else output
+
+        return CausalLMOutputWithCrossAttentions(
+            loss=loss,
+            logits=lm_logits,
+            past_key_values=transformer_outputs.past_key_values,
+            hidden_states=transformer_outputs.hidden_states,
+            attentions=transformer_outputs.attentions,
+        )

pytorch_model.bin.index.json

@@ -0,0 +1,390 @@
+{
+  "metadata": {
+    "total_size": 24772864000
+  },
+  "weight_map": {
+    "lm_head.weight": "pytorch_model_00041-of-00041.bin",
+    "transformer.h.0.input_layernorm.weight": "pytorch_model_00002-of-00041.bin",
+    "transformer.h.0.mlp.down_proj.bias": "pytorch_model_00002-of-00041.bin",
+    "transformer.h.0.mlp.down_proj.weight": "pytorch_model_00002-of-00041.bin",
+    "transformer.h.0.mlp.gate_proj.weight": "pytorch_model_00002-of-00041.bin",
+    "transformer.h.0.mlp.up_proj.weight": "pytorch_model_00002-of-00041.bin",
+    "transformer.h.0.post_attention_layernorm.weight": "pytorch_model_00002-of-00041.bin",
+    "transformer.h.0.self_attention.dense.bias": "pytorch_model_00002-of-00041.bin",
+    "transformer.h.0.self_attention.dense.weight": "pytorch_model_00002-of-00041.bin",
+    "transformer.h.0.self_attention.key_value.weight": "pytorch_model_00002-of-00041.bin",
+    "transformer.h.0.self_attention.query.weight": "pytorch_model_00002-of-00041.bin",
+    "transformer.h.1.input_layernorm.weight": "pytorch_model_00003-of-00041.bin",
+    "transformer.h.1.mlp.down_proj.bias": "pytorch_model_00003-of-00041.bin",
+    "transformer.h.1.mlp.down_proj.weight": "pytorch_model_00003-of-00041.bin",
+    "transformer.h.1.mlp.gate_proj.weight": "pytorch_model_00003-of-00041.bin",
+    "transformer.h.1.mlp.up_proj.weight": "pytorch_model_00003-of-00041.bin",
+    "transformer.h.1.post_attention_layernorm.weight": "pytorch_model_00003-of-00041.bin",
+    "transformer.h.1.self_attention.dense.bias": "pytorch_model_00003-of-00041.bin",
+    "transformer.h.1.self_attention.dense.weight": "pytorch_model_00003-of-00041.bin",
+    "transformer.h.1.self_attention.key_value.weight": "pytorch_model_00003-of-00041.bin",
+    "transformer.h.1.self_attention.query.weight": "pytorch_model_00003-of-00041.bin",
+    "transformer.h.10.input_layernorm.weight": "pytorch_model_00012-of-00041.bin",
+    "transformer.h.10.mlp.down_proj.bias": "pytorch_model_00012-of-00041.bin",
+    "transformer.h.10.mlp.down_proj.weight": "pytorch_model_00012-of-00041.bin",
+    "transformer.h.10.mlp.gate_proj.weight": "pytorch_model_00012-of-00041.bin",
+    "transformer.h.10.mlp.up_proj.weight": "pytorch_model_00012-of-00041.bin",
+    "transformer.h.10.post_attention_layernorm.weight": "pytorch_model_00012-of-00041.bin",
+    "transformer.h.10.self_attention.dense.bias": "pytorch_model_00012-of-00041.bin",
+    "transformer.h.10.self_attention.dense.weight": "pytorch_model_00012-of-00041.bin",
+    "transformer.h.10.self_attention.key_value.weight": "pytorch_model_00012-of-00041.bin",
+    "transformer.h.10.self_attention.query.weight": "pytorch_model_00012-of-00041.bin",
+    "transformer.h.11.input_layernorm.weight": "pytorch_model_00013-of-00041.bin",
+    "transformer.h.11.mlp.down_proj.bias": "pytorch_model_00013-of-00041.bin",
+    "transformer.h.11.mlp.down_proj.weight": "pytorch_model_00013-of-00041.bin",
+    "transformer.h.11.mlp.gate_proj.weight": "pytorch_model_00013-of-00041.bin",
+    "transformer.h.11.mlp.up_proj.weight": "pytorch_model_00013-of-00041.bin",
+    "transformer.h.11.post_attention_layernorm.weight": "pytorch_model_00013-of-00041.bin",
+    "transformer.h.11.self_attention.dense.bias": "pytorch_model_00013-of-00041.bin",
+    "transformer.h.11.self_attention.dense.weight": "pytorch_model_00013-of-00041.bin",
+    "transformer.h.11.self_attention.key_value.weight": "pytorch_model_00013-of-00041.bin",
+    "transformer.h.11.self_attention.query.weight": "pytorch_model_00013-of-00041.bin",
+    "transformer.h.12.input_layernorm.weight": "pytorch_model_00014-of-00041.bin",
+    "transformer.h.12.mlp.down_proj.bias": "pytorch_model_00014-of-00041.bin",
+    "transformer.h.12.mlp.down_proj.weight": "pytorch_model_00014-of-00041.bin",
+    "transformer.h.12.mlp.gate_proj.weight": "pytorch_model_00014-of-00041.bin",
+    "transformer.h.12.mlp.up_proj.weight": "pytorch_model_00014-of-00041.bin",
+    "transformer.h.12.post_attention_layernorm.weight": "pytorch_model_00014-of-00041.bin",
+    "transformer.h.12.self_attention.dense.bias": "pytorch_model_00014-of-00041.bin",
+    "transformer.h.12.self_attention.dense.weight": "pytorch_model_00014-of-00041.bin",
+    "transformer.h.12.self_attention.key_value.weight": "pytorch_model_00014-of-00041.bin",
+    "transformer.h.12.self_attention.query.weight": "pytorch_model_00014-of-00041.bin",
+    "transformer.h.13.input_layernorm.weight": "pytorch_model_00015-of-00041.bin",
+    "transformer.h.13.mlp.down_proj.bias": "pytorch_model_00015-of-00041.bin",
+    "transformer.h.13.mlp.down_proj.weight": "pytorch_model_00015-of-00041.bin",
+    "transformer.h.13.mlp.gate_proj.weight": "pytorch_model_00015-of-00041.bin",
+    "transformer.h.13.mlp.up_proj.weight": "pytorch_model_00015-of-00041.bin",
+    "transformer.h.13.post_attention_layernorm.weight": "pytorch_model_00015-of-00041.bin",
+    "transformer.h.13.self_attention.dense.bias": "pytorch_model_00015-of-00041.bin",
+    "transformer.h.13.self_attention.dense.weight": "pytorch_model_00015-of-00041.bin",
+    "transformer.h.13.self_attention.key_value.weight": "pytorch_model_00015-of-00041.bin",
+    "transformer.h.13.self_attention.query.weight": "pytorch_model_00015-of-00041.bin",
+    "transformer.h.14.input_layernorm.weight": "pytorch_model_00016-of-00041.bin",
+    "transformer.h.14.mlp.down_proj.bias": "pytorch_model_00016-of-00041.bin",
+    "transformer.h.14.mlp.down_proj.weight": "pytorch_model_00016-of-00041.bin",
+    "transformer.h.14.mlp.gate_proj.weight": "pytorch_model_00016-of-00041.bin",
+    "transformer.h.14.mlp.up_proj.weight": "pytorch_model_00016-of-00041.bin",
+    "transformer.h.14.post_attention_layernorm.weight": "pytorch_model_00016-of-00041.bin",
+    "transformer.h.14.self_attention.dense.bias": "pytorch_model_00016-of-00041.bin",
+    "transformer.h.14.self_attention.dense.weight": "pytorch_model_00016-of-00041.bin",
+    "transformer.h.14.self_attention.key_value.weight": "pytorch_model_00016-of-00041.bin",
+    "transformer.h.14.self_attention.query.weight": "pytorch_model_00016-of-00041.bin",
+    "transformer.h.15.input_layernorm.weight": "pytorch_model_00017-of-00041.bin",
+    "transformer.h.15.mlp.down_proj.bias": "pytorch_model_00017-of-00041.bin",
+    "transformer.h.15.mlp.down_proj.weight": "pytorch_model_00017-of-00041.bin",
+    "transformer.h.15.mlp.gate_proj.weight": "pytorch_model_00017-of-00041.bin",
+    "transformer.h.15.mlp.up_proj.weight": "pytorch_model_00017-of-00041.bin",
+    "transformer.h.15.post_attention_layernorm.weight": "pytorch_model_00017-of-00041.bin",
+    "transformer.h.15.self_attention.dense.bias": "pytorch_model_00017-of-00041.bin",
+    "transformer.h.15.self_attention.dense.weight": "pytorch_model_00017-of-00041.bin",
+    "transformer.h.15.self_attention.key_value.weight": "pytorch_model_00017-of-00041.bin",
+    "transformer.h.15.self_attention.query.weight": "pytorch_model_00017-of-00041.bin",
+    "transformer.h.16.input_layernorm.weight": "pytorch_model_00018-of-00041.bin",
+    "transformer.h.16.mlp.down_proj.bias": "pytorch_model_00018-of-00041.bin",
+    "transformer.h.16.mlp.down_proj.weight": "pytorch_model_00018-of-00041.bin",
+    "transformer.h.16.mlp.gate_proj.weight": "pytorch_model_00018-of-00041.bin",
+    "transformer.h.16.mlp.up_proj.weight": "pytorch_model_00018-of-00041.bin",
+    "transformer.h.16.post_attention_layernorm.weight": "pytorch_model_00018-of-00041.bin",
+    "transformer.h.16.self_attention.dense.bias": "pytorch_model_00018-of-00041.bin",
+    "transformer.h.16.self_attention.dense.weight": "pytorch_model_00018-of-00041.bin",
+    "transformer.h.16.self_attention.key_value.weight": "pytorch_model_00018-of-00041.bin",
+    "transformer.h.16.self_attention.query.weight": "pytorch_model_00018-of-00041.bin",
+    "transformer.h.17.input_layernorm.weight": "pytorch_model_00019-of-00041.bin",
+    "transformer.h.17.mlp.down_proj.bias": "pytorch_model_00019-of-00041.bin",
+    "transformer.h.17.mlp.down_proj.weight": "pytorch_model_00019-of-00041.bin",
+    "transformer.h.17.mlp.gate_proj.weight": "pytorch_model_00019-of-00041.bin",
+    "transformer.h.17.mlp.up_proj.weight": "pytorch_model_00019-of-00041.bin",
+    "transformer.h.17.post_attention_layernorm.weight": "pytorch_model_00019-of-00041.bin",
+    "transformer.h.17.self_attention.dense.bias": "pytorch_model_00019-of-00041.bin",
+    "transformer.h.17.self_attention.dense.weight": "pytorch_model_00019-of-00041.bin",
+    "transformer.h.17.self_attention.key_value.weight": "pytorch_model_00019-of-00041.bin",
+    "transformer.h.17.self_attention.query.weight": "pytorch_model_00019-of-00041.bin",
+    "transformer.h.18.input_layernorm.weight": "pytorch_model_00020-of-00041.bin",
+    "transformer.h.18.mlp.down_proj.bias": "pytorch_model_00020-of-00041.bin",
+    "transformer.h.18.mlp.down_proj.weight": "pytorch_model_00020-of-00041.bin",
+    "transformer.h.18.mlp.gate_proj.weight": "pytorch_model_00020-of-00041.bin",
+    "transformer.h.18.mlp.up_proj.weight": "pytorch_model_00020-of-00041.bin",
+    "transformer.h.18.post_attention_layernorm.weight": "pytorch_model_00020-of-00041.bin",
+    "transformer.h.18.self_attention.dense.bias": "pytorch_model_00020-of-00041.bin",
+    "transformer.h.18.self_attention.dense.weight": "pytorch_model_00020-of-00041.bin",
+    "transformer.h.18.self_attention.key_value.weight": "pytorch_model_00020-of-00041.bin",
+    "transformer.h.18.self_attention.query.weight": "pytorch_model_00020-of-00041.bin",
+    "transformer.h.19.input_layernorm.weight": "pytorch_model_00021-of-00041.bin",
+    "transformer.h.19.mlp.down_proj.bias": "pytorch_model_00021-of-00041.bin",
+    "transformer.h.19.mlp.down_proj.weight": "pytorch_model_00021-of-00041.bin",
+    "transformer.h.19.mlp.gate_proj.weight": "pytorch_model_00021-of-00041.bin",
+    "transformer.h.19.mlp.up_proj.weight": "pytorch_model_00021-of-00041.bin",
+    "transformer.h.19.post_attention_layernorm.weight": "pytorch_model_00021-of-00041.bin",
+    "transformer.h.19.self_attention.dense.bias": "pytorch_model_00021-of-00041.bin",
+    "transformer.h.19.self_attention.dense.weight": "pytorch_model_00021-of-00041.bin",
+    "transformer.h.19.self_attention.key_value.weight": "pytorch_model_00021-of-00041.bin",
+    "transformer.h.19.self_attention.query.weight": "pytorch_model_00021-of-00041.bin",
+    "transformer.h.2.input_layernorm.weight": "pytorch_model_00004-of-00041.bin",
+    "transformer.h.2.mlp.down_proj.bias": "pytorch_model_00004-of-00041.bin",
+    "transformer.h.2.mlp.down_proj.weight": "pytorch_model_00004-of-00041.bin",
+    "transformer.h.2.mlp.gate_proj.weight": "pytorch_model_00004-of-00041.bin",
+    "transformer.h.2.mlp.up_proj.weight": "pytorch_model_00004-of-00041.bin",
+    "transformer.h.2.post_attention_layernorm.weight": "pytorch_model_00004-of-00041.bin",
+    "transformer.h.2.self_attention.dense.bias": "pytorch_model_00004-of-00041.bin",
+    "transformer.h.2.self_attention.dense.weight": "pytorch_model_00004-of-00041.bin",
+    "transformer.h.2.self_attention.key_value.weight": "pytorch_model_00004-of-00041.bin",
+    "transformer.h.2.self_attention.query.weight": "pytorch_model_00004-of-00041.bin",
+    "transformer.h.20.input_layernorm.weight": "pytorch_model_00022-of-00041.bin",
+    "transformer.h.20.mlp.down_proj.bias": "pytorch_model_00022-of-00041.bin",
+    "transformer.h.20.mlp.down_proj.weight": "pytorch_model_00022-of-00041.bin",
+    "transformer.h.20.mlp.gate_proj.weight": "pytorch_model_00022-of-00041.bin",
+    "transformer.h.20.mlp.up_proj.weight": "pytorch_model_00022-of-00041.bin",
+    "transformer.h.20.post_attention_layernorm.weight": "pytorch_model_00022-of-00041.bin",
+    "transformer.h.20.self_attention.dense.bias": "pytorch_model_00022-of-00041.bin",
+    "transformer.h.20.self_attention.dense.weight": "pytorch_model_00022-of-00041.bin",
+    "transformer.h.20.self_attention.key_value.weight": "pytorch_model_00022-of-00041.bin",
+    "transformer.h.20.self_attention.query.weight": "pytorch_model_00022-of-00041.bin",
+    "transformer.h.21.input_layernorm.weight": "pytorch_model_00023-of-00041.bin",
+    "transformer.h.21.mlp.down_proj.bias": "pytorch_model_00023-of-00041.bin",
+    "transformer.h.21.mlp.down_proj.weight": "pytorch_model_00023-of-00041.bin",
+    "transformer.h.21.mlp.gate_proj.weight": "pytorch_model_00023-of-00041.bin",
+    "transformer.h.21.mlp.up_proj.weight": "pytorch_model_00023-of-00041.bin",
+    "transformer.h.21.post_attention_layernorm.weight": "pytorch_model_00023-of-00041.bin",
+    "transformer.h.21.self_attention.dense.bias": "pytorch_model_00023-of-00041.bin",
+    "transformer.h.21.self_attention.dense.weight": "pytorch_model_00023-of-00041.bin",
+    "transformer.h.21.self_attention.key_value.weight": "pytorch_model_00023-of-00041.bin",
+    "transformer.h.21.self_attention.query.weight": "pytorch_model_00023-of-00041.bin",
+    "transformer.h.22.input_layernorm.weight": "pytorch_model_00024-of-00041.bin",
+    "transformer.h.22.mlp.down_proj.bias": "pytorch_model_00024-of-00041.bin",
+    "transformer.h.22.mlp.down_proj.weight": "pytorch_model_00024-of-00041.bin",
+    "transformer.h.22.mlp.gate_proj.weight": "pytorch_model_00024-of-00041.bin",
+    "transformer.h.22.mlp.up_proj.weight": "pytorch_model_00024-of-00041.bin",
+    "transformer.h.22.post_attention_layernorm.weight": "pytorch_model_00024-of-00041.bin",
+    "transformer.h.22.self_attention.dense.bias": "pytorch_model_00024-of-00041.bin",
+    "transformer.h.22.self_attention.dense.weight": "pytorch_model_00024-of-00041.bin",
+    "transformer.h.22.self_attention.key_value.weight": "pytorch_model_00024-of-00041.bin",
+    "transformer.h.22.self_attention.query.weight": "pytorch_model_00024-of-00041.bin",
+    "transformer.h.23.input_layernorm.weight": "pytorch_model_00025-of-00041.bin",
+    "transformer.h.23.mlp.down_proj.bias": "pytorch_model_00025-of-00041.bin",
+    "transformer.h.23.mlp.down_proj.weight": "pytorch_model_00025-of-00041.bin",
+    "transformer.h.23.mlp.gate_proj.weight": "pytorch_model_00025-of-00041.bin",
+    "transformer.h.23.mlp.up_proj.weight": "pytorch_model_00025-of-00041.bin",
+    "transformer.h.23.post_attention_layernorm.weight": "pytorch_model_00025-of-00041.bin",
+    "transformer.h.23.self_attention.dense.bias": "pytorch_model_00025-of-00041.bin",
+    "transformer.h.23.self_attention.dense.weight": "pytorch_model_00025-of-00041.bin",
+    "transformer.h.23.self_attention.key_value.weight": "pytorch_model_00025-of-00041.bin",
+    "transformer.h.23.self_attention.query.weight": "pytorch_model_00025-of-00041.bin",
+    "transformer.h.24.input_layernorm.weight": "pytorch_model_00026-of-00041.bin",
+    "transformer.h.24.mlp.down_proj.bias": "pytorch_model_00026-of-00041.bin",
+    "transformer.h.24.mlp.down_proj.weight": "pytorch_model_00026-of-00041.bin",
+    "transformer.h.24.mlp.gate_proj.weight": "pytorch_model_00026-of-00041.bin",
+    "transformer.h.24.mlp.up_proj.weight": "pytorch_model_00026-of-00041.bin",
+    "transformer.h.24.post_attention_layernorm.weight": "pytorch_model_00026-of-00041.bin",
+    "transformer.h.24.self_attention.dense.bias": "pytorch_model_00026-of-00041.bin",
+    "transformer.h.24.self_attention.dense.weight": "pytorch_model_00026-of-00041.bin",
+    "transformer.h.24.self_attention.key_value.weight": "pytorch_model_00026-of-00041.bin",
+    "transformer.h.24.self_attention.query.weight": "pytorch_model_00026-of-00041.bin",
+    "transformer.h.25.input_layernorm.weight": "pytorch_model_00027-of-00041.bin",
+    "transformer.h.25.mlp.down_proj.bias": "pytorch_model_00027-of-00041.bin",
+    "transformer.h.25.mlp.down_proj.weight": "pytorch_model_00027-of-00041.bin",
+    "transformer.h.25.mlp.gate_proj.weight": "pytorch_model_00027-of-00041.bin",
+    "transformer.h.25.mlp.up_proj.weight": "pytorch_model_00027-of-00041.bin",
+    "transformer.h.25.post_attention_layernorm.weight": "pytorch_model_00027-of-00041.bin",
+    "transformer.h.25.self_attention.dense.bias": "pytorch_model_00027-of-00041.bin",
+    "transformer.h.25.self_attention.dense.weight": "pytorch_model_00027-of-00041.bin",
+    "transformer.h.25.self_attention.key_value.weight": "pytorch_model_00027-of-00041.bin",
+    "transformer.h.25.self_attention.query.weight": "pytorch_model_00027-of-00041.bin",
+    "transformer.h.26.input_layernorm.weight": "pytorch_model_00028-of-00041.bin",
+    "transformer.h.26.mlp.down_proj.bias": "pytorch_model_00028-of-00041.bin",
+    "transformer.h.26.mlp.down_proj.weight": "pytorch_model_00028-of-00041.bin",
+    "transformer.h.26.mlp.gate_proj.weight": "pytorch_model_00028-of-00041.bin",
+    "transformer.h.26.mlp.up_proj.weight": "pytorch_model_00028-of-00041.bin",
+    "transformer.h.26.post_attention_layernorm.weight": "pytorch_model_00028-of-00041.bin",
+    "transformer.h.26.self_attention.dense.bias": "pytorch_model_00028-of-00041.bin",
+    "transformer.h.26.self_attention.dense.weight": "pytorch_model_00028-of-00041.bin",
+    "transformer.h.26.self_attention.key_value.weight": "pytorch_model_00028-of-00041.bin",
+    "transformer.h.26.self_attention.query.weight": "pytorch_model_00028-of-00041.bin",
+    "transformer.h.27.input_layernorm.weight": "pytorch_model_00029-of-00041.bin",
+    "transformer.h.27.mlp.down_proj.bias": "pytorch_model_00029-of-00041.bin",
+    "transformer.h.27.mlp.down_proj.weight": "pytorch_model_00029-of-00041.bin",
+    "transformer.h.27.mlp.gate_proj.weight": "pytorch_model_00029-of-00041.bin",
+    "transformer.h.27.mlp.up_proj.weight": "pytorch_model_00029-of-00041.bin",
+    "transformer.h.27.post_attention_layernorm.weight": "pytorch_model_00029-of-00041.bin",
+    "transformer.h.27.self_attention.dense.bias": "pytorch_model_00029-of-00041.bin",
+    "transformer.h.27.self_attention.dense.weight": "pytorch_model_00029-of-00041.bin",
+    "transformer.h.27.self_attention.key_value.weight": "pytorch_model_00029-of-00041.bin",
+    "transformer.h.27.self_attention.query.weight": "pytorch_model_00029-of-00041.bin",
+    "transformer.h.28.input_layernorm.weight": "pytorch_model_00030-of-00041.bin",
+    "transformer.h.28.mlp.down_proj.bias": "pytorch_model_00030-of-00041.bin",
+    "transformer.h.28.mlp.down_proj.weight": "pytorch_model_00030-of-00041.bin",
+    "transformer.h.28.mlp.gate_proj.weight": "pytorch_model_00030-of-00041.bin",
+    "transformer.h.28.mlp.up_proj.weight": "pytorch_model_00030-of-00041.bin",
+    "transformer.h.28.post_attention_layernorm.weight": "pytorch_model_00030-of-00041.bin",
+    "transformer.h.28.self_attention.dense.bias": "pytorch_model_00030-of-00041.bin",
+    "transformer.h.28.self_attention.dense.weight": "pytorch_model_00030-of-00041.bin",
+    "transformer.h.28.self_attention.key_value.weight": "pytorch_model_00030-of-00041.bin",
+    "transformer.h.28.self_attention.query.weight": "pytorch_model_00030-of-00041.bin",
+    "transformer.h.29.input_layernorm.weight": "pytorch_model_00031-of-00041.bin",
+    "transformer.h.29.mlp.down_proj.bias": "pytorch_model_00031-of-00041.bin",
+    "transformer.h.29.mlp.down_proj.weight": "pytorch_model_00031-of-00041.bin",
+    "transformer.h.29.mlp.gate_proj.weight": "pytorch_model_00031-of-00041.bin",
+    "transformer.h.29.mlp.up_proj.weight": "pytorch_model_00031-of-00041.bin",
+    "transformer.h.29.post_attention_layernorm.weight": "pytorch_model_00031-of-00041.bin",
+    "transformer.h.29.self_attention.dense.bias": "pytorch_model_00031-of-00041.bin",
+    "transformer.h.29.self_attention.dense.weight": "pytorch_model_00031-of-00041.bin",
+    "transformer.h.29.self_attention.key_value.weight": "pytorch_model_00031-of-00041.bin",
+    "transformer.h.29.self_attention.query.weight": "pytorch_model_00031-of-00041.bin",
+    "transformer.h.3.input_layernorm.weight": "pytorch_model_00005-of-00041.bin",
+    "transformer.h.3.mlp.down_proj.bias": "pytorch_model_00005-of-00041.bin",
+    "transformer.h.3.mlp.down_proj.weight": "pytorch_model_00005-of-00041.bin",
+    "transformer.h.3.mlp.gate_proj.weight": "pytorch_model_00005-of-00041.bin",
+    "transformer.h.3.mlp.up_proj.weight": "pytorch_model_00005-of-00041.bin",
+    "transformer.h.3.post_attention_layernorm.weight": "pytorch_model_00005-of-00041.bin",
+    "transformer.h.3.self_attention.dense.bias": "pytorch_model_00005-of-00041.bin",
+    "transformer.h.3.self_attention.dense.weight": "pytorch_model_00005-of-00041.bin",
+    "transformer.h.3.self_attention.key_value.weight": "pytorch_model_00005-of-00041.bin",
+    "transformer.h.3.self_attention.query.weight": "pytorch_model_00005-of-00041.bin",
+    "transformer.h.30.input_layernorm.weight": "pytorch_model_00032-of-00041.bin",
+    "transformer.h.30.mlp.down_proj.bias": "pytorch_model_00032-of-00041.bin",
+    "transformer.h.30.mlp.down_proj.weight": "pytorch_model_00032-of-00041.bin",
+    "transformer.h.30.mlp.gate_proj.weight": "pytorch_model_00032-of-00041.bin",
+    "transformer.h.30.mlp.up_proj.weight": "pytorch_model_00032-of-00041.bin",
+    "transformer.h.30.post_attention_layernorm.weight": "pytorch_model_00032-of-00041.bin",
+    "transformer.h.30.self_attention.dense.bias": "pytorch_model_00032-of-00041.bin",
+    "transformer.h.30.self_attention.dense.weight": "pytorch_model_00032-of-00041.bin",
+    "transformer.h.30.self_attention.key_value.weight": "pytorch_model_00032-of-00041.bin",
+    "transformer.h.30.self_attention.query.weight": "pytorch_model_00032-of-00041.bin",
+    "transformer.h.31.input_layernorm.weight": "pytorch_model_00033-of-00041.bin",
+    "transformer.h.31.mlp.down_proj.bias": "pytorch_model_00033-of-00041.bin",
+    "transformer.h.31.mlp.down_proj.weight": "pytorch_model_00033-of-00041.bin",
+    "transformer.h.31.mlp.gate_proj.weight": "pytorch_model_00033-of-00041.bin",
+    "transformer.h.31.mlp.up_proj.weight": "pytorch_model_00033-of-00041.bin",
+    "transformer.h.31.post_attention_layernorm.weight": "pytorch_model_00033-of-00041.bin",
+    "transformer.h.31.self_attention.dense.bias": "pytorch_model_00033-of-00041.bin",
+    "transformer.h.31.self_attention.dense.weight": "pytorch_model_00033-of-00041.bin",
+    "transformer.h.31.self_attention.key_value.weight": "pytorch_model_00033-of-00041.bin",
+    "transformer.h.31.self_attention.query.weight": "pytorch_model_00033-of-00041.bin",
+    "transformer.h.32.input_layernorm.weight": "pytorch_model_00034-of-00041.bin",
+    "transformer.h.32.mlp.down_proj.bias": "pytorch_model_00034-of-00041.bin",
+    "transformer.h.32.mlp.down_proj.weight": "pytorch_model_00034-of-00041.bin",
+    "transformer.h.32.mlp.gate_proj.weight": "pytorch_model_00034-of-00041.bin",
+    "transformer.h.32.mlp.up_proj.weight": "pytorch_model_00034-of-00041.bin",
+    "transformer.h.32.post_attention_layernorm.weight": "pytorch_model_00034-of-00041.bin",
+    "transformer.h.32.self_attention.dense.bias": "pytorch_model_00034-of-00041.bin",
+    "transformer.h.32.self_attention.dense.weight": "pytorch_model_00034-of-00041.bin",
+    "transformer.h.32.self_attention.key_value.weight": "pytorch_model_00034-of-00041.bin",
+    "transformer.h.32.self_attention.query.weight": "pytorch_model_00034-of-00041.bin",
+    "transformer.h.33.input_layernorm.weight": "pytorch_model_00035-of-00041.bin",
+    "transformer.h.33.mlp.down_proj.bias": "pytorch_model_00035-of-00041.bin",
+    "transformer.h.33.mlp.down_proj.weight": "pytorch_model_00035-of-00041.bin",
+    "transformer.h.33.mlp.gate_proj.weight": "pytorch_model_00035-of-00041.bin",
+    "transformer.h.33.mlp.up_proj.weight": "pytorch_model_00035-of-00041.bin",
+    "transformer.h.33.post_attention_layernorm.weight": "pytorch_model_00035-of-00041.bin",
+    "transformer.h.33.self_attention.dense.bias": "pytorch_model_00035-of-00041.bin",
+    "transformer.h.33.self_attention.dense.weight": "pytorch_model_00035-of-00041.bin",
+    "transformer.h.33.self_attention.key_value.weight": "pytorch_model_00035-of-00041.bin",
+    "transformer.h.33.self_attention.query.weight": "pytorch_model_00035-of-00041.bin",
+    "transformer.h.34.input_layernorm.weight": "pytorch_model_00036-of-00041.bin",
+    "transformer.h.34.mlp.down_proj.bias": "pytorch_model_00036-of-00041.bin",
+    "transformer.h.34.mlp.down_proj.weight": "pytorch_model_00036-of-00041.bin",
+    "transformer.h.34.mlp.gate_proj.weight": "pytorch_model_00036-of-00041.bin",
+    "transformer.h.34.mlp.up_proj.weight": "pytorch_model_00036-of-00041.bin",
+    "transformer.h.34.post_attention_layernorm.weight": "pytorch_model_00036-of-00041.bin",
+    "transformer.h.34.self_attention.dense.bias": "pytorch_model_00036-of-00041.bin",
+    "transformer.h.34.self_attention.dense.weight": "pytorch_model_00036-of-00041.bin",
+    "transformer.h.34.self_attention.key_value.weight": "pytorch_model_00036-of-00041.bin",
+    "transformer.h.34.self_attention.query.weight": "pytorch_model_00036-of-00041.bin",
+    "transformer.h.35.input_layernorm.weight": "pytorch_model_00037-of-00041.bin",
+    "transformer.h.35.mlp.down_proj.bias": "pytorch_model_00037-of-00041.bin",
+    "transformer.h.35.mlp.down_proj.weight": "pytorch_model_00037-of-00041.bin",
+    "transformer.h.35.mlp.gate_proj.weight": "pytorch_model_00037-of-00041.bin",
+    "transformer.h.35.mlp.up_proj.weight": "pytorch_model_00037-of-00041.bin",
+    "transformer.h.35.post_attention_layernorm.weight": "pytorch_model_00037-of-00041.bin",
+    "transformer.h.35.self_attention.dense.bias": "pytorch_model_00037-of-00041.bin",
+    "transformer.h.35.self_attention.dense.weight": "pytorch_model_00037-of-00041.bin",
+    "transformer.h.35.self_attention.key_value.weight": "pytorch_model_00037-of-00041.bin",
+    "transformer.h.35.self_attention.query.weight": "pytorch_model_00037-of-00041.bin",
+    "transformer.h.36.input_layernorm.weight": "pytorch_model_00038-of-00041.bin",
+    "transformer.h.36.mlp.down_proj.bias": "pytorch_model_00038-of-00041.bin",
+    "transformer.h.36.mlp.down_proj.weight": "pytorch_model_00038-of-00041.bin",
+    "transformer.h.36.mlp.gate_proj.weight": "pytorch_model_00038-of-00041.bin",
+    "transformer.h.36.mlp.up_proj.weight": "pytorch_model_00038-of-00041.bin",
+    "transformer.h.36.post_attention_layernorm.weight": "pytorch_model_00038-of-00041.bin",
+    "transformer.h.36.self_attention.dense.bias": "pytorch_model_00038-of-00041.bin",
+    "transformer.h.36.self_attention.dense.weight": "pytorch_model_00038-of-00041.bin",
+    "transformer.h.36.self_attention.key_value.weight": "pytorch_model_00038-of-00041.bin",
+    "transformer.h.36.self_attention.query.weight": "pytorch_model_00038-of-00041.bin",
+    "transformer.h.37.input_layernorm.weight": "pytorch_model_00039-of-00041.bin",
+    "transformer.h.37.mlp.down_proj.bias": "pytorch_model_00039-of-00041.bin",
+    "transformer.h.37.mlp.down_proj.weight": "pytorch_model_00039-of-00041.bin",
+    "transformer.h.37.mlp.gate_proj.weight": "pytorch_model_00039-of-00041.bin",
+    "transformer.h.37.mlp.up_proj.weight": "pytorch_model_00039-of-00041.bin",
+    "transformer.h.37.post_attention_layernorm.weight": "pytorch_model_00039-of-00041.bin",
+    "transformer.h.37.self_attention.dense.bias": "pytorch_model_00039-of-00041.bin",
+    "transformer.h.37.self_attention.dense.weight": "pytorch_model_00039-of-00041.bin",
+    "transformer.h.37.self_attention.key_value.weight": "pytorch_model_00039-of-00041.bin",
+    "transformer.h.37.self_attention.query.weight": "pytorch_model_00039-of-00041.bin",
+    "transformer.h.4.input_layernorm.weight": "pytorch_model_00006-of-00041.bin",
+    "transformer.h.4.mlp.down_proj.bias": "pytorch_model_00006-of-00041.bin",
+    "transformer.h.4.mlp.down_proj.weight": "pytorch_model_00006-of-00041.bin",
+    "transformer.h.4.mlp.gate_proj.weight": "pytorch_model_00006-of-00041.bin",
+    "transformer.h.4.mlp.up_proj.weight": "pytorch_model_00006-of-00041.bin",
+    "transformer.h.4.post_attention_layernorm.weight": "pytorch_model_00006-of-00041.bin",
+    "transformer.h.4.self_attention.dense.bias": "pytorch_model_00006-of-00041.bin",
+    "transformer.h.4.self_attention.dense.weight": "pytorch_model_00006-of-00041.bin",
+    "transformer.h.4.self_attention.key_value.weight": "pytorch_model_00006-of-00041.bin",
+    "transformer.h.4.self_attention.query.weight": "pytorch_model_00006-of-00041.bin",
+    "transformer.h.5.input_layernorm.weight": "pytorch_model_00007-of-00041.bin",
+    "transformer.h.5.mlp.down_proj.bias": "pytorch_model_00007-of-00041.bin",
+    "transformer.h.5.mlp.down_proj.weight": "pytorch_model_00007-of-00041.bin",
+    "transformer.h.5.mlp.gate_proj.weight": "pytorch_model_00007-of-00041.bin",
+    "transformer.h.5.mlp.up_proj.weight": "pytorch_model_00007-of-00041.bin",
+    "transformer.h.5.post_attention_layernorm.weight": "pytorch_model_00007-of-00041.bin",
+    "transformer.h.5.self_attention.dense.bias": "pytorch_model_00007-of-00041.bin",
+    "transformer.h.5.self_attention.dense.weight": "pytorch_model_00007-of-00041.bin",
+    "transformer.h.5.self_attention.key_value.weight": "pytorch_model_00007-of-00041.bin",
+    "transformer.h.5.self_attention.query.weight": "pytorch_model_00007-of-00041.bin",
+    "transformer.h.6.input_layernorm.weight": "pytorch_model_00008-of-00041.bin",
+    "transformer.h.6.mlp.down_proj.bias": "pytorch_model_00008-of-00041.bin",
+    "transformer.h.6.mlp.down_proj.weight": "pytorch_model_00008-of-00041.bin",
+    "transformer.h.6.mlp.gate_proj.weight": "pytorch_model_00008-of-00041.bin",
+    "transformer.h.6.mlp.up_proj.weight": "pytorch_model_00008-of-00041.bin",
+    "transformer.h.6.post_attention_layernorm.weight": "pytorch_model_00008-of-00041.bin",
+    "transformer.h.6.self_attention.dense.bias": "pytorch_model_00008-of-00041.bin",
+    "transformer.h.6.self_attention.dense.weight": "pytorch_model_00008-of-00041.bin",
+    "transformer.h.6.self_attention.key_value.weight": "pytorch_model_00008-of-00041.bin",
+    "transformer.h.6.self_attention.query.weight": "pytorch_model_00008-of-00041.bin",
+    "transformer.h.7.input_layernorm.weight": "pytorch_model_00009-of-00041.bin",
+    "transformer.h.7.mlp.down_proj.bias": "pytorch_model_00009-of-00041.bin",
+    "transformer.h.7.mlp.down_proj.weight": "pytorch_model_00009-of-00041.bin",
+    "transformer.h.7.mlp.gate_proj.weight": "pytorch_model_00009-of-00041.bin",
+    "transformer.h.7.mlp.up_proj.weight": "pytorch_model_00009-of-00041.bin",
+    "transformer.h.7.post_attention_layernorm.weight": "pytorch_model_00009-of-00041.bin",
+    "transformer.h.7.self_attention.dense.bias": "pytorch_model_00009-of-00041.bin",
+    "transformer.h.7.self_attention.dense.weight": "pytorch_model_00009-of-00041.bin",
+    "transformer.h.7.self_attention.key_value.weight": "pytorch_model_00009-of-00041.bin",
+    "transformer.h.7.self_attention.query.weight": "pytorch_model_00009-of-00041.bin",
+    "transformer.h.8.input_layernorm.weight": "pytorch_model_00010-of-00041.bin",
+    "transformer.h.8.mlp.down_proj.bias": "pytorch_model_00010-of-00041.bin",
+    "transformer.h.8.mlp.down_proj.weight": "pytorch_model_00010-of-00041.bin",
+    "transformer.h.8.mlp.gate_proj.weight": "pytorch_model_00010-of-00041.bin",
+    "transformer.h.8.mlp.up_proj.weight": "pytorch_model_00010-of-00041.bin",
+    "transformer.h.8.post_attention_layernorm.weight": "pytorch_model_00010-of-00041.bin",
+    "transformer.h.8.self_attention.dense.bias": "pytorch_model_00010-of-00041.bin",
+    "transformer.h.8.self_attention.dense.weight": "pytorch_model_00010-of-00041.bin",
+    "transformer.h.8.self_attention.key_value.weight": "pytorch_model_00010-of-00041.bin",
+    "transformer.h.8.self_attention.query.weight": "pytorch_model_00010-of-00041.bin",
+    "transformer.h.9.input_layernorm.weight": "pytorch_model_00011-of-00041.bin",
+    "transformer.h.9.mlp.down_proj.bias": "pytorch_model_00011-of-00041.bin",
+    "transformer.h.9.mlp.down_proj.weight": "pytorch_model_00011-of-00041.bin",
+    "transformer.h.9.mlp.gate_proj.weight": "pytorch_model_00011-of-00041.bin",
+    "transformer.h.9.mlp.up_proj.weight": "pytorch_model_00011-of-00041.bin",
+    "transformer.h.9.post_attention_layernorm.weight": "pytorch_model_00011-of-00041.bin",
+    "transformer.h.9.self_attention.dense.bias": "pytorch_model_00011-of-00041.bin",
+    "transformer.h.9.self_attention.dense.weight": "pytorch_model_00011-of-00041.bin",
+    "transformer.h.9.self_attention.key_value.weight": "pytorch_model_00011-of-00041.bin",
+    "transformer.h.9.self_attention.query.weight": "pytorch_model_00011-of-00041.bin",
+    "transformer.ln_f.weight": "pytorch_model_00040-of-00041.bin",
+    "transformer.word_embeddings.weight": "pytorch_model_00001-of-00041.bin"
+  }
+}

pytorch_model_00001-of-00041.bin

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

pytorch_model_00002-of-00041.bin

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

pytorch_model_00003-of-00041.bin

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

pytorch_model_00004-of-00041.bin

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

pytorch_model_00005-of-00041.bin

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

pytorch_model_00006-of-00041.bin

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

pytorch_model_00007-of-00041.bin

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

pytorch_model_00008-of-00041.bin

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

pytorch_model_00009-of-00041.bin

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

pytorch_model_00010-of-00041.bin

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

pytorch_model_00011-of-00041.bin

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

pytorch_model_00012-of-00041.bin

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

pytorch_model_00013-of-00041.bin

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

pytorch_model_00014-of-00041.bin

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

pytorch_model_00015-of-00041.bin

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

pytorch_model_00016-of-00041.bin

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

pytorch_model_00017-of-00041.bin

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

pytorch_model_00018-of-00041.bin

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

pytorch_model_00019-of-00041.bin

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