Upload folder using huggingface_hub

config.json

@@ -0,0 +1,29 @@
+{
+  "_name_or_path": "/workspace/WizardLM-Uncensored-falcon-40b",
+  "alibi": false,
+  "apply_residual_connection_post_layernorm": false,
+  "architectures": [
+    "RWForCausalLM"
+  ],
+  "attention_dropout": 0.0,
+  "auto_map": {
+    "AutoConfig": "configuration_RW.RWConfig",
+    "AutoModelForCausalLM": "modelling_RW.RWForCausalLM"
+  },
+  "bias": false,
+  "bos_token_id": 1,
+  "eos_token_id": 2,
+  "hidden_dropout": 0.0,
+  "hidden_size": 8192,
+  "initializer_range": 0.02,
+  "layer_norm_epsilon": 1e-05,
+  "model_type": "RefinedWeb",
+  "n_head": 128,
+  "n_head_kv": 8,
+  "n_layer": 60,
+  "parallel_attn": true,
+  "torch_dtype": "float32",
+  "transformers_version": "4.30.0.dev0",
+  "use_cache": true,
+  "vocab_size": 65025
+}

configuration_RW.py

@@ -0,0 +1,75 @@
+# 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.
+""" Bloom configuration"""
+from transformers.configuration_utils import PretrainedConfig
+from transformers.utils import logging
+
+
+logger = logging.get_logger(__name__)
+
+
+class RWConfig(PretrainedConfig):
+    model_type = "RefinedWeb"
+    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=250880,
+        hidden_size=64,
+        n_layer=2,
+        n_head=8,
+        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,
+        n_head_kv=None,
+        alibi=False,
+        **kwargs,
+    ):
+        self.vocab_size = vocab_size
+        # Backward compatibility with n_embed kwarg
+        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.n_head_kv = n_head if n_head_kv is None else n_head_kv
+        self.alibi = alibi
+
+        super().__init__(bos_token_id=bos_token_id, eos_token_id=eos_token_id, **kwargs)
+
+    @property
+    def head_dim(self):
+        return self.hidden_size // self.n_head
+
+    @property
+    def rotary(self):
+        return not self.alibi

generation_config.json

@@ -0,0 +1,6 @@
+{
+  "_from_model_config": true,
+  "bos_token_id": 1,
+  "eos_token_id": 2,
+  "transformers_version": "4.30.0.dev0"
+}

latest

@@ -0,0 +1 @@
+global_step214

modelling_RW.py

@@ -0,0 +1,1106 @@
+# port of models described in RW
+# We use the bloom model as a starting point for these model.
+# Please refer to the bloom models for usage instructions.
+
+import math
+import warnings
+from typing import Optional, Tuple, Union
+
+import torch
+import torch.utils.checkpoint
+from torch import nn
+from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, LayerNorm, MSELoss
+from torch.nn import functional as F
+
+from transformers.modeling_outputs import (
+    BaseModelOutputWithPastAndCrossAttentions,
+    CausalLMOutputWithCrossAttentions,
+    QuestionAnsweringModelOutput,
+    SequenceClassifierOutputWithPast,
+    TokenClassifierOutput,
+)
+from transformers.modeling_utils import PreTrainedModel
+from transformers.utils import logging
+from .configuration_RW import RWConfig
+
+logger = logging.get_logger(__name__)
+
+# 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.
+# In order not to degrade the quality of our HF-port, we keep these characteristics in the final model.
+class Linear(nn.Linear):
+    def forward(self, input: torch.Tensor) -> torch.Tensor:
+        ret = input @ self.weight.T
+        if self.bias is None:
+            return ret
+        else:
+            return ret + self.bias
+
+
+from einops import rearrange
+
+# rotary pos emb helpers (torch.jit.script does not seem to support staticmethod...)
+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 torch < 1.8.0
+
+
+class RotaryEmbedding(torch.nn.Module):
+    """Implementation of RotaryEmbedding from GPT-NeoX.
+    This implementation is design to operate on queries and keys that are compatible with
+    [batch_size, n_heads_per_partition, seq_len, head_dim] (e.g. MinGPTAttention format).
+    """
+
+    def __init__(
+        self,
+        head_dim: int,
+        base=10000,
+    ):
+        super().__init__()
+        inv_freq = 1.0 / (base ** (torch.arange(0, head_dim, 2).float() / head_dim))
+        self.register_buffer("inv_freq", inv_freq, persistent=False)
+        self.head_dim = head_dim
+        self.seq_len_cached = None
+        self.batch_size_cached = None
+        self.cos_cached: torch.Tensor | None = None
+        self.sin_cached: torch.Tensor | None = None
+
+    def cos_sin(
+        self,
+        seq_len: int,
+        device="cuda",
+        dtype=torch.bfloat16,
+    ) -> torch.Tensor:
+        if seq_len != self.seq_len_cached:
+            self.seq_len_cached = seq_len
+            t = torch.arange(seq_len, device=device).type_as(self.inv_freq)
+            freqs = torch.einsum("i,j->ij", t, self.inv_freq)
+            emb = torch.cat((freqs, freqs), dim=-1).to(device)
+
+            if dtype in [torch.float16, torch.bfloat16]:
+                emb = emb.float()
+
+            self.cos_cached = emb.cos()[None, :, :]
+            self.sin_cached = emb.sin()[None, :, :]
+
+            self.cos_cached = self.cos_cached.type(dtype)
+            self.sin_cached = self.sin_cached.type(dtype)
+
+        return self.cos_cached, self.sin_cached
+
+    def forward(self, q, k):
+        batch, seq_len, head_dim = q.shape
+        cos, sin = self.cos_sin(seq_len, q.device, q.dtype)
+        return (q * cos) + (rotate_half(q) * sin), (k * cos) + (rotate_half(k) * sin)
+
+
+def _make_causal_mask(
+    input_ids_shape: torch.Size, device: torch.device, past_key_values_length: int
+) -> torch.BoolTensor:
+    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:
+    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 build_alibi_tensor(attention_mask: torch.Tensor, num_heads: int, dtype: torch.dtype) -> torch.Tensor:
+    batch_size, seq_length = attention_mask.shape
+    closest_power_of_2 = 2 ** math.floor(math.log2(num_heads))
+    base = torch.tensor(
+        2 ** (-(2 ** -(math.log2(closest_power_of_2) - 3))), device=attention_mask.device, dtype=torch.float32
+    )
+    powers = torch.arange(1, 1 + closest_power_of_2, device=attention_mask.device, dtype=torch.int32)
+    slopes = torch.pow(base, powers)
+
+    if closest_power_of_2 != num_heads:
+        extra_base = torch.tensor(
+            2 ** (-(2 ** -(math.log2(2 * closest_power_of_2) - 3))), device=attention_mask.device, dtype=torch.float32
+        )
+        num_remaining_heads = min(closest_power_of_2, num_heads - closest_power_of_2)
+        extra_powers = torch.arange(1, 1 + 2 * num_remaining_heads, 2, device=attention_mask.device, dtype=torch.int32)
+        slopes = torch.cat([slopes, torch.pow(extra_base, extra_powers)], dim=0)
+
+    # Note: alibi will added to the attention bias that will be applied to the query, key product of attention
+    # => therefore alibi will have to be of shape (batch_size, num_heads, query_length, key_length)
+    # => here we set (batch_size=1, num_heads=num_heads, query_length=1, key_length=max_length)
+    # => the query_length dimension will then be broadcasted correctly
+    # This is more or less identical to T5's relative position bias:
+    # https://github.com/huggingface/transformers/blob/f681437203baa7671de3174b0fa583c349d9d5e1/src/transformers/models/t5/modeling_t5.py#L527
+    arange_tensor = ((attention_mask.cumsum(dim=-1) - 1) * attention_mask)[:, None, :]
+    alibi = slopes[..., None].bfloat16() * arange_tensor
+    return alibi.reshape(batch_size * num_heads, 1, seq_length).to(dtype)
+
+
+def dropout_add(x: torch.Tensor, residual: torch.Tensor, prob: float, training: bool) -> torch.Tensor:
+    out = F.dropout(x, p=prob, training=training)
+    out = residual + out
+    return out
+
+
+class Attention(nn.Module):
+    def __init__(self, config: RWConfig):
+        super().__init__()
+
+        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
+
+        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})."
+            )
+
+        self.maybe_rotary = RotaryEmbedding(config.head_dim) if config.rotary else lambda q, k: (q, k)
+
+        # Layer-wise attention scaling
+        self.inv_norm_factor = 1.0 / math.sqrt(self.head_dim)
+        self.beta = self.inv_norm_factor
+
+        self.query_key_value = Linear(
+            self.hidden_size,
+            (config.n_head_kv * 2 + config.n_head) * self.head_dim,
+            bias=config.bias,
+        )
+        self.dense = Linear(self.hidden_size, self.hidden_size, bias=config.bias)
+        self.attention_dropout = nn.Dropout(config.attention_dropout)
+        self.num_kv = config.n_head_kv
+
+    def _split_heads(self, fused_qkv: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        """
+        Split the last dimension into (num_heads, head_dim), results share same memory
+        storage as `fused_qkv`
+
+        Args:
+            fused_qkv (`torch.tensor`, *required*): [batch_size, seq_length, num_heads * 3 * head_dim]
+
+        Returns:
+            query: [batch_size, seq_length, num_heads, head_dim]
+            key: [batch_size, seq_length, num_heads, head_dim]
+            value: [batch_size, seq_length, num_heads, head_dim]
+        """
+        batch, seq_len, _ = fused_qkv.shape
+        qkv = fused_qkv.view(batch, seq_len, -1, self.num_heads // self.num_kv + 2, 64)
+        q = qkv[:, :, :, :-2]
+        k = qkv[:, :, :, [-2]]
+        v = qkv[:, :, :, [-1]]
+        k = torch.broadcast_to(k, q.shape)
+        v = torch.broadcast_to(v, q.shape)
+
+        q, k, v = [
+            rearrange(
+                x,
+                "batch seq_len group num_heads head_dim ->\
+                batch seq_len (group num_heads) head_dim",
+                head_dim=self.head_dim,
+            )
+            for x in [q, k, v]
+        ]
+        return q, k, v
+
+    def _merge_heads(self, x: torch.Tensor) -> torch.Tensor:
+        """
+        Merge heads together over the last dimenstion
+
+        Args:
+            x: (`torch.tensor`, *required*): [batch_size * num_heads, seq_length, head_dim]
+
+        Returns:
+            torch.tensor: [batch_size, seq_length, num_heads * head_dim]
+        """
+        # What we want to achieve is:
+        # batch_size * num_heads, seq_length, head_dim -> batch_size, seq_length, num_heads * head_dim
+        batch_size_and_num_heads, seq_length, _ = x.shape
+        batch_size = batch_size_and_num_heads // self.num_heads
+
+        # First view to decompose the batch size
+        # batch_size * num_heads, seq_length, head_dim -> batch_size, num_heads, seq_length, head_dim
+        x = x.view(batch_size, self.num_heads, seq_length, self.head_dim)
+
+        # batch_size, num_heads, seq_length, head_dim -> batch_size, seq_length, num_heads, head_dim
+        x = x.permute(0, 2, 1, 3)
+
+        # batch_size, seq_length, num_heads, head_dim -> batch_size, seq_length, num_heads * head_dim
+        return x.reshape(batch_size, seq_length, self.num_heads * self.head_dim)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        alibi: torch.Tensor,
+        attention_mask: torch.Tensor,
+        layer_past: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,
+        head_mask: Optional[torch.Tensor] = None,
+        use_cache: bool = False,
+        output_attentions: bool = False,
+    ):
+        fused_qkv = self.query_key_value(hidden_states)  # [batch_size, seq_length, 3 x hidden_size]
+
+        # 3 x [batch_size, seq_length, num_heads, head_dim]
+        (query_layer, key_layer, value_layer) = self._split_heads(fused_qkv)
+
+        batch_size, q_length, _, _ = query_layer.shape
+
+        query_layer = query_layer.transpose(1, 2).reshape(batch_size * self.num_heads, q_length, self.head_dim)
+        key_layer = key_layer.transpose(1, 2).reshape(
+            batch_size * self.num_heads,
+            q_length,
+            self.head_dim,
+        )
+        value_layer = value_layer.transpose(1, 2).reshape(batch_size * self.num_heads, q_length, self.head_dim)
+
+        query_layer, key_layer = self.maybe_rotary(query_layer, key_layer)
+
+        if layer_past is not None:
+            past_key, past_value = layer_past
+            # concatenate along seq_length dimension:
+            #  - key: [batch_size * self.num_heads, head_dim, kv_length]
+            #  - value: [batch_size * self.num_heads, kv_length, head_dim]
+            key_layer = torch.cat((past_key, key_layer), dim=1)
+            value_layer = torch.cat((past_value, value_layer), dim=1)
+
+        _, kv_length, _ = key_layer.shape
+
+        if use_cache is True:
+            present = (key_layer, value_layer)
+        else:
+            present = None
+
+        if alibi is None:
+            query_layer_ = query_layer.reshape(batch_size, self.num_heads, -1, self.head_dim)
+            key_layer_ = key_layer.reshape(batch_size, self.num_heads, -1, self.head_dim)
+            value_layer_ = value_layer.reshape(batch_size, self.num_heads, -1, self.head_dim)
+
+            attn_output = F.scaled_dot_product_attention(
+                query_layer_, key_layer_, value_layer_, None, 0.0, is_causal=True
+            )
+
+            x = attn_output.view(batch_size, self.num_heads, q_length, self.head_dim)
+            x = x.permute(0, 2, 1, 3)
+            attn_output = x.reshape(batch_size, q_length, self.num_heads * self.head_dim)
+
+            output_tensor = self.dense(attn_output)
+
+            outputs = (output_tensor, present)
+            assert not output_attentions  # not supported.
+            return outputs
+        else:
+            attention_mask_float = (attention_mask * 1.0).masked_fill(attention_mask, -1e9).to(torch.bfloat16)
+            matmul_result = query_layer @ key_layer.transpose(-1, -2)
+
+            # change view to [batch_size, num_heads, q_length, kv_length]
+            attention_scores = matmul_result.view(batch_size, self.num_heads, q_length, kv_length)
+
+            # cast attention scores to fp32, compute scaled softmax and cast back to initial dtype - [batch_size, num_heads, q_length, kv_length]
+            input_dtype = attention_scores.dtype
+            # `float16` has a minimum value of -65504.0, whereas `bfloat16` and `float32` have a minimum value of `-3.4e+38`
+            if input_dtype == torch.float16 or input_dtype == torch.bfloat16:
+                attention_scores = attention_scores.to(torch.float32)
+            # attn_weights = torch.masked_fill(attention_scores, attention_mask, torch.finfo(attention_scores.dtype).min)
+            attention_probs = F.softmax(
+                (attention_scores + alibi.view(batch_size, self.num_heads, 1, -1)) * self.inv_norm_factor
+                + attention_mask_float,
+                dim=-1,
+                dtype=hidden_states.dtype,
+            )
+            # [batch_size, num_heads, q_length, kv_length]
+            attention_probs = self.attention_dropout(attention_probs)
+
+            if head_mask is not None:
+                attention_probs = attention_probs * head_mask
+
+            # change view [batch_size x num_heads, q_length, kv_length]
+            attention_probs_reshaped = attention_probs.view(batch_size * self.num_heads, q_length, kv_length)
+
+            # matmul: [batch_size * num_heads, q_length, head_dim]
+            context_layer = attention_probs_reshaped @ value_layer
+
+            # change view [batch_size, num_heads, q_length, head_dim]
+            context_layer = self._merge_heads(context_layer)
+
+            output_tensor = self.dense(context_layer)
+
+            outputs = (output_tensor, present)
+            if output_attentions:
+                outputs += (attention_probs,)
+
+            return outputs
+
+
+class MLP(nn.Module):
+    def __init__(self, config: RWConfig):
+        super().__init__()
+        hidden_size = config.hidden_size
+
+        self.dense_h_to_4h = Linear(hidden_size, 4 * hidden_size, bias=config.bias)
+        self.act = nn.GELU()
+        self.dense_4h_to_h = Linear(4 * hidden_size, hidden_size, bias=config.bias)
+        self.hidden_dropout = config.hidden_dropout
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = self.act(self.dense_h_to_4h(x))
+        x = self.dense_4h_to_h(x)
+        return x
+
+
+class DecoderLayer(nn.Module):
+    def __init__(self, config: RWConfig):
+        super().__init__()
+        hidden_size = config.hidden_size
+
+        self.ln_attn = LayerNorm(hidden_size, eps=config.layer_norm_epsilon)
+        self.ln_mlp = LayerNorm(hidden_size, eps=config.layer_norm_epsilon)
+
+        self.num_heads = config.n_head
+        self.self_attention = Attention(config)
+
+        self.mlp = MLP(config)
+
+        self.apply_residual_connection_post_layernorm = config.apply_residual_connection_post_layernorm
+        self.hidden_dropout = config.hidden_dropout
+
+        self.config = config
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        alibi: torch.Tensor,
+        attention_mask: torch.Tensor,
+        layer_past: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,
+        head_mask: Optional[torch.Tensor] = None,
+        use_cache: bool = False,
+        output_attentions: bool = False,
+    ):
+
+        ln_attn = self.ln_attn(hidden_states)
+        ln_mlp = self.ln_mlp(hidden_states)
+
+        residual = hidden_states
+
+        # Self attention.
+        attn_outputs = self.self_attention(
+            ln_attn,
+            layer_past=layer_past,
+            attention_mask=attention_mask,
+            alibi=alibi,
+            head_mask=head_mask,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+        )
+
+        attention_output = attn_outputs[0]
+
+        outputs = attn_outputs[1:]
+
+        # MLP.
+        mlp_output = self.mlp(ln_mlp)
+
+        output = dropout_add(
+            mlp_output + attention_output, residual, self.config.hidden_dropout, training=self.training
+        )
+
+        if use_cache:
+            outputs = (output,) + outputs
+        else:
+            outputs = (output,) + outputs[1:]
+
+        return outputs  # hidden_states, present, attentions
+
+
+class RWPreTrainedModel(PreTrainedModel):
+    _keys_to_ignore_on_load_missing = [r"h.*.self_attention.scale_mask_softmax.causal_mask", r"lm_head.weight"]
+    """
+    An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
+    models.
+    """
+
+    config_class = RWConfig
+    base_model_prefix = "transformer"
+    supports_gradient_checkpointing = True
+    _no_split_modules = ["DecoderLayer"]
+
+    def __init__(self, *inputs, **kwargs):
+        super().__init__(*inputs, **kwargs)
+
+    def _init_weights(self, module: nn.Module):
+        """Initialize the weights."""
+        if isinstance(module, nn.Linear) or isinstance(module, Linear):
+            # Slightly different from the TF version which uses truncated_normal for initialization
+            # cf https://github.com/pytorch/pytorch/pull/5617
+            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, RWModel):
+            module.gradient_checkpointing = value
+
+    @staticmethod
+    def _convert_to_standard_cache(
+        past_key_value: Tuple[Tuple[torch.Tensor, torch.Tensor]], batch_size: int
+    ) -> Tuple[Tuple[torch.Tensor, torch.Tensor]]:
+        """
+        Standardizes the format of the cache so as to match most implementations, i.e. to tuple(tuple([batch_size,
+        num_heads, ...]))
+        """
+        batch_size_times_num_heads, head_dim, seq_length = past_key_value[0][0].shape
+        num_heads = batch_size_times_num_heads // batch_size
+        # key: [batch_size * num_heads, head_dim, seq_length] -> [batch_size, num_heads, head_dim, seq_length]
+        # value: [batch_size * num_heads, seq_length, head_dim] -> [batch_size, num_heads, seq_length, head_dim]
+        return tuple(
+            (
+                layer_past[0].view(batch_size, num_heads, head_dim, seq_length),
+                layer_past[1].view(batch_size, num_heads, seq_length, head_dim),
+            )
+            for layer_past in past_key_value
+        )
+
+    @staticmethod
+    def _convert_to_rw_cache(
+        past_key_value: Tuple[Tuple[torch.Tensor, torch.Tensor]]
+    ) -> Tuple[Tuple[torch.Tensor, torch.Tensor]]:
+        batch_size, num_heads, head_dim, seq_length = past_key_value[0][0].shape
+        batch_size_times_num_heads = batch_size * num_heads
+        # key:  [batch_size, num_heads, head_dim, seq_length] -> [batch_size * num_heads, head_dim, seq_length]
+        # value: [batch_size, num_heads, seq_length, head_dim] -> [batch_size * num_heads, seq_length, head_dim]
+        return tuple(
+            (
+                layer_past[0].view(batch_size_times_num_heads, head_dim, seq_length),
+                layer_past[1].view(batch_size_times_num_heads, seq_length, head_dim),
+            )
+            for layer_past in past_key_value
+        )
+
+
+class RWModel(RWPreTrainedModel):
+    def __init__(self, config: RWConfig):
+        super().__init__(config)
+
+        self.embed_dim = config.hidden_size
+        self.num_heads = config.n_head
+        self.alibi = config.alibi
+
+        # Embedding + LN Embedding
+        self.word_embeddings = nn.Embedding(config.vocab_size, self.embed_dim)
+
+        # Transformer blocks
+        self.h = nn.ModuleList([DecoderLayer(config) for _ in range(config.num_hidden_layers)])
+
+        # Final Layer Norm
+        self.ln_f = LayerNorm(self.embed_dim, eps=config.layer_norm_epsilon)
+
+        self.gradient_checkpointing = False
+
+        # Initialize weights and apply final processing
+        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:
+        # create causal mask
+        # [batch_size, seq_length] -> [batch_size, 1, tgt_length, src_length]
+        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
+            )
+
+        # [batch_size, seq_length] -> [batch_size, 1, tgt_length, src_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,
+        head_mask: Optional[torch.LongTensor] = 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]:
+        if deprecated_arguments.pop("position_ids", False) is not False:
+            # `position_ids` could have been `torch.Tensor` or `None` so defaulting pop to `False` allows to detect if users were passing explicitly `None`
+            warnings.warn(
+                "`position_ids` have no functionality in BLOOM and will be removed in v5.0.0. You can safely ignore"
+                " passing `position_ids`.",
+                FutureWarning,
+            )
+        if len(deprecated_arguments) > 0:
+            raise ValueError(f"Got unexpected arguments: {deprecated_arguments}")
+
+        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 and inputs_embeds is not None:
+            raise ValueError("You cannot specify both input_ids and inputs_embeds at the same time")
+        elif 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
+        else:
+            raise ValueError("You have to specify either input_ids or inputs_embeds")
+
+        if past_key_values is None:
+            past_key_values = tuple([None] * len(self.h))
+
+        # Prepare head mask if needed
+        # 1.0 in head_mask indicate we keep the head
+        # attention_probs has shape batch_size x num_heads x N x N
+        # head_mask has shape n_layer x batch x num_heads x N x N
+        head_mask = self.get_head_mask(head_mask, self.config.n_layer)
+
+        if inputs_embeds is None:
+            inputs_embeds = self.word_embeddings(input_ids)
+
+        hidden_states = 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
+
+        # Compute alibi tensor: check build_alibi_tensor documentation
+        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)
+
+        if self.alibi:
+            alibi = build_alibi_tensor(attention_mask, self.num_heads, dtype=hidden_states.dtype)
+        else:
+            alibi = None
+
+        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:
+
+                if use_cache:
+                    logger.warning(
+                        "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..."
+                    )
+                    use_cache = False
+
+                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,
+                    alibi,
+                    causal_mask,
+                    head_mask[i],
+                )
+            else:
+                outputs = block(
+                    hidden_states,
+                    layer_past=layer_past,
+                    attention_mask=causal_mask,
+                    head_mask=head_mask[i],
+                    use_cache=use_cache,
+                    output_attentions=output_attentions,
+                    alibi=alibi,
+                )
+
+            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],)
+
+        # Add last hidden state
+        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 RWForCausalLM(RWPreTrainedModel):
+    _keys_to_ignore_on_load_missing = [r"h.*.self_attention.scale_mask_softmax.causal_mask", r"lm_head.weight"]
+
+    def __init__(self, config: RWConfig):
+        super().__init__(config)
+        self.transformer = RWModel(config)
+        self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
+
+        # Initialize weights and apply final processing
+        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: Optional[torch.Tensor] = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        **kwargs,
+    ) -> dict:
+        # only last token for input_ids if past is not None
+        if past:
+            input_ids = input_ids[:, -1].unsqueeze(-1)
+
+            # the cache may be in the stardard format (e.g. in contrastive search), convert to our's format if needed
+            if past[0][0].shape[0] == input_ids.shape[0]:
+                past = self._convert_to_rw_cache(past)
+
+        return {
+            "input_ids": input_ids,
+            "past_key_values": past,
+            "use_cache": kwargs.get("use_cache"),
+            "attention_mask": attention_mask,
+        }
+
+    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,
+        head_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]:
+        r"""
+        labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+            Labels for language modeling. Note that the labels **are shifted** inside the model, i.e. you can set
+            `labels = input_ids` Indices are selected in `[-100, 0, ..., config.vocab_size]` All labels set to `-100`
+            are ignored (masked), the loss is only computed for labels in `[0, ..., config.vocab_size]`
+        """
+        if deprecated_arguments.pop("position_ids", False) is not False:
+            # `position_ids` could have been `torch.Tensor` or `None` so defaulting pop to `False` allows to detect if users were passing explicitly `None`
+            warnings.warn(
+                "`position_ids` have no functionality in BLOOM and will be removed in v5.0.0. You can safely ignore"
+                " passing `position_ids`.",
+                FutureWarning,
+            )
+        if len(deprecated_arguments) > 0:
+            raise ValueError(f"Got unexpected arguments: {deprecated_arguments}")
+
+        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,
+            head_mask=head_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:
+            # Shift so that tokens < n predict n
+            shift_logits = lm_logits[..., :-1, :].contiguous()
+            shift_labels = labels[..., 1:].contiguous()
+            batch_size, seq_length, vocab_size = shift_logits.shape
+            # Flatten the tokens
+            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,
+        )
+
+    def _reorder_cache(
+        self, past: Tuple[Tuple[torch.Tensor, torch.Tensor], ...], beam_idx: torch.LongTensor
+    ) -> Tuple[Tuple[torch.Tensor, torch.Tensor], ...]:
+        """
+        This function is used to re-order the `past_key_values` cache if [`~PreTrainedModel.beam_search`] or
+        [`~PreTrainedModel.beam_sample`] is called. This is required to match `past_key_values` with the correct
+        beam_idx at every generation step.
+
+        Output shares the same memory storage as `past`.
+        """
+        standardized_past = self._convert_to_standard_cache(past, batch_size=len(beam_idx))
+
+        # Get a copy of `beam_idx` on all the devices where we need those indices.
+        device_to_beam_idx = {
+            past_state.device: beam_idx.to(past_state.device) for layer_past in past for past_state in layer_past
+        }
+        reordered_past = tuple(
+            (
+                layer_past[0].index_select(0, device_to_beam_idx[layer_past[0].device]),
+                layer_past[1].index_select(0, device_to_beam_idx[layer_past[0].device]),
+            )
+            for layer_past in standardized_past
+        )
+        return self._convert_to_rw_cache(reordered_past)
+
+
+class RWForSequenceClassification(RWPreTrainedModel):
+    _keys_to_ignore_on_load_missing = [r"h.*.self_attention.scale_mask_softmax.causal_mask", r"lm_head.weight"]
+
+    def __init__(self, config: RWConfig):
+        super().__init__(config)
+        self.num_labels = config.num_labels
+        self.transformer = RWModel(config)
+        self.score = nn.Linear(config.hidden_size, config.num_labels, bias=False)
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    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,
+        head_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], SequenceClassifierOutputWithPast]:
+        r"""
+        labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+            Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
+            config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+            `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+        """
+        if deprecated_arguments.pop("position_ids", False) is not False:
+            # `position_ids` could have been `torch.Tensor` or `None` so defaulting pop to `False` allows to detect if users were passing explicitly `None`
+            warnings.warn(
+                "`position_ids` have no functionality in BLOOM and will be removed in v5.0.0. You can safely ignore"
+                " passing `position_ids`.",
+                FutureWarning,
+            )
+        if len(deprecated_arguments) > 0:
+            raise ValueError(f"Got unexpected arguments: {deprecated_arguments}")
+
+        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,
+            head_mask=head_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]
+        logits = self.score(hidden_states)
+
+        if input_ids is not None:
+            batch_size = input_ids.shape[0]
+        else:
+            batch_size = inputs_embeds.shape[0]
+
+        if self.config.pad_token_id is None and batch_size != 1:
+            raise ValueError("Cannot handle batch sizes > 1 if no padding token is defined.")
+        if self.config.pad_token_id is None:
+            sequence_lengths = -1
+        else:
+            if input_ids is not None:
+                sequence_lengths = torch.ne(input_ids, self.config.pad_token_id).sum(dim=-1) - 1
+            else:
+                sequence_lengths = -1
+                logger.warning(
+                    f"{self.__class__.__name__} will not detect padding tokens in `inputs_embeds`. Results may be "
+                    "unexpected if using padding tokens in conjunction with `inputs_embeds.`"
+                )
+
+        pooled_logits = logits[torch.arange(batch_size, device=logits.device), sequence_lengths]
+
+        loss = None
+        if labels is not None:
+            if self.config.problem_type is None:
+                if self.num_labels == 1:
+                    self.config.problem_type = "regression"
+                elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
+                    self.config.problem_type = "single_label_classification"
+                else:
+                    self.config.problem_type = "multi_label_classification"
+
+            if self.config.problem_type == "regression":
+                loss_fct = MSELoss()
+                if self.num_labels == 1:
+                    loss = loss_fct(pooled_logits.squeeze(), labels.squeeze())
+                else:
+                    loss = loss_fct(pooled_logits, labels)
+            elif self.config.problem_type == "single_label_classification":
+                loss_fct = CrossEntropyLoss()
+                loss = loss_fct(pooled_logits, labels)
+            elif self.config.problem_type == "multi_label_classification":
+                loss_fct = BCEWithLogitsLoss()
+                loss = loss_fct(pooled_logits, labels)
+        if not return_dict:
+            output = (pooled_logits,) + transformer_outputs[1:]
+            return ((loss,) + output) if loss is not None else output
+
+        return SequenceClassifierOutputWithPast(
+            loss=loss,
+            logits=pooled_logits,
+            past_key_values=transformer_outputs.past_key_values,
+            hidden_states=transformer_outputs.hidden_states,
+            attentions=transformer_outputs.attentions,
+        )
+
+
+class RWForTokenClassification(RWPreTrainedModel):
+    _keys_to_ignore_on_load_missing = [r"h.*.self_attention.scale_mask_softmax.causal_mask", r"lm_head.weight"]
+
+    def __init__(self, config: RWConfig):
+        super().__init__(config)
+        self.num_labels = config.num_labels
+
+        self.transformer = RWModel(config)
+        if hasattr(config, "classifier_dropout") and config.classifier_dropout is not None:
+            classifier_dropout = config.classifier_dropout
+        elif hasattr(config, "hidden_dropout") and config.hidden_dropout is not None:
+            classifier_dropout = config.hidden_dropout
+        else:
+            classifier_dropout = 0.1
+        self.dropout = nn.Dropout(classifier_dropout)
+        self.classifier = nn.Linear(config.hidden_size, config.num_labels)
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    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,
+        head_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], TokenClassifierOutput]:
+        r"""
+        labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+            Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
+            config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+            `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+        """
+        if deprecated_arguments.pop("position_ids", False) is not False:
+            # `position_ids` could have been `torch.Tensor` or `None` so defaulting pop to `False` allows to detect if users were passing explicitly `None`
+            warnings.warn(
+                "`position_ids` have no functionality in BLOOM and will be removed in v5.0.0. You can safely ignore"
+                " passing `position_ids`.",
+                FutureWarning,
+            )
+        if len(deprecated_arguments) > 0:
+            raise ValueError(f"Got unexpected arguments: {deprecated_arguments}")
+
+        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,
+            head_mask=head_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]
+        hidden_states = self.dropout(hidden_states)
+        logits = self.classifier(hidden_states)
+
+        loss = None
+        if labels is not None:
+            batch_size, seq_length = labels.shape
+            loss_fct = CrossEntropyLoss()
+            loss = loss_fct(logits.view(batch_size * seq_length, self.num_labels), labels.view(batch_size * seq_length))
+
+        if not return_dict:
+            output = (logits,) + transformer_outputs[2:]
+            return ((loss,) + output) if loss is not None else output
+
+        return TokenClassifierOutput(
+            loss=loss,
+            logits=logits,
+            hidden_states=transformer_outputs.hidden_states,
+            attentions=transformer_outputs.attentions,
+        )
+
+
+class RWForQuestionAnswering(RWPreTrainedModel):
+    _keys_to_ignore_on_load_missing = [r"h.*.self_attention.scale_mask_softmax.causal_mask", r"lm_head.weight"]
+
+    def __init__(self, config):
+        super().__init__(config)
+        self.transformer = RWModel(config)
+        self.qa_outputs = nn.Linear(config.hidden_size, 2)
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def forward(
+        self,
+        input_ids: Optional[torch.LongTensor] = None,
+        attention_mask: Optional[torch.FloatTensor] = None,
+        position_ids: Optional[torch.LongTensor] = None,
+        head_mask: Optional[torch.FloatTensor] = None,
+        inputs_embeds: Optional[torch.FloatTensor] = None,
+        start_positions: Optional[torch.LongTensor] = None,
+        end_positions: Optional[torch.LongTensor] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple, QuestionAnsweringModelOutput]:
+        r"""
+        start_positions (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+            Labels for position (index) of the start of the labelled span for computing the token classification loss.
+            Positions are clamped to the length of the sequence (`sequence_length`). Position outside of the sequence
+            are not taken into account for computing the loss.
+        end_positions (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+            Labels for position (index) of the end of the labelled span for computing the token classification loss.
+            Positions are clamped to the length of the sequence (`sequence_length`). Position outside of the sequence
+            are not taken into account for computing the loss.
+        """
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        outputs = self.transformer(
+            input_ids,
+            attention_mask=attention_mask,
+            position_ids=position_ids,
+            head_mask=head_mask,
+            inputs_embeds=inputs_embeds,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+
+        sequence_output = outputs[0]
+
+        logits = self.qa_outputs(sequence_output)
+        start_logits, end_logits = logits.split(1, dim=-1)
+        start_logits = start_logits.squeeze(-1).contiguous()
+        end_logits = end_logits.squeeze(-1).contiguous()
+
+        total_loss = None
+        if start_positions is not None and end_positions is not None:
+            # If we are on multi-GPU, split add a dimension
+            if len(start_positions.size()) > 1:
+                start_positions = start_positions.squeeze(-1)
+            if len(end_positions.size()) > 1:
+                end_positions = end_positions.squeeze(-1)
+            # sometimes the start/end positions are outside our model inputs, we ignore these terms
+            ignored_index = start_logits.size(1)
+            start_positions = start_positions.clamp(0, ignored_index)
+            end_positions = end_positions.clamp(0, ignored_index)
+
+            loss_fct = CrossEntropyLoss(ignore_index=ignored_index)
+            start_loss = loss_fct(start_logits, start_positions)
+            end_loss = loss_fct(end_logits, end_positions)
+            total_loss = (start_loss + end_loss) / 2
+
+        if not return_dict:
+            output = (start_logits, end_logits) + outputs[2:]
+            return ((total_loss,) + output) if total_loss is not None else output
+
+        return QuestionAnsweringModelOutput(
+            loss=total_loss,
+            start_logits=start_logits,
+            end_logits=end_logits,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )

pytorch_model-00001-of-00018.bin

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

pytorch_model-00002-of-00018.bin

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

pytorch_model-00003-of-00018.bin

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

pytorch_model-00004-of-00018.bin

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

pytorch_model-00005-of-00018.bin

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

pytorch_model-00006-of-00018.bin

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

pytorch_model-00007-of-00018.bin

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

pytorch_model-00008-of-00018.bin

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

pytorch_model-00009-of-00018.bin

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

pytorch_model-00010-of-00018.bin

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

pytorch_model-00011-of-00018.bin

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

pytorch_model-00012-of-00018.bin

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

pytorch_model-00013-of-00018.bin

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

pytorch_model-00014-of-00018.bin

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

pytorch_model-00015-of-00018.bin

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

pytorch_model-00016-of-00018.bin

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

pytorch_model-00017-of-00018.bin

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

pytorch_model-00018-of-00018.bin

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

pytorch_model.bin.index.json

@@ -0,0 +1,491 @@
+{
+  "metadata": {
+    "total_size": 167343947776
+  },
+  "weight_map": {
+    "lm_head.weight": "pytorch_model-00018-of-00018.bin",
+    "transformer.h.0.ln_attn.bias": "pytorch_model-00001-of-00018.bin",
+    "transformer.h.0.ln_attn.weight": "pytorch_model-00001-of-00018.bin",
+    "transformer.h.0.ln_mlp.bias": "pytorch_model-00001-of-00018.bin",
+    "transformer.h.0.ln_mlp.weight": "pytorch_model-00001-of-00018.bin",
+    "transformer.h.0.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00018.bin",
+    "transformer.h.0.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00018.bin",
+    "transformer.h.0.self_attention.dense.weight": "pytorch_model-00001-of-00018.bin",
+    "transformer.h.0.self_attention.query_key_value.weight": "pytorch_model-00001-of-00018.bin",
+    "transformer.h.1.ln_attn.bias": "pytorch_model-00001-of-00018.bin",
+    "transformer.h.1.ln_attn.weight": "pytorch_model-00001-of-00018.bin",
+    "transformer.h.1.ln_mlp.bias": "pytorch_model-00001-of-00018.bin",
+    "transformer.h.1.ln_mlp.weight": "pytorch_model-00001-of-00018.bin",
+    "transformer.h.1.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00018.bin",
+    "transformer.h.1.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00018.bin",
+    "transformer.h.1.self_attention.dense.weight": "pytorch_model-00001-of-00018.bin",
+    "transformer.h.1.self_attention.query_key_value.weight": "pytorch_model-00001-of-00018.bin",
+    "transformer.h.10.ln_attn.bias": "pytorch_model-00004-of-00018.bin",
+    "transformer.h.10.ln_attn.weight": "pytorch_model-00004-of-00018.bin",
+    "transformer.h.10.ln_mlp.bias": "pytorch_model-00004-of-00018.bin",
+    "transformer.h.10.ln_mlp.weight": "pytorch_model-00004-of-00018.bin",
+    "transformer.h.10.mlp.dense_4h_to_h.weight": "pytorch_model-00004-of-00018.bin",
+    "transformer.h.10.mlp.dense_h_to_4h.weight": "pytorch_model-00004-of-00018.bin",
+    "transformer.h.10.self_attention.dense.weight": "pytorch_model-00004-of-00018.bin",
+    "transformer.h.10.self_attention.query_key_value.weight": "pytorch_model-00004-of-00018.bin",
+    "transformer.h.11.ln_attn.bias": "pytorch_model-00004-of-00018.bin",
+    "transformer.h.11.ln_attn.weight": "pytorch_model-00004-of-00018.bin",
+    "transformer.h.11.ln_mlp.bias": "pytorch_model-00004-of-00018.bin",
+    "transformer.h.11.ln_mlp.weight": "pytorch_model-00004-of-00018.bin",
+    "transformer.h.11.mlp.dense_4h_to_h.weight": "pytorch_model-00004-of-00018.bin",
+    "transformer.h.11.mlp.dense_h_to_4h.weight": "pytorch_model-00004-of-00018.bin",
+    "transformer.h.11.self_attention.dense.weight": "pytorch_model-00004-of-00018.bin",
+    "transformer.h.11.self_attention.query_key_value.weight": "pytorch_model-00004-of-00018.bin",
+    "transformer.h.12.ln_attn.bias": "pytorch_model-00004-of-00018.bin",
+    "transformer.h.12.ln_attn.weight": "pytorch_model-00004-of-00018.bin",
+    "transformer.h.12.ln_mlp.bias": "pytorch_model-00004-of-00018.bin",
+    "transformer.h.12.ln_mlp.weight": "pytorch_model-00004-of-00018.bin",
+    "transformer.h.12.mlp.dense_4h_to_h.weight": "pytorch_model-00004-of-00018.bin",
+    "transformer.h.12.mlp.dense_h_to_4h.weight": "pytorch_model-00004-of-00018.bin",
+    "transformer.h.12.self_attention.dense.weight": "pytorch_model-00004-of-00018.bin",
+    "transformer.h.12.self_attention.query_key_value.weight": "pytorch_model-00004-of-00018.bin",
+    "transformer.h.13.ln_attn.bias": "pytorch_model-00004-of-00018.bin",
+    "transformer.h.13.ln_attn.weight": "pytorch_model-00004-of-00018.bin",
+    "transformer.h.13.ln_mlp.bias": "pytorch_model-00004-of-00018.bin",
+    "transformer.h.13.ln_mlp.weight": "pytorch_model-00004-of-00018.bin",
+    "transformer.h.13.mlp.dense_4h_to_h.weight": "pytorch_model-00005-of-00018.bin",
+    "transformer.h.13.mlp.dense_h_to_4h.weight": "pytorch_model-00005-of-00018.bin",
+    "transformer.h.13.self_attention.dense.weight": "pytorch_model-00004-of-00018.bin",
+    "transformer.h.13.self_attention.query_key_value.weight": "pytorch_model-00004-of-00018.bin",
+    "transformer.h.14.ln_attn.bias": "pytorch_model-00005-of-00018.bin",
+    "transformer.h.14.ln_attn.weight": "pytorch_model-00005-of-00018.bin",
+    "transformer.h.14.ln_mlp.bias": "pytorch_model-00005-of-00018.bin",
+    "transformer.h.14.ln_mlp.weight": "pytorch_model-00005-of-00018.bin",
+    "transformer.h.14.mlp.dense_4h_to_h.weight": "pytorch_model-00005-of-00018.bin",
+    "transformer.h.14.mlp.dense_h_to_4h.weight": "pytorch_model-00005-of-00018.bin",
+    "transformer.h.14.self_attention.dense.weight": "pytorch_model-00005-of-00018.bin",
+    "transformer.h.14.self_attention.query_key_value.weight": "pytorch_model-00005-of-00018.bin",
+    "transformer.h.15.ln_attn.bias": "pytorch_model-00005-of-00018.bin",
+    "transformer.h.15.ln_attn.weight": "pytorch_model-00005-of-00018.bin",
+    "transformer.h.15.ln_mlp.bias": "pytorch_model-00005-of-00018.bin",
+    "transformer.h.15.ln_mlp.weight": "pytorch_model-00005-of-00018.bin",
+    "transformer.h.15.mlp.dense_4h_to_h.weight": "pytorch_model-00005-of-00018.bin",
+    "transformer.h.15.mlp.dense_h_to_4h.weight": "pytorch_model-00005-of-00018.bin",
+    "transformer.h.15.self_attention.dense.weight": "pytorch_model-00005-of-00018.bin",
+    "transformer.h.15.self_attention.query_key_value.weight": "pytorch_model-00005-of-00018.bin",
+    "transformer.h.16.ln_attn.bias": "pytorch_model-00005-of-00018.bin",
+    "transformer.h.16.ln_attn.weight": "pytorch_model-00005-of-00018.bin",
+    "transformer.h.16.ln_mlp.bias": "pytorch_model-00005-of-00018.bin",
+    "transformer.h.16.ln_mlp.weight": "pytorch_model-00005-of-00018.bin",
+    "transformer.h.16.mlp.dense_4h_to_h.weight": "pytorch_model-00006-of-00018.bin",
+    "transformer.h.16.mlp.dense_h_to_4h.weight": "pytorch_model-00005-of-00018.bin",
+    "transformer.h.16.self_attention.dense.weight": "pytorch_model-00005-of-00018.bin",
+    "transformer.h.16.self_attention.query_key_value.weight": "pytorch_model-00005-of-00018.bin",
+    "transformer.h.17.ln_attn.bias": "pytorch_model-00006-of-00018.bin",
+    "transformer.h.17.ln_attn.weight": "pytorch_model-00006-of-00018.bin",
+    "transformer.h.17.ln_mlp.bias": "pytorch_model-00006-of-00018.bin",
+    "transformer.h.17.ln_mlp.weight": "pytorch_model-00006-of-00018.bin",
+    "transformer.h.17.mlp.dense_4h_to_h.weight": "pytorch_model-00006-of-00018.bin",
+    "transformer.h.17.mlp.dense_h_to_4h.weight": "pytorch_model-00006-of-00018.bin",
+    "transformer.h.17.self_attention.dense.weight": "pytorch_model-00006-of-00018.bin",
+    "transformer.h.17.self_attention.query_key_value.weight": "pytorch_model-00006-of-00018.bin",
+    "transformer.h.18.ln_attn.bias": "pytorch_model-00006-of-00018.bin",
+    "transformer.h.18.ln_attn.weight": "pytorch_model-00006-of-00018.bin",
+    "transformer.h.18.ln_mlp.bias": "pytorch_model-00006-of-00018.bin",
+    "transformer.h.18.ln_mlp.weight": "pytorch_model-00006-of-00018.bin",
+    "transformer.h.18.mlp.dense_4h_to_h.weight": "pytorch_model-00006-of-00018.bin",
+    "transformer.h.18.mlp.dense_h_to_4h.weight": "pytorch_model-00006-of-00018.bin",
+    "transformer.h.18.self_attention.dense.weight": "pytorch_model-00006-of-00018.bin",
+    "transformer.h.18.self_attention.query_key_value.weight": "pytorch_model-00006-of-00018.bin",
+    "transformer.h.19.ln_attn.bias": "pytorch_model-00006-of-00018.bin",
+    "transformer.h.19.ln_attn.weight": "pytorch_model-00006-of-00018.bin",
+    "transformer.h.19.ln_mlp.bias": "pytorch_model-00006-of-00018.bin",
+    "transformer.h.19.ln_mlp.weight": "pytorch_model-00006-of-00018.bin",
+    "transformer.h.19.mlp.dense_4h_to_h.weight": "pytorch_model-00006-of-00018.bin",
+    "transformer.h.19.mlp.dense_h_to_4h.weight": "pytorch_model-00006-of-00018.bin",
+    "transformer.h.19.self_attention.dense.weight": "pytorch_model-00006-of-00018.bin",
+    "transformer.h.19.self_attention.query_key_value.weight": "pytorch_model-00006-of-00018.bin",
+    "transformer.h.2.ln_attn.bias": "pytorch_model-00001-of-00018.bin",
+    "transformer.h.2.ln_attn.weight": "pytorch_model-00001-of-00018.bin",
+    "transformer.h.2.ln_mlp.bias": "pytorch_model-00001-of-00018.bin",
+    "transformer.h.2.ln_mlp.weight": "pytorch_model-00001-of-00018.bin",
+    "transformer.h.2.mlp.dense_4h_to_h.weight": "pytorch_model-00002-of-00018.bin",
+    "transformer.h.2.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00018.bin",
+    "transformer.h.2.self_attention.dense.weight": "pytorch_model-00001-of-00018.bin",
+    "transformer.h.2.self_attention.query_key_value.weight": "pytorch_model-00001-of-00018.bin",
+    "transformer.h.20.ln_attn.bias": "pytorch_model-00006-of-00018.bin",
+    "transformer.h.20.ln_attn.weight": "pytorch_model-00006-of-00018.bin",
+    "transformer.h.20.ln_mlp.bias": "pytorch_model-00006-of-00018.bin",
+    "transformer.h.20.ln_mlp.weight": "pytorch_model-00006-of-00018.bin",
+    "transformer.h.20.mlp.dense_4h_to_h.weight": "pytorch_model-00007-of-00018.bin",
+    "transformer.h.20.mlp.dense_h_to_4h.weight": "pytorch_model-00007-of-00018.bin",
+    "transformer.h.20.self_attention.dense.weight": "pytorch_model-00006-of-00018.bin",
+    "transformer.h.20.self_attention.query_key_value.weight": "pytorch_model-00006-of-00018.bin",
+    "transformer.h.21.ln_attn.bias": "pytorch_model-00007-of-00018.bin",
+    "transformer.h.21.ln_attn.weight": "pytorch_model-00007-of-00018.bin",
+    "transformer.h.21.ln_mlp.bias": "pytorch_model-00007-of-00018.bin",
+    "transformer.h.21.ln_mlp.weight": "pytorch_model-00007-of-00018.bin",
+    "transformer.h.21.mlp.dense_4h_to_h.weight": "pytorch_model-00007-of-00018.bin",
+    "transformer.h.21.mlp.dense_h_to_4h.weight": "pytorch_model-00007-of-00018.bin",
+    "transformer.h.21.self_attention.dense.weight": "pytorch_model-00007-of-00018.bin",
+    "transformer.h.21.self_attention.query_key_value.weight": "pytorch_model-00007-of-00018.bin",
+    "transformer.h.22.ln_attn.bias": "pytorch_model-00007-of-00018.bin",
+    "transformer.h.22.ln_attn.weight": "pytorch_model-00007-of-00018.bin",
+    "transformer.h.22.ln_mlp.bias": "pytorch_model-00007-of-00018.bin",
+    "transformer.h.22.ln_mlp.weight": "pytorch_model-00007-of-00018.bin",
+    "transformer.h.22.mlp.dense_4h_to_h.weight": "pytorch_model-00007-of-00018.bin",
+    "transformer.h.22.mlp.dense_h_to_4h.weight": "pytorch_model-00007-of-00018.bin",
+    "transformer.h.22.self_attention.dense.weight": "pytorch_model-00007-of-00018.bin",
+    "transformer.h.22.self_attention.query_key_value.weight": "pytorch_model-00007-of-00018.bin",
+    "transformer.h.23.ln_attn.bias": "pytorch_model-00007-of-00018.bin",
+    "transformer.h.23.ln_attn.weight": "pytorch_model-00007-of-00018.bin",
+    "transformer.h.23.ln_mlp.bias": "pytorch_model-00007-of-00018.bin",
+    "transformer.h.23.ln_mlp.weight": "pytorch_model-00007-of-00018.bin",
+    "transformer.h.23.mlp.dense_4h_to_h.weight": "pytorch_model-00008-of-00018.bin",
+    "transformer.h.23.mlp.dense_h_to_4h.weight": "pytorch_model-00007-of-00018.bin",
+    "transformer.h.23.self_attention.dense.weight": "pytorch_model-00007-of-00018.bin",
+    "transformer.h.23.self_attention.query_key_value.weight": "pytorch_model-00007-of-00018.bin",
+    "transformer.h.24.ln_attn.bias": "pytorch_model-00008-of-00018.bin",
+    "transformer.h.24.ln_attn.weight": "pytorch_model-00008-of-00018.bin",
+    "transformer.h.24.ln_mlp.bias": "pytorch_model-00008-of-00018.bin",
+    "transformer.h.24.ln_mlp.weight": "pytorch_model-00008-of-00018.bin",
+    "transformer.h.24.mlp.dense_4h_to_h.weight": "pytorch_model-00008-of-00018.bin",
+    "transformer.h.24.mlp.dense_h_to_4h.weight": "pytorch_model-00008-of-00018.bin",
+    "transformer.h.24.self_attention.dense.weight": "pytorch_model-00008-of-00018.bin",
+    "transformer.h.24.self_attention.query_key_value.weight": "pytorch_model-00008-of-00018.bin",
+    "transformer.h.25.ln_attn.bias": "pytorch_model-00008-of-00018.bin",
+    "transformer.h.25.ln_attn.weight": "pytorch_model-00008-of-00018.bin",
+    "transformer.h.25.ln_mlp.bias": "pytorch_model-00008-of-00018.bin",
+    "transformer.h.25.ln_mlp.weight": "pytorch_model-00008-of-00018.bin",
+    "transformer.h.25.mlp.dense_4h_to_h.weight": "pytorch_model-00008-of-00018.bin",
+    "transformer.h.25.mlp.dense_h_to_4h.weight": "pytorch_model-00008-of-00018.bin",
+    "transformer.h.25.self_attention.dense.weight": "pytorch_model-00008-of-00018.bin",
+    "transformer.h.25.self_attention.query_key_value.weight": "pytorch_model-00008-of-00018.bin",
+    "transformer.h.26.ln_attn.bias": "pytorch_model-00008-of-00018.bin",
+    "transformer.h.26.ln_attn.weight": "pytorch_model-00008-of-00018.bin",
+    "transformer.h.26.ln_mlp.bias": "pytorch_model-00008-of-00018.bin",
+    "transformer.h.26.ln_mlp.weight": "pytorch_model-00008-of-00018.bin",
+    "transformer.h.26.mlp.dense_4h_to_h.weight": "pytorch_model-00008-of-00018.bin",
+    "transformer.h.26.mlp.dense_h_to_4h.weight": "pytorch_model-00008-of-00018.bin",
+    "transformer.h.26.self_attention.dense.weight": "pytorch_model-00008-of-00018.bin",
+    "transformer.h.26.self_attention.query_key_value.weight": "pytorch_model-00008-of-00018.bin",
+    "transformer.h.27.ln_attn.bias": "pytorch_model-00008-of-00018.bin",
+    "transformer.h.27.ln_attn.weight": "pytorch_model-00008-of-00018.bin",
+    "transformer.h.27.ln_mlp.bias": "pytorch_model-00008-of-00018.bin",
+    "transformer.h.27.ln_mlp.weight": "pytorch_model-00008-of-00018.bin",
+    "transformer.h.27.mlp.dense_4h_to_h.weight": "pytorch_model-00009-of-00018.bin",
+    "transformer.h.27.mlp.dense_h_to_4h.weight": "pytorch_model-00009-of-00018.bin",
+    "transformer.h.27.self_attention.dense.weight": "pytorch_model-00008-of-00018.bin",
+    "transformer.h.27.self_attention.query_key_value.weight": "pytorch_model-00008-of-00018.bin",
+    "transformer.h.28.ln_attn.bias": "pytorch_model-00009-of-00018.bin",
+    "transformer.h.28.ln_attn.weight": "pytorch_model-00009-of-00018.bin",
+    "transformer.h.28.ln_mlp.bias": "pytorch_model-00009-of-00018.bin",
+    "transformer.h.28.ln_mlp.weight": "pytorch_model-00009-of-00018.bin",
+    "transformer.h.28.mlp.dense_4h_to_h.weight": "pytorch_model-00009-of-00018.bin",
+    "transformer.h.28.mlp.dense_h_to_4h.weight": "pytorch_model-00009-of-00018.bin",
+    "transformer.h.28.self_attention.dense.weight": "pytorch_model-00009-of-00018.bin",
+    "transformer.h.28.self_attention.query_key_value.weight": "pytorch_model-00009-of-00018.bin",
+    "transformer.h.29.ln_attn.bias": "pytorch_model-00009-of-00018.bin",
+    "transformer.h.29.ln_attn.weight": "pytorch_model-00009-of-00018.bin",
+    "transformer.h.29.ln_mlp.bias": "pytorch_model-00009-of-00018.bin",
+    "transformer.h.29.ln_mlp.weight": "pytorch_model-00009-of-00018.bin",
+    "transformer.h.29.mlp.dense_4h_to_h.weight": "pytorch_model-00009-of-00018.bin",
+    "transformer.h.29.mlp.dense_h_to_4h.weight": "pytorch_model-00009-of-00018.bin",
+    "transformer.h.29.self_attention.dense.weight": "pytorch_model-00009-of-00018.bin",
+    "transformer.h.29.self_attention.query_key_value.weight": "pytorch_model-00009-of-00018.bin",
+    "transformer.h.3.ln_attn.bias": "pytorch_model-00002-of-00018.bin",
+    "transformer.h.3.ln_attn.weight": "pytorch_model-00002-of-00018.bin",
+    "transformer.h.3.ln_mlp.bias": "pytorch_model-00002-of-00018.bin",
+    "transformer.h.3.ln_mlp.weight": "pytorch_model-00002-of-00018.bin",
+    "transformer.h.3.mlp.dense_4h_to_h.weight": "pytorch_model-00002-of-00018.bin",
+    "transformer.h.3.mlp.dense_h_to_4h.weight": "pytorch_model-00002-of-00018.bin",
+    "transformer.h.3.self_attention.dense.weight": "pytorch_model-00002-of-00018.bin",
+    "transformer.h.3.self_attention.query_key_value.weight": "pytorch_model-00002-of-00018.bin",
+    "transformer.h.30.ln_attn.bias": "pytorch_model-00009-of-00018.bin",
+    "transformer.h.30.ln_attn.weight": "pytorch_model-00009-of-00018.bin",
+    "transformer.h.30.ln_mlp.bias": "pytorch_model-00009-of-00018.bin",
+    "transformer.h.30.ln_mlp.weight": "pytorch_model-00009-of-00018.bin",
+    "transformer.h.30.mlp.dense_4h_to_h.weight": "pytorch_model-00010-of-00018.bin",
+    "transformer.h.30.mlp.dense_h_to_4h.weight": "pytorch_model-00009-of-00018.bin",
+    "transformer.h.30.self_attention.dense.weight": "pytorch_model-00009-of-00018.bin",
+    "transformer.h.30.self_attention.query_key_value.weight": "pytorch_model-00009-of-00018.bin",
+    "transformer.h.31.ln_attn.bias": "pytorch_model-00010-of-00018.bin",
+    "transformer.h.31.ln_attn.weight": "pytorch_model-00010-of-00018.bin",
+    "transformer.h.31.ln_mlp.bias": "pytorch_model-00010-of-00018.bin",
+    "transformer.h.31.ln_mlp.weight": "pytorch_model-00010-of-00018.bin",
+    "transformer.h.31.mlp.dense_4h_to_h.weight": "pytorch_model-00010-of-00018.bin",
+    "transformer.h.31.mlp.dense_h_to_4h.weight": "pytorch_model-00010-of-00018.bin",
+    "transformer.h.31.self_attention.dense.weight": "pytorch_model-00010-of-00018.bin",
+    "transformer.h.31.self_attention.query_key_value.weight": "pytorch_model-00010-of-00018.bin",
+    "transformer.h.32.ln_attn.bias": "pytorch_model-00010-of-00018.bin",
+    "transformer.h.32.ln_attn.weight": "pytorch_model-00010-of-00018.bin",
+    "transformer.h.32.ln_mlp.bias": "pytorch_model-00010-of-00018.bin",
+    "transformer.h.32.ln_mlp.weight": "pytorch_model-00010-of-00018.bin",
+    "transformer.h.32.mlp.dense_4h_to_h.weight": "pytorch_model-00010-of-00018.bin",
+    "transformer.h.32.mlp.dense_h_to_4h.weight": "pytorch_model-00010-of-00018.bin",
+    "transformer.h.32.self_attention.dense.weight": "pytorch_model-00010-of-00018.bin",
+    "transformer.h.32.self_attention.query_key_value.weight": "pytorch_model-00010-of-00018.bin",
+    "transformer.h.33.ln_attn.bias": "pytorch_model-00010-of-00018.bin",
+    "transformer.h.33.ln_attn.weight": "pytorch_model-00010-of-00018.bin",
+    "transformer.h.33.ln_mlp.bias": "pytorch_model-00010-of-00018.bin",
+    "transformer.h.33.ln_mlp.weight": "pytorch_model-00010-of-00018.bin",
+    "transformer.h.33.mlp.dense_4h_to_h.weight": "pytorch_model-00010-of-00018.bin",
+    "transformer.h.33.mlp.dense_h_to_4h.weight": "pytorch_model-00010-of-00018.bin",
+    "transformer.h.33.self_attention.dense.weight": "pytorch_model-00010-of-00018.bin",
+    "transformer.h.33.self_attention.query_key_value.weight": "pytorch_model-00010-of-00018.bin",
+    "transformer.h.34.ln_attn.bias": "pytorch_model-00010-of-00018.bin",
+    "transformer.h.34.ln_attn.weight": "pytorch_model-00010-of-00018.bin",
+    "transformer.h.34.ln_mlp.bias": "pytorch_model-00010-of-00018.bin",
+    "transformer.h.34.ln_mlp.weight": "pytorch_model-00010-of-00018.bin",
+    "transformer.h.34.mlp.dense_4h_to_h.weight": "pytorch_model-00011-of-00018.bin",
+    "transformer.h.34.mlp.dense_h_to_4h.weight": "pytorch_model-00011-of-00018.bin",
+    "transformer.h.34.self_attention.dense.weight": "pytorch_model-00010-of-00018.bin",
+    "transformer.h.34.self_attention.query_key_value.weight": "pytorch_model-00010-of-00018.bin",
+    "transformer.h.35.ln_attn.bias": "pytorch_model-00011-of-00018.bin",
+    "transformer.h.35.ln_attn.weight": "pytorch_model-00011-of-00018.bin",
+    "transformer.h.35.ln_mlp.bias": "pytorch_model-00011-of-00018.bin",
+    "transformer.h.35.ln_mlp.weight": "pytorch_model-00011-of-00018.bin",
+    "transformer.h.35.mlp.dense_4h_to_h.weight": "pytorch_model-00011-of-00018.bin",
+    "transformer.h.35.mlp.dense_h_to_4h.weight": "pytorch_model-00011-of-00018.bin",
+    "transformer.h.35.self_attention.dense.weight": "pytorch_model-00011-of-00018.bin",
+    "transformer.h.35.self_attention.query_key_value.weight": "pytorch_model-00011-of-00018.bin",
+    "transformer.h.36.ln_attn.bias": "pytorch_model-00011-of-00018.bin",
+    "transformer.h.36.ln_attn.weight": "pytorch_model-00011-of-00018.bin",
+    "transformer.h.36.ln_mlp.bias": "pytorch_model-00011-of-00018.bin",
+    "transformer.h.36.ln_mlp.weight": "pytorch_model-00011-of-00018.bin",
+    "transformer.h.36.mlp.dense_4h_to_h.weight": "pytorch_model-00011-of-00018.bin",
+    "transformer.h.36.mlp.dense_h_to_4h.weight": "pytorch_model-00011-of-00018.bin",
+    "transformer.h.36.self_attention.dense.weight": "pytorch_model-00011-of-00018.bin",
+    "transformer.h.36.self_attention.query_key_value.weight": "pytorch_model-00011-of-00018.bin",
+    "transformer.h.37.ln_attn.bias": "pytorch_model-00011-of-00018.bin",
+    "transformer.h.37.ln_attn.weight": "pytorch_model-00011-of-00018.bin",
+    "transformer.h.37.ln_mlp.bias": "pytorch_model-00011-of-00018.bin",
+    "transformer.h.37.ln_mlp.weight": "pytorch_model-00011-of-00018.bin",
+    "transformer.h.37.mlp.dense_4h_to_h.weight": "pytorch_model-00012-of-00018.bin",
+    "transformer.h.37.mlp.dense_h_to_4h.weight": "pytorch_model-00011-of-00018.bin",
+    "transformer.h.37.self_attention.dense.weight": "pytorch_model-00011-of-00018.bin",
+    "transformer.h.37.self_attention.query_key_value.weight": "pytorch_model-00011-of-00018.bin",
+    "transformer.h.38.ln_attn.bias": "pytorch_model-00012-of-00018.bin",
+    "transformer.h.38.ln_attn.weight": "pytorch_model-00012-of-00018.bin",
+    "transformer.h.38.ln_mlp.bias": "pytorch_model-00012-of-00018.bin",
+    "transformer.h.38.ln_mlp.weight": "pytorch_model-00012-of-00018.bin",
+    "transformer.h.38.mlp.dense_4h_to_h.weight": "pytorch_model-00012-of-00018.bin",
+    "transformer.h.38.mlp.dense_h_to_4h.weight": "pytorch_model-00012-of-00018.bin",
+    "transformer.h.38.self_attention.dense.weight": "pytorch_model-00012-of-00018.bin",
+    "transformer.h.38.self_attention.query_key_value.weight": "pytorch_model-00012-of-00018.bin",
+    "transformer.h.39.ln_attn.bias": "pytorch_model-00012-of-00018.bin",
+    "transformer.h.39.ln_attn.weight": "pytorch_model-00012-of-00018.bin",
+    "transformer.h.39.ln_mlp.bias": "pytorch_model-00012-of-00018.bin",
+    "transformer.h.39.ln_mlp.weight": "pytorch_model-00012-of-00018.bin",
+    "transformer.h.39.mlp.dense_4h_to_h.weight": "pytorch_model-00012-of-00018.bin",
+    "transformer.h.39.mlp.dense_h_to_4h.weight": "pytorch_model-00012-of-00018.bin",
+    "transformer.h.39.self_attention.dense.weight": "pytorch_model-00012-of-00018.bin",
+    "transformer.h.39.self_attention.query_key_value.weight": "pytorch_model-00012-of-00018.bin",
+    "transformer.h.4.ln_attn.bias": "pytorch_model-00002-of-00018.bin",
+    "transformer.h.4.ln_attn.weight": "pytorch_model-00002-of-00018.bin",
+    "transformer.h.4.ln_mlp.bias": "pytorch_model-00002-of-00018.bin",
+    "transformer.h.4.ln_mlp.weight": "pytorch_model-00002-of-00018.bin",
+    "transformer.h.4.mlp.dense_4h_to_h.weight": "pytorch_model-00002-of-00018.bin",
+    "transformer.h.4.mlp.dense_h_to_4h.weight": "pytorch_model-00002-of-00018.bin",
+    "transformer.h.4.self_attention.dense.weight": "pytorch_model-00002-of-00018.bin",
+    "transformer.h.4.self_attention.query_key_value.weight": "pytorch_model-00002-of-00018.bin",
+    "transformer.h.40.ln_attn.bias": "pytorch_model-00012-of-00018.bin",
+    "transformer.h.40.ln_attn.weight": "pytorch_model-00012-of-00018.bin",
+    "transformer.h.40.ln_mlp.bias": "pytorch_model-00012-of-00018.bin",
+    "transformer.h.40.ln_mlp.weight": "pytorch_model-00012-of-00018.bin",
+    "transformer.h.40.mlp.dense_4h_to_h.weight": "pytorch_model-00012-of-00018.bin",
+    "transformer.h.40.mlp.dense_h_to_4h.weight": "pytorch_model-00012-of-00018.bin",
+    "transformer.h.40.self_attention.dense.weight": "pytorch_model-00012-of-00018.bin",
+    "transformer.h.40.self_attention.query_key_value.weight": "pytorch_model-00012-of-00018.bin",
+    "transformer.h.41.ln_attn.bias": "pytorch_model-00012-of-00018.bin",
+    "transformer.h.41.ln_attn.weight": "pytorch_model-00012-of-00018.bin",
+    "transformer.h.41.ln_mlp.bias": "pytorch_model-00012-of-00018.bin",
+    "transformer.h.41.ln_mlp.weight": "pytorch_model-00012-of-00018.bin",
+    "transformer.h.41.mlp.dense_4h_to_h.weight": "pytorch_model-00013-of-00018.bin",
+    "transformer.h.41.mlp.dense_h_to_4h.weight": "pytorch_model-00013-of-00018.bin",
+    "transformer.h.41.self_attention.dense.weight": "pytorch_model-00012-of-00018.bin",
+    "transformer.h.41.self_attention.query_key_value.weight": "pytorch_model-00012-of-00018.bin",
+    "transformer.h.42.ln_attn.bias": "pytorch_model-00013-of-00018.bin",
+    "transformer.h.42.ln_attn.weight": "pytorch_model-00013-of-00018.bin",
+    "transformer.h.42.ln_mlp.bias": "pytorch_model-00013-of-00018.bin",
+    "transformer.h.42.ln_mlp.weight": "pytorch_model-00013-of-00018.bin",
+    "transformer.h.42.mlp.dense_4h_to_h.weight": "pytorch_model-00013-of-00018.bin",
+    "transformer.h.42.mlp.dense_h_to_4h.weight": "pytorch_model-00013-of-00018.bin",
+    "transformer.h.42.self_attention.dense.weight": "pytorch_model-00013-of-00018.bin",
+    "transformer.h.42.self_attention.query_key_value.weight": "pytorch_model-00013-of-00018.bin",
+    "transformer.h.43.ln_attn.bias": "pytorch_model-00013-of-00018.bin",
+    "transformer.h.43.ln_attn.weight": "pytorch_model-00013-of-00018.bin",
+    "transformer.h.43.ln_mlp.bias": "pytorch_model-00013-of-00018.bin",
+    "transformer.h.43.ln_mlp.weight": "pytorch_model-00013-of-00018.bin",
+    "transformer.h.43.mlp.dense_4h_to_h.weight": "pytorch_model-00013-of-00018.bin",
+    "transformer.h.43.mlp.dense_h_to_4h.weight": "pytorch_model-00013-of-00018.bin",
+    "transformer.h.43.self_attention.dense.weight": "pytorch_model-00013-of-00018.bin",
+    "transformer.h.43.self_attention.query_key_value.weight": "pytorch_model-00013-of-00018.bin",
+    "transformer.h.44.ln_attn.bias": "pytorch_model-00013-of-00018.bin",
+    "transformer.h.44.ln_attn.weight": "pytorch_model-00013-of-00018.bin",
+    "transformer.h.44.ln_mlp.bias": "pytorch_model-00013-of-00018.bin",
+    "transformer.h.44.ln_mlp.weight": "pytorch_model-00013-of-00018.bin",
+    "transformer.h.44.mlp.dense_4h_to_h.weight": "pytorch_model-00014-of-00018.bin",
+    "transformer.h.44.mlp.dense_h_to_4h.weight": "pytorch_model-00013-of-00018.bin",
+    "transformer.h.44.self_attention.dense.weight": "pytorch_model-00013-of-00018.bin",
+    "transformer.h.44.self_attention.query_key_value.weight": "pytorch_model-00013-of-00018.bin",
+    "transformer.h.45.ln_attn.bias": "pytorch_model-00014-of-00018.bin",
+    "transformer.h.45.ln_attn.weight": "pytorch_model-00014-of-00018.bin",
+    "transformer.h.45.ln_mlp.bias": "pytorch_model-00014-of-00018.bin",
+    "transformer.h.45.ln_mlp.weight": "pytorch_model-00014-of-00018.bin",
+    "transformer.h.45.mlp.dense_4h_to_h.weight": "pytorch_model-00014-of-00018.bin",
+    "transformer.h.45.mlp.dense_h_to_4h.weight": "pytorch_model-00014-of-00018.bin",
+    "transformer.h.45.self_attention.dense.weight": "pytorch_model-00014-of-00018.bin",
+    "transformer.h.45.self_attention.query_key_value.weight": "pytorch_model-00014-of-00018.bin",
+    "transformer.h.46.ln_attn.bias": "pytorch_model-00014-of-00018.bin",
+    "transformer.h.46.ln_attn.weight": "pytorch_model-00014-of-00018.bin",
+    "transformer.h.46.ln_mlp.bias": "pytorch_model-00014-of-00018.bin",
+    "transformer.h.46.ln_mlp.weight": "pytorch_model-00014-of-00018.bin",
+    "transformer.h.46.mlp.dense_4h_to_h.weight": "pytorch_model-00014-of-00018.bin",
+    "transformer.h.46.mlp.dense_h_to_4h.weight": "pytorch_model-00014-of-00018.bin",
+    "transformer.h.46.self_attention.dense.weight": "pytorch_model-00014-of-00018.bin",
+    "transformer.h.46.self_attention.query_key_value.weight": "pytorch_model-00014-of-00018.bin",
+    "transformer.h.47.ln_attn.bias": "pytorch_model-00014-of-00018.bin",
+    "transformer.h.47.ln_attn.weight": "pytorch_model-00014-of-00018.bin",
+    "transformer.h.47.ln_mlp.bias": "pytorch_model-00014-of-00018.bin",
+    "transformer.h.47.ln_mlp.weight": "pytorch_model-00014-of-00018.bin",
+    "transformer.h.47.mlp.dense_4h_to_h.weight": "pytorch_model-00014-of-00018.bin",
+    "transformer.h.47.mlp.dense_h_to_4h.weight": "pytorch_model-00014-of-00018.bin",
+    "transformer.h.47.self_attention.dense.weight": "pytorch_model-00014-of-00018.bin",
+    "transformer.h.47.self_attention.query_key_value.weight": "pytorch_model-00014-of-00018.bin",
+    "transformer.h.48.ln_attn.bias": "pytorch_model-00014-of-00018.bin",
+    "transformer.h.48.ln_attn.weight": "pytorch_model-00014-of-00018.bin",
+    "transformer.h.48.ln_mlp.bias": "pytorch_model-00014-of-00018.bin",
+    "transformer.h.48.ln_mlp.weight": "pytorch_model-00014-of-00018.bin",
+    "transformer.h.48.mlp.dense_4h_to_h.weight": "pytorch_model-00015-of-00018.bin",
+    "transformer.h.48.mlp.dense_h_to_4h.weight": "pytorch_model-00015-of-00018.bin",
+    "transformer.h.48.self_attention.dense.weight": "pytorch_model-00014-of-00018.bin",
+    "transformer.h.48.self_attention.query_key_value.weight": "pytorch_model-00014-of-00018.bin",
+    "transformer.h.49.ln_attn.bias": "pytorch_model-00015-of-00018.bin",
+    "transformer.h.49.ln_attn.weight": "pytorch_model-00015-of-00018.bin",
+    "transformer.h.49.ln_mlp.bias": "pytorch_model-00015-of-00018.bin",
+    "transformer.h.49.ln_mlp.weight": "pytorch_model-00015-of-00018.bin",
+    "transformer.h.49.mlp.dense_4h_to_h.weight": "pytorch_model-00015-of-00018.bin",
+    "transformer.h.49.mlp.dense_h_to_4h.weight": "pytorch_model-00015-of-00018.bin",
+    "transformer.h.49.self_attention.dense.weight": "pytorch_model-00015-of-00018.bin",
+    "transformer.h.49.self_attention.query_key_value.weight": "pytorch_model-00015-of-00018.bin",
+    "transformer.h.5.ln_attn.bias": "pytorch_model-00002-of-00018.bin",
+    "transformer.h.5.ln_attn.weight": "pytorch_model-00002-of-00018.bin",
+    "transformer.h.5.ln_mlp.bias": "pytorch_model-00002-of-00018.bin",
+    "transformer.h.5.ln_mlp.weight": "pytorch_model-00002-of-00018.bin",
+    "transformer.h.5.mlp.dense_4h_to_h.weight": "pytorch_model-00002-of-00018.bin",
+    "transformer.h.5.mlp.dense_h_to_4h.weight": "pytorch_model-00002-of-00018.bin",
+    "transformer.h.5.self_attention.dense.weight": "pytorch_model-00002-of-00018.bin",
+    "transformer.h.5.self_attention.query_key_value.weight": "pytorch_model-00002-of-00018.bin",
+    "transformer.h.50.ln_attn.bias": "pytorch_model-00015-of-00018.bin",
+    "transformer.h.50.ln_attn.weight": "pytorch_model-00015-of-00018.bin",
+    "transformer.h.50.ln_mlp.bias": "pytorch_model-00015-of-00018.bin",
+    "transformer.h.50.ln_mlp.weight": "pytorch_model-00015-of-00018.bin",
+    "transformer.h.50.mlp.dense_4h_to_h.weight": "pytorch_model-00015-of-00018.bin",
+    "transformer.h.50.mlp.dense_h_to_4h.weight": "pytorch_model-00015-of-00018.bin",
+    "transformer.h.50.self_attention.dense.weight": "pytorch_model-00015-of-00018.bin",
+    "transformer.h.50.self_attention.query_key_value.weight": "pytorch_model-00015-of-00018.bin",
+    "transformer.h.51.ln_attn.bias": "pytorch_model-00015-of-00018.bin",
+    "transformer.h.51.ln_attn.weight": "pytorch_model-00015-of-00018.bin",
+    "transformer.h.51.ln_mlp.bias": "pytorch_model-00015-of-00018.bin",
+    "transformer.h.51.ln_mlp.weight": "pytorch_model-00015-of-00018.bin",
+    "transformer.h.51.mlp.dense_4h_to_h.weight": "pytorch_model-00016-of-00018.bin",
+    "transformer.h.51.mlp.dense_h_to_4h.weight": "pytorch_model-00015-of-00018.bin",
+    "transformer.h.51.self_attention.dense.weight": "pytorch_model-00015-of-00018.bin",
+    "transformer.h.51.self_attention.query_key_value.weight": "pytorch_model-00015-of-00018.bin",
+    "transformer.h.52.ln_attn.bias": "pytorch_model-00016-of-00018.bin",
+    "transformer.h.52.ln_attn.weight": "pytorch_model-00016-of-00018.bin",
+    "transformer.h.52.ln_mlp.bias": "pytorch_model-00016-of-00018.bin",
+    "transformer.h.52.ln_mlp.weight": "pytorch_model-00016-of-00018.bin",
+    "transformer.h.52.mlp.dense_4h_to_h.weight": "pytorch_model-00016-of-00018.bin",
+    "transformer.h.52.mlp.dense_h_to_4h.weight": "pytorch_model-00016-of-00018.bin",
+    "transformer.h.52.self_attention.dense.weight": "pytorch_model-00016-of-00018.bin",
+    "transformer.h.52.self_attention.query_key_value.weight": "pytorch_model-00016-of-00018.bin",
+    "transformer.h.53.ln_attn.bias": "pytorch_model-00016-of-00018.bin",
+    "transformer.h.53.ln_attn.weight": "pytorch_model-00016-of-00018.bin",
+    "transformer.h.53.ln_mlp.bias": "pytorch_model-00016-of-00018.bin",
+    "transformer.h.53.ln_mlp.weight": "pytorch_model-00016-of-00018.bin",
+    "transformer.h.53.mlp.dense_4h_to_h.weight": "pytorch_model-00016-of-00018.bin",
+    "transformer.h.53.mlp.dense_h_to_4h.weight": "pytorch_model-00016-of-00018.bin",
+    "transformer.h.53.self_attention.dense.weight": "pytorch_model-00016-of-00018.bin",
+    "transformer.h.53.self_attention.query_key_value.weight": "pytorch_model-00016-of-00018.bin",
+    "transformer.h.54.ln_attn.bias": "pytorch_model-00016-of-00018.bin",
+    "transformer.h.54.ln_attn.weight": "pytorch_model-00016-of-00018.bin",
+    "transformer.h.54.ln_mlp.bias": "pytorch_model-00016-of-00018.bin",
+    "transformer.h.54.ln_mlp.weight": "pytorch_model-00016-of-00018.bin",
+    "transformer.h.54.mlp.dense_4h_to_h.weight": "pytorch_model-00016-of-00018.bin",
+    "transformer.h.54.mlp.dense_h_to_4h.weight": "pytorch_model-00016-of-00018.bin",
+    "transformer.h.54.self_attention.dense.weight": "pytorch_model-00016-of-00018.bin",
+    "transformer.h.54.self_attention.query_key_value.weight": "pytorch_model-00016-of-00018.bin",
+    "transformer.h.55.ln_attn.bias": "pytorch_model-00016-of-00018.bin",
+    "transformer.h.55.ln_attn.weight": "pytorch_model-00016-of-00018.bin",
+    "transformer.h.55.ln_mlp.bias": "pytorch_model-00016-of-00018.bin",
+    "transformer.h.55.ln_mlp.weight": "pytorch_model-00016-of-00018.bin",
+    "transformer.h.55.mlp.dense_4h_to_h.weight": "pytorch_model-00017-of-00018.bin",
+    "transformer.h.55.mlp.dense_h_to_4h.weight": "pytorch_model-00017-of-00018.bin",
+    "transformer.h.55.self_attention.dense.weight": "pytorch_model-00016-of-00018.bin",
+    "transformer.h.55.self_attention.query_key_value.weight": "pytorch_model-00016-of-00018.bin",
+    "transformer.h.56.ln_attn.bias": "pytorch_model-00017-of-00018.bin",
+    "transformer.h.56.ln_attn.weight": "pytorch_model-00017-of-00018.bin",
+    "transformer.h.56.ln_mlp.bias": "pytorch_model-00017-of-00018.bin",
+    "transformer.h.56.ln_mlp.weight": "pytorch_model-00017-of-00018.bin",
+    "transformer.h.56.mlp.dense_4h_to_h.weight": "pytorch_model-00017-of-00018.bin",
+    "transformer.h.56.mlp.dense_h_to_4h.weight": "pytorch_model-00017-of-00018.bin",
+    "transformer.h.56.self_attention.dense.weight": "pytorch_model-00017-of-00018.bin",
+    "transformer.h.56.self_attention.query_key_value.weight": "pytorch_model-00017-of-00018.bin",
+    "transformer.h.57.ln_attn.bias": "pytorch_model-00017-of-00018.bin",
+    "transformer.h.57.ln_attn.weight": "pytorch_model-00017-of-00018.bin",
+    "transformer.h.57.ln_mlp.bias": "pytorch_model-00017-of-00018.bin",
+    "transformer.h.57.ln_mlp.weight": "pytorch_model-00017-of-00018.bin",
+    "transformer.h.57.mlp.dense_4h_to_h.weight": "pytorch_model-00017-of-00018.bin",
+    "transformer.h.57.mlp.dense_h_to_4h.weight": "pytorch_model-00017-of-00018.bin",
+    "transformer.h.57.self_attention.dense.weight": "pytorch_model-00017-of-00018.bin",
+    "transformer.h.57.self_attention.query_key_value.weight": "pytorch_model-00017-of-00018.bin",
+    "transformer.h.58.ln_attn.bias": "pytorch_model-00017-of-00018.bin",
+    "transformer.h.58.ln_attn.weight": "pytorch_model-00017-of-00018.bin",
+    "transformer.h.58.ln_mlp.bias": "pytorch_model-00017-of-00018.bin",
+    "transformer.h.58.ln_mlp.weight": "pytorch_model-00017-of-00018.bin",
+    "transformer.h.58.mlp.dense_4h_to_h.weight": "pytorch_model-00018-of-00018.bin",
+    "transformer.h.58.mlp.dense_h_to_4h.weight": "pytorch_model-00017-of-00018.bin",
+    "transformer.h.58.self_attention.dense.weight": "pytorch_model-00017-of-00018.bin",
+    "transformer.h.58.self_attention.query_key_value.weight": "pytorch_model-00017-of-00018.bin",
+    "transformer.h.59.ln_attn.bias": "pytorch_model-00018-of-00018.bin",
+    "transformer.h.59.ln_attn.weight": "pytorch_model-00018-of-00018.bin",
+    "transformer.h.59.ln_mlp.bias": "pytorch_model-00018-of-00018.bin",
+    "transformer.h.59.ln_mlp.weight": "pytorch_model-00018-of-00018.bin",
+    "transformer.h.59.mlp.dense_4h_to_h.weight": "pytorch_model-00018-of-00018.bin",
+    "transformer.h.59.mlp.dense_h_to_4h.weight": "pytorch_model-00018-of-00018.bin",
+    "transformer.h.59.self_attention.dense.weight": "pytorch_model-00018-of-00018.bin",
+    "transformer.h.59.self_attention.query_key_value.weight": "pytorch_model-00018-of-00018.bin",
+    "transformer.h.6.ln_attn.bias": "pytorch_model-00002-of-00018.bin",
+    "transformer.h.6.ln_attn.weight": "pytorch_model-00002-of-00018.bin",
+    "transformer.h.6.ln_mlp.bias": "pytorch_model-00002-of-00018.bin",
+    "transformer.h.6.ln_mlp.weight": "pytorch_model-00002-of-00018.bin",
+    "transformer.h.6.mlp.dense_4h_to_h.weight": "pytorch_model-00003-of-00018.bin",
+    "transformer.h.6.mlp.dense_h_to_4h.weight": "pytorch_model-00003-of-00018.bin",
+    "transformer.h.6.self_attention.dense.weight": "pytorch_model-00002-of-00018.bin",
+    "transformer.h.6.self_attention.query_key_value.weight": "pytorch_model-00002-of-00018.bin",
+    "transformer.h.7.ln_attn.bias": "pytorch_model-00003-of-00018.bin",
+    "transformer.h.7.ln_attn.weight": "pytorch_model-00003-of-00018.bin",
+    "transformer.h.7.ln_mlp.bias": "pytorch_model-00003-of-00018.bin",
+    "transformer.h.7.ln_mlp.weight": "pytorch_model-00003-of-00018.bin",
+    "transformer.h.7.mlp.dense_4h_to_h.weight": "pytorch_model-00003-of-00018.bin",
+    "transformer.h.7.mlp.dense_h_to_4h.weight": "pytorch_model-00003-of-00018.bin",
+    "transformer.h.7.self_attention.dense.weight": "pytorch_model-00003-of-00018.bin",
+    "transformer.h.7.self_attention.query_key_value.weight": "pytorch_model-00003-of-00018.bin",
+    "transformer.h.8.ln_attn.bias": "pytorch_model-00003-of-00018.bin",
+    "transformer.h.8.ln_attn.weight": "pytorch_model-00003-of-00018.bin",
+    "transformer.h.8.ln_mlp.bias": "pytorch_model-00003-of-00018.bin",
+    "transformer.h.8.ln_mlp.weight": "pytorch_model-00003-of-00018.bin",
+    "transformer.h.8.mlp.dense_4h_to_h.weight": "pytorch_model-00003-of-00018.bin",
+    "transformer.h.8.mlp.dense_h_to_4h.weight": "pytorch_model-00003-of-00018.bin",
+    "transformer.h.8.self_attention.dense.weight": "pytorch_model-00003-of-00018.bin",
+    "transformer.h.8.self_attention.query_key_value.weight": "pytorch_model-00003-of-00018.bin",
+    "transformer.h.9.ln_attn.bias": "pytorch_model-00003-of-00018.bin",
+    "transformer.h.9.ln_attn.weight": "pytorch_model-00003-of-00018.bin",
+    "transformer.h.9.ln_mlp.bias": "pytorch_model-00003-of-00018.bin",
+    "transformer.h.9.ln_mlp.weight": "pytorch_model-00003-of-00018.bin",
+    "transformer.h.9.mlp.dense_4h_to_h.weight": "pytorch_model-00004-of-00018.bin",
+    "transformer.h.9.mlp.dense_h_to_4h.weight": "pytorch_model-00003-of-00018.bin",
+    "transformer.h.9.self_attention.dense.weight": "pytorch_model-00003-of-00018.bin",
+    "transformer.h.9.self_attention.query_key_value.weight": "pytorch_model-00003-of-00018.bin",
+    "transformer.ln_f.bias": "pytorch_model-00018-of-00018.bin",
+    "transformer.ln_f.weight": "pytorch_model-00018-of-00018.bin",
+    "transformer.word_embeddings.weight": "pytorch_model-00001-of-00018.bin"
+  }
+}

special_tokens_map.json

@@ -0,0 +1,17 @@
+{
+  "additional_special_tokens": [
+    ">>TITLE<<",
+    ">>ABSTRACT<<",
+    ">>INTRODUCTION<<",
+    ">>SUMMARY<<",
+    ">>COMMENT<<",
+    ">>ANSWER<<",
+    ">>QUESTION<<",
+    ">>DOMAIN<<",
+    ">>PREFIX<<",
+    ">>SUFFIX<<",
+    ">>MIDDLE<<"
+  ],
+  "eos_token": "<|endoftext|>",
+  "pad_token": "[PAD]"
+}

tokenizer_config.json

@@ -0,0 +1,8 @@
+{
+  "add_prefix_space": false,
+  "clean_up_tokenization_spaces": true,
+  "eos_token": "<|endoftext|>",
+  "model_max_length": 2048,
+  "padding_side": "right",
+  "tokenizer_class": "PreTrainedTokenizerFast"
+}

trainer_state.json

@@ -0,0 +1,658 @@
+{
+  "best_metric": null,
+  "best_model_checkpoint": null,
+  "epoch": 1.9930151338766007,
+  "global_step": 214,
+  "is_hyper_param_search": false,
+  "is_local_process_zero": true,
+  "is_world_process_zero": true,
+  "log_history": [
+    {
+      "epoch": 0.02,
+      "learning_rate": 2e-05,
+      "loss": 0.8616,
+      "step": 2
+    },
+    {
+      "epoch": 0.04,
+      "learning_rate": 1.9995608365087945e-05,
+      "loss": 0.7122,
+      "step": 4
+    },
+    {
+      "epoch": 0.06,
+      "learning_rate": 1.9982437317643218e-05,
+      "loss": 0.6609,
+      "step": 6
+    },
+    {
+      "epoch": 0.07,
+      "learning_rate": 1.996049842615217e-05,
+      "loss": 0.6289,
+      "step": 8
+    },
+    {
+      "epoch": 0.09,
+      "learning_rate": 1.992981096013517e-05,
+      "loss": 0.6091,
+      "step": 10
+    },
+    {
+      "epoch": 0.11,
+      "learning_rate": 1.9890401873221642e-05,
+      "loss": 0.5863,
+      "step": 12
+    },
+    {
+      "epoch": 0.13,
+      "learning_rate": 1.984230577947597e-05,
+      "loss": 0.5834,
+      "step": 14
+    },
+    {
+      "epoch": 0.15,
+      "learning_rate": 1.9785564922995042e-05,
+      "loss": 0.5628,
+      "step": 16
+    },
+    {
+      "epoch": 0.17,
+      "learning_rate": 1.972022914080411e-05,
+      "loss": 0.5446,
+      "step": 18
+    },
+    {
+      "epoch": 0.19,
+      "learning_rate": 1.964635581908359e-05,
+      "loss": 0.5434,
+      "step": 20
+    },
+    {
+      "epoch": 0.2,
+      "learning_rate": 1.9564009842765225e-05,
+      "loss": 0.5196,
+      "step": 22
+    },
+    {
+      "epoch": 0.22,
+      "learning_rate": 1.9473263538541916e-05,
+      "loss": 0.5292,
+      "step": 24
+    },
+    {
+      "epoch": 0.24,
+      "learning_rate": 1.9374196611341212e-05,
+      "loss": 0.5139,
+      "step": 26
+    },
+    {
+      "epoch": 0.26,
+      "learning_rate": 1.9266896074318335e-05,
+      "loss": 0.5088,
+      "step": 28
+    },
+    {
+      "epoch": 0.28,
+      "learning_rate": 1.9151456172430186e-05,
+      "loss": 0.5079,
+      "step": 30
+    },
+    {
+      "epoch": 0.3,
+      "learning_rate": 1.9027978299657436e-05,
+      "loss": 0.5086,
+      "step": 32
+    },
+    {
+      "epoch": 0.32,
+      "learning_rate": 1.8896570909947477e-05,
+      "loss": 0.5024,
+      "step": 34
+    },
+    {
+      "epoch": 0.34,
+      "learning_rate": 1.875734942195637e-05,
+      "loss": 0.5046,
+      "step": 36
+    },
+    {
+      "epoch": 0.35,
+      "learning_rate": 1.8610436117673557e-05,
+      "loss": 0.4777,
+      "step": 38
+    },
+    {
+      "epoch": 0.37,
+      "learning_rate": 1.845596003501826e-05,
+      "loss": 0.5006,
+      "step": 40
+    },
+    {
+      "epoch": 0.39,
+      "learning_rate": 1.829405685450202e-05,
+      "loss": 0.4796,
+      "step": 42
+    },
+    {
+      "epoch": 0.41,
+      "learning_rate": 1.8124868780056814e-05,
+      "loss": 0.4701,
+      "step": 44
+    },
+    {
+      "epoch": 0.43,
+      "learning_rate": 1.7948544414133534e-05,
+      "loss": 0.4784,
+      "step": 46
+    },
+    {
+      "epoch": 0.45,
+      "learning_rate": 1.7765238627180424e-05,
+      "loss": 0.4773,
+      "step": 48
+    },
+    {
+      "epoch": 0.47,
+      "learning_rate": 1.7575112421616203e-05,
+      "loss": 0.4783,
+      "step": 50
+    },
+    {
+      "epoch": 0.48,
+      "learning_rate": 1.7378332790417275e-05,
+      "loss": 0.4772,
+      "step": 52
+    },
+    {
+      "epoch": 0.5,
+      "learning_rate": 1.717507257044331e-05,
+      "loss": 0.4671,
+      "step": 54
+    },
+    {
+      "epoch": 0.52,
+      "learning_rate": 1.6965510290629973e-05,
+      "loss": 0.4716,
+      "step": 56
+    },
+    {
+      "epoch": 0.54,
+      "learning_rate": 1.6749830015182106e-05,
+      "loss": 0.4539,
+      "step": 58
+    },
+    {
+      "epoch": 0.56,
+      "learning_rate": 1.6528221181905217e-05,
+      "loss": 0.4613,
+      "step": 60
+    },
+    {
+      "epoch": 0.58,
+      "learning_rate": 1.6300878435817115e-05,
+      "loss": 0.4758,
+      "step": 62
+    },
+    {
+      "epoch": 0.6,
+      "learning_rate": 1.6068001458185934e-05,
+      "loss": 0.4623,
+      "step": 64
+    },
+    {
+      "epoch": 0.61,
+      "learning_rate": 1.5829794791144723e-05,
+      "loss": 0.4734,
+      "step": 66
+    },
+    {
+      "epoch": 0.63,
+      "learning_rate": 1.5586467658036526e-05,
+      "loss": 0.4512,
+      "step": 68
+    },
+    {
+      "epoch": 0.65,
+      "learning_rate": 1.533823377964791e-05,
+      "loss": 0.4713,
+      "step": 70
+    },
+    {
+      "epoch": 0.67,
+      "learning_rate": 1.5085311186492206e-05,
+      "loss": 0.4789,
+      "step": 72
+    },
+    {
+      "epoch": 0.69,
+      "learning_rate": 1.482792202730745e-05,
+      "loss": 0.5663,
+      "step": 74
+    },
+    {
+      "epoch": 0.71,
+      "learning_rate": 1.4566292373937133e-05,
+      "loss": 0.4551,
+      "step": 76
+    },
+    {
+      "epoch": 0.73,
+      "learning_rate": 1.4300652022765207e-05,
+      "loss": 0.461,
+      "step": 78
+    },
+    {
+      "epoch": 0.75,
+      "learning_rate": 1.4031234292879726e-05,
+      "loss": 0.4673,
+      "step": 80
+    },
+    {
+      "epoch": 0.76,
+      "learning_rate": 1.3758275821142382e-05,
+      "loss": 0.4589,
+      "step": 82
+    },
+    {
+      "epoch": 0.78,
+      "learning_rate": 1.348201635434399e-05,
+      "loss": 0.4495,
+      "step": 84
+    },
+    {
+      "epoch": 0.8,
+      "learning_rate": 1.3202698538628376e-05,
+      "loss": 0.4645,
+      "step": 86
+    },
+    {
+      "epoch": 0.82,
+      "learning_rate": 1.292056770636976e-05,
+      "loss": 0.4555,
+      "step": 88
+    },
+    {
+      "epoch": 0.84,
+      "learning_rate": 1.2635871660690677e-05,
+      "loss": 0.4464,
+      "step": 90
+    },
+    {
+      "epoch": 0.86,
+      "learning_rate": 1.234886045780984e-05,
+      "loss": 0.4646,
+      "step": 92
+    },
+    {
+      "epoch": 0.88,
+      "learning_rate": 1.2059786187410984e-05,
+      "loss": 0.4599,
+      "step": 94
+    },
+    {
+      "epoch": 0.89,
+      "learning_rate": 1.176890275122573e-05,
+      "loss": 0.4534,
+      "step": 96
+    },
+    {
+      "epoch": 0.91,
+      "learning_rate": 1.1476465640024814e-05,
+      "loss": 0.4744,
+      "step": 98
+    },
+    {
+      "epoch": 0.93,
+      "learning_rate": 1.1182731709213658e-05,
+      "loss": 0.4626,
+      "step": 100
+    },
+    {
+      "epoch": 0.95,
+      "learning_rate": 1.0887958953229349e-05,
+      "loss": 0.4407,
+      "step": 102
+    },
+    {
+      "epoch": 0.97,
+      "learning_rate": 1.0592406278937143e-05,
+      "loss": 0.452,
+      "step": 104
+    },
+    {
+      "epoch": 0.99,
+      "learning_rate": 1.0296333278225599e-05,
+      "loss": 0.4496,
+      "step": 106
+    },
+    {
+      "epoch": 1.01,
+      "learning_rate": 1e-05,
+      "loss": 0.4138,
+      "step": 108
+    },
+    {
+      "epoch": 1.02,
+      "learning_rate": 9.703666721774403e-06,
+      "loss": 0.2924,
+      "step": 110
+    },
+    {
+      "epoch": 1.04,
+      "learning_rate": 9.407593721062858e-06,
+      "loss": 0.3184,
+      "step": 112
+    },
+    {
+      "epoch": 1.06,
+      "learning_rate": 9.112041046770653e-06,
+      "loss": 0.2885,
+      "step": 114
+    },
+    {
+      "epoch": 1.08,
+      "learning_rate": 8.817268290786343e-06,
+      "loss": 0.2842,
+      "step": 116
+    },
+    {
+      "epoch": 1.1,
+      "learning_rate": 8.52353435997519e-06,
+      "loss": 0.2763,
+      "step": 118
+    },
+    {
+      "epoch": 1.12,
+      "learning_rate": 8.231097248774273e-06,
+      "loss": 0.2765,
+      "step": 120
+    },
+    {
+      "epoch": 1.14,
+      "learning_rate": 7.940213812589018e-06,
+      "loss": 0.2788,
+      "step": 122
+    },
+    {
+      "epoch": 1.15,
+      "learning_rate": 7.651139542190164e-06,
+      "loss": 0.2821,
+      "step": 124
+    },
+    {
+      "epoch": 1.17,
+      "learning_rate": 7.364128339309326e-06,
+      "loss": 0.2834,
+      "step": 126
+    },
+    {
+      "epoch": 1.19,
+      "learning_rate": 7.079432293630244e-06,
+      "loss": 0.2728,
+      "step": 128
+    },
+    {
+      "epoch": 1.21,
+      "learning_rate": 6.797301461371626e-06,
+      "loss": 0.274,
+      "step": 130
+    },
+    {
+      "epoch": 1.23,
+      "learning_rate": 6.517983645656014e-06,
+      "loss": 0.276,
+      "step": 132
+    },
+    {
+      "epoch": 1.25,
+      "learning_rate": 6.241724178857621e-06,
+      "loss": 0.2723,
+      "step": 134
+    },
+    {
+      "epoch": 1.27,
+      "learning_rate": 5.96876570712028e-06,
+      "loss": 0.2876,
+      "step": 136
+    },
+    {
+      "epoch": 1.29,
+      "learning_rate": 5.699347977234799e-06,
+      "loss": 0.2714,
+      "step": 138
+    },
+    {
+      "epoch": 1.3,
+      "learning_rate": 5.43370762606287e-06,
+      "loss": 0.2758,
+      "step": 140
+    },
+    {
+      "epoch": 1.32,
+      "learning_rate": 5.172077972692553e-06,
+      "loss": 0.2816,
+      "step": 142
+    },
+    {
+      "epoch": 1.34,
+      "learning_rate": 4.914688813507798e-06,
+      "loss": 0.2787,
+      "step": 144
+    },
+    {
+      "epoch": 1.36,
+      "learning_rate": 4.661766220352098e-06,
+      "loss": 0.2801,
+      "step": 146
+    },
+    {
+      "epoch": 1.38,
+      "learning_rate": 4.413532341963477e-06,
+      "loss": 0.271,
+      "step": 148
+    },
+    {
+      "epoch": 1.4,
+      "learning_rate": 4.170205208855281e-06,
+      "loss": 0.2708,
+      "step": 150
+    },
+    {
+      "epoch": 1.42,
+      "learning_rate": 3.931998541814069e-06,
+      "loss": 0.2728,
+      "step": 152
+    },
+    {
+      "epoch": 1.43,
+      "learning_rate": 3.6991215641828903e-06,
+      "loss": 0.2719,
+      "step": 154
+    },
+    {
+      "epoch": 1.45,
+      "learning_rate": 3.4717788180947855e-06,
+      "loss": 0.272,
+      "step": 156
+    },
+    {
+      "epoch": 1.47,
+      "learning_rate": 3.250169984817897e-06,
+      "loss": 0.2724,
+      "step": 158
+    },
+    {
+      "epoch": 1.49,
+      "learning_rate": 3.0344897093700333e-06,
+      "loss": 0.2744,
+      "step": 160
+    },
+    {
+      "epoch": 1.51,
+      "learning_rate": 2.8249274295566863e-06,
+      "loss": 0.2736,
+      "step": 162
+    },
+    {
+      "epoch": 1.53,
+      "learning_rate": 2.6216672095827267e-06,
+      "loss": 0.2681,
+      "step": 164
+    },
+    {
+      "epoch": 1.55,
+      "learning_rate": 2.424887578383799e-06,
+      "loss": 0.2703,
+      "step": 166
+    },
+    {
+      "epoch": 1.56,
+      "learning_rate": 2.234761372819577e-06,
+      "loss": 0.2649,
+      "step": 168
+    },
+    {
+      "epoch": 1.58,
+      "learning_rate": 2.0514555858664663e-06,
+      "loss": 0.2781,
+      "step": 170
+    },
+    {
+      "epoch": 1.6,
+      "learning_rate": 1.875131219943187e-06,
+      "loss": 0.2645,
+      "step": 172
+    },
+    {
+      "epoch": 1.62,
+      "learning_rate": 1.7059431454979825e-06,
+      "loss": 0.27,
+      "step": 174
+    },
+    {
+      "epoch": 1.64,
+      "learning_rate": 1.5440399649817384e-06,
+      "loss": 0.2683,
+      "step": 176
+    },
+    {
+      "epoch": 1.66,
+      "learning_rate": 1.3895638823264447e-06,
+      "loss": 0.2645,
+      "step": 178
+    },
+    {
+      "epoch": 1.68,
+      "learning_rate": 1.2426505780436326e-06,
+      "loss": 0.2712,
+      "step": 180
+    },
+    {
+      "epoch": 1.69,
+      "learning_rate": 1.1034290900525279e-06,
+      "loss": 0.2621,
+      "step": 182
+    },
+    {
+      "epoch": 1.71,
+      "learning_rate": 9.720217003425648e-07,
+      "loss": 0.268,
+      "step": 184
+    },
+    {
+      "epoch": 1.73,
+      "learning_rate": 8.485438275698154e-07,
+      "loss": 0.2641,
+      "step": 186
+    },
+    {
+      "epoch": 1.75,
+      "learning_rate": 7.331039256816664e-07,
+      "loss": 0.2623,
+      "step": 188
+    },
+    {
+      "epoch": 1.77,
+      "learning_rate": 6.258033886587911e-07,
+      "loss": 0.2714,
+      "step": 190
+    },
+    {
+      "epoch": 1.79,
+      "learning_rate": 5.267364614580861e-07,
+      "loss": 0.2723,
+      "step": 192
+    },
+    {
+      "epoch": 1.81,
+      "learning_rate": 4.359901572347758e-07,
+      "loss": 0.2611,
+      "step": 194
+    },
+    {
+      "epoch": 1.83,
+      "learning_rate": 3.5364418091641374e-07,
+      "loss": 0.2724,
+      "step": 196
+    },
+    {
+      "epoch": 1.84,
+      "learning_rate": 2.7977085919589253e-07,
+      "loss": 0.2738,
+      "step": 198
+    },
+    {
+      "epoch": 1.86,
+      "learning_rate": 2.1443507700495968e-07,
+      "loss": 0.2623,
+      "step": 200
+    },
+    {
+      "epoch": 1.88,
+      "learning_rate": 1.5769422052403172e-07,
+      "loss": 0.2695,
+      "step": 202
+    },
+    {
+      "epoch": 1.9,
+      "learning_rate": 1.0959812677835968e-07,
+      "loss": 0.2661,
+      "step": 204
+    },
+    {
+      "epoch": 1.92,
+      "learning_rate": 7.018903986483083e-08,
+      "loss": 0.2712,
+      "step": 206
+    },
+    {
+      "epoch": 1.94,
+      "learning_rate": 3.950157384783104e-08,
+      "loss": 0.2706,
+      "step": 208
+    },
+    {
+      "epoch": 1.96,
+      "learning_rate": 1.7562682356786488e-08,
+      "loss": 0.276,
+      "step": 210
+    },
+    {
+      "epoch": 1.97,
+      "learning_rate": 4.39163491205652e-09,
+      "loss": 0.2767,
+      "step": 212
+    },
+    {
+      "epoch": 1.99,
+      "learning_rate": 0.0,
+      "loss": 0.2624,
+      "step": 214
+    }
+  ],
+  "max_steps": 214,
+  "num_train_epochs": 2,
+  "total_flos": 1536113535614976.0,
+  "trial_name": null,
+  "trial_params": null
+}

training_args.bin

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

zero_to_fp32.py

@@ -0,0 +1,584 @@
+#!/usr/bin/env python
+
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+# This script extracts fp32 consolidated weights from a zero 2 and 3 DeepSpeed checkpoints. It gets
+# copied into the top level checkpoint dir, so the user can easily do the conversion at any point in
+# the future. Once extracted, the weights don't require DeepSpeed and can be used in any
+# application.
+#
+# example: python zero_to_fp32.py . pytorch_model.bin
+
+import argparse
+import torch
+import glob
+import math
+import os
+import re
+from collections import OrderedDict
+from dataclasses import dataclass
+
+# while this script doesn't use deepspeed to recover data, since the checkpoints are pickled with
+# DeepSpeed data structures it has to be available in the current python environment.
+from deepspeed.utils import logger
+from deepspeed.checkpoint.constants import (DS_VERSION, OPTIMIZER_STATE_DICT, SINGLE_PARTITION_OF_FP32_GROUPS,
+                                            FP32_FLAT_GROUPS, ZERO_STAGE, PARTITION_COUNT, PARAM_SHAPES, BUFFER_NAMES,
+                                            FROZEN_PARAM_SHAPES, FROZEN_PARAM_FRAGMENTS)
+
+
+@dataclass
+class zero_model_state:
+    buffers: dict()
+    param_shapes: dict()
+    shared_params: list
+    ds_version: int
+    frozen_param_shapes: dict()
+    frozen_param_fragments: dict()
+
+
+debug = 0
+
+# load to cpu
+device = torch.device('cpu')
+
+
+def atoi(text):
+    return int(text) if text.isdigit() else text
+
+
+def natural_keys(text):
+    '''
+    alist.sort(key=natural_keys) sorts in human order
+    http://nedbatchelder.com/blog/200712/human_sorting.html
+    (See Toothy's implementation in the comments)
+    '''
+    return [atoi(c) for c in re.split(r'(\d+)', text)]
+
+
+def get_model_state_file(checkpoint_dir, zero_stage):
+    if not os.path.isdir(checkpoint_dir):
+        raise FileNotFoundError(f"Directory '{checkpoint_dir}' doesn't exist")
+
+    # there should be only one file
+    if zero_stage == 2:
+        file = os.path.join(checkpoint_dir, "mp_rank_00_model_states.pt")
+    elif zero_stage == 3:
+        file = os.path.join(checkpoint_dir, "zero_pp_rank_0_mp_rank_00_model_states.pt")
+
+    if not os.path.exists(file):
+        raise FileNotFoundError(f"can't find model states file at '{file}'")
+
+    return file
+
+
+def get_checkpoint_files(checkpoint_dir, glob_pattern):
+    # XXX: need to test that this simple glob rule works for multi-node setup too
+    ckpt_files = sorted(glob.glob(os.path.join(checkpoint_dir, glob_pattern)), key=natural_keys)
+
+    if len(ckpt_files) == 0:
+        raise FileNotFoundError(f"can't find {glob_pattern} files in directory '{checkpoint_dir}'")
+
+    return ckpt_files
+
+
+def get_optim_files(checkpoint_dir):
+    return get_checkpoint_files(checkpoint_dir, "*_optim_states.pt")
+
+
+def get_model_state_files(checkpoint_dir):
+    return get_checkpoint_files(checkpoint_dir, "*_model_states.pt")
+
+
+def parse_model_states(files):
+    zero_model_states = []
+    for file in files:
+        state_dict = torch.load(file, map_location=device)
+
+        if BUFFER_NAMES not in state_dict:
+            raise ValueError(f"{file} is not a model state checkpoint")
+        buffer_names = state_dict[BUFFER_NAMES]
+        if debug:
+            print("Found buffers:", buffer_names)
+
+        # recover just the buffers while restoring them to fp32 if they were saved in fp16
+        buffers = {k: v.float() for k, v in state_dict["module"].items() if k in buffer_names}
+        param_shapes = state_dict[PARAM_SHAPES]
+
+        # collect parameters that are included in param_shapes
+        param_names = []
+        for s in param_shapes:
+            for name in s.keys():
+                param_names.append(name)
+
+        # update with frozen parameters
+        frozen_param_shapes = state_dict.get(FROZEN_PARAM_SHAPES, None)
+        if frozen_param_shapes is not None:
+            if debug:
+                print(f"Found frozen_param_shapes: {frozen_param_shapes}")
+            param_names += list(frozen_param_shapes.keys())
+
+        # record shared parameters so that they can be recovered based on partners
+        # this is because such parameters holding reference only are not saved by optimizer
+        shared_params = []
+        for param in state_dict["module"]:
+            if param not in [*param_names, *buffer_names]:
+                for share_param in state_dict["module"]:
+                    if (state_dict["module"][share_param].data_ptr() == state_dict["module"][param].data_ptr()
+                            and share_param != param):
+                        shared_params.append([param, share_param])
+                        break
+
+        ds_version = state_dict.get(DS_VERSION, None)
+
+        frozen_param_fragments = state_dict.get(FROZEN_PARAM_FRAGMENTS, None)
+
+        z_model_state = zero_model_state(buffers=buffers,
+                                         param_shapes=param_shapes,
+                                         shared_params=shared_params,
+                                         ds_version=ds_version,
+                                         frozen_param_shapes=frozen_param_shapes,
+                                         frozen_param_fragments=frozen_param_fragments)
+        zero_model_states.append(z_model_state)
+
+    return zero_model_states
+
+
+def parse_optim_states(files, ds_checkpoint_dir):
+
+    total_files = len(files)
+    state_dicts = []
+    for f in files:
+        state_dicts.append(torch.load(f, map_location=device))
+
+    if not ZERO_STAGE in state_dicts[0][OPTIMIZER_STATE_DICT]:
+        raise ValueError(f"{files[0]} is not a zero checkpoint")
+    zero_stage = state_dicts[0][OPTIMIZER_STATE_DICT][ZERO_STAGE]
+    world_size = state_dicts[0][OPTIMIZER_STATE_DICT][PARTITION_COUNT]
+
+    # For ZeRO-2 each param group can have different partition_count as data parallelism for expert
+    # parameters can be different from data parallelism for non-expert parameters. So we can just
+    # use the max of the partition_count to get the dp world_size.
+
+    if type(world_size) is list:
+        world_size = max(world_size)
+
+    if world_size != total_files:
+        raise ValueError(
+            f"Expected {world_size} of '*_optim_states.pt' under '{ds_checkpoint_dir}' but found {total_files} files. "
+            "Possibly due to an overwrite of an old checkpoint, or a checkpoint didn't get saved by one or more processes."
+        )
+
+    # the groups are named differently in each stage
+    if zero_stage == 2:
+        fp32_groups_key = SINGLE_PARTITION_OF_FP32_GROUPS
+    elif zero_stage == 3:
+        fp32_groups_key = FP32_FLAT_GROUPS
+    else:
+        raise ValueError(f"unknown zero stage {zero_stage}")
+
+    if zero_stage == 2:
+        fp32_flat_groups = [state_dicts[i][OPTIMIZER_STATE_DICT][fp32_groups_key] for i in range(len(state_dicts))]
+    elif zero_stage == 3:
+        # if there is more than one param group, there will be multiple flattened tensors - one
+        # flattened tensor per group - for simplicity merge them into a single tensor
+        #
+        # XXX: could make the script more memory efficient for when there are multiple groups - it
+        # will require matching the sub-lists of param_shapes for each param group flattened tensor
+
+        fp32_flat_groups = [
+            torch.cat(state_dicts[i][OPTIMIZER_STATE_DICT][fp32_groups_key], 0) for i in range(len(state_dicts))
+        ]
+
+    return zero_stage, world_size, fp32_flat_groups
+
+
+def _get_fp32_state_dict_from_zero_checkpoint(ds_checkpoint_dir):
+    """
+    Returns fp32 state_dict reconstructed from ds checkpoint
+
+    Args:
+        - ``ds_checkpoint_dir``: path to the deepspeed checkpoint folder (where the optimizer files are)
+
+    """
+    print(f"Processing zero checkpoint '{ds_checkpoint_dir}'")
+
+    optim_files = get_optim_files(ds_checkpoint_dir)
+    zero_stage, world_size, fp32_flat_groups = parse_optim_states(optim_files, ds_checkpoint_dir)
+    print(f"Detected checkpoint of type zero stage {zero_stage}, world_size: {world_size}")
+
+    model_files = get_model_state_files(ds_checkpoint_dir)
+
+    zero_model_states = parse_model_states(model_files)
+    print(f'Parsing checkpoint created by deepspeed=={zero_model_states[0].ds_version}')
+
+    if zero_stage == 2:
+        return _get_fp32_state_dict_from_zero2_checkpoint(world_size, fp32_flat_groups, zero_model_states)
+    elif zero_stage == 3:
+        return _get_fp32_state_dict_from_zero3_checkpoint(world_size, fp32_flat_groups, zero_model_states)
+
+
+def _zero2_merge_frozen_params(state_dict, zero_model_states):
+    if zero_model_states[0].frozen_param_shapes is None or len(zero_model_states[0].frozen_param_shapes) == 0:
+        return
+
+    frozen_param_shapes = zero_model_states[0].frozen_param_shapes
+    frozen_param_fragments = zero_model_states[0].frozen_param_fragments
+
+    if debug:
+        num_elem = sum(s.numel() for s in frozen_param_shapes.values())
+        print(f'rank 0: {FROZEN_PARAM_SHAPES}.numel = {num_elem}')
+
+        wanted_params = len(frozen_param_shapes)
+        wanted_numel = sum(s.numel() for s in frozen_param_shapes.values())
+        avail_numel = sum([p.numel() for p in frozen_param_fragments.values()])
+        print(f'Frozen params: Have {avail_numel} numels to process.')
+        print(f'Frozen params: Need {wanted_numel} numels in {wanted_params} params')
+
+    total_params = 0
+    total_numel = 0
+    for name, shape in frozen_param_shapes.items():
+        total_params += 1
+        unpartitioned_numel = shape.numel()
+        total_numel += unpartitioned_numel
+
+        state_dict[name] = frozen_param_fragments[name]
+
+        if debug:
+            print(f"{name} full shape: {shape} unpartitioned numel {unpartitioned_numel} ")
+
+    print(f"Reconstructed Frozen fp32 state dict with {total_params} params {total_numel} elements")
+
+
+def _zero2_merge_trainable_params(state_dict, world_size, fp32_flat_groups, zero_model_states):
+    param_shapes = zero_model_states[0].param_shapes
+
+    # Reconstruction protocol:
+    #
+    # XXX: document this
+
+    if debug:
+        for i in range(world_size):
+            for j in range(len(fp32_flat_groups[0])):
+                print(f"{FP32_FLAT_GROUPS}[{i}][{j}].shape={fp32_flat_groups[i][j].shape}")
+
+    # XXX: memory usage doubles here (zero2)
+    num_param_groups = len(fp32_flat_groups[0])
+    merged_single_partition_of_fp32_groups = []
+    for i in range(num_param_groups):
+        merged_partitions = [sd[i] for sd in fp32_flat_groups]
+        full_single_fp32_vector = torch.cat(merged_partitions, 0)
+        merged_single_partition_of_fp32_groups.append(full_single_fp32_vector)
+    avail_numel = sum(
+        [full_single_fp32_vector.numel() for full_single_fp32_vector in merged_single_partition_of_fp32_groups])
+
+    if debug:
+        wanted_params = sum([len(shapes) for shapes in param_shapes])
+        wanted_numel = sum([sum(shape.numel() for shape in shapes.values()) for shapes in param_shapes])
+        # not asserting if there is a mismatch due to possible padding
+        print(f"Have {avail_numel} numels to process.")
+        print(f"Need {wanted_numel} numels in {wanted_params} params.")
+
+    # params
+    # XXX: for huge models that can't fit into the host's RAM we will have to recode this to support
+    # out-of-core computing solution
+    total_numel = 0
+    total_params = 0
+    for shapes, full_single_fp32_vector in zip(param_shapes, merged_single_partition_of_fp32_groups):
+        offset = 0
+        avail_numel = full_single_fp32_vector.numel()
+        for name, shape in shapes.items():
+
+            unpartitioned_numel = shape.numel()
+            total_numel += unpartitioned_numel
+            total_params += 1
+
+            if debug:
+                print(f"{name} full shape: {shape} unpartitioned numel {unpartitioned_numel} ")
+            state_dict[name] = full_single_fp32_vector.narrow(0, offset, unpartitioned_numel).view(shape)
+            offset += unpartitioned_numel
+
+        # Z2 started to align to 2*world_size to improve nccl performance. Therefore both offset and
+        # avail_numel can differ by anywhere between 0..2*world_size. Due to two unrelated complex
+        # paddings performed in the code it's almost impossible to predict the exact numbers w/o the
+        # live optimizer object, so we are checking that the numbers are within the right range
+        align_to = 2 * world_size
+
+        def zero2_align(x):
+            return align_to * math.ceil(x / align_to)
+
+        if debug:
+            print(f"original offset={offset}, avail_numel={avail_numel}")
+
+        offset = zero2_align(offset)
+        avail_numel = zero2_align(avail_numel)
+
+        if debug:
+            print(f"aligned  offset={offset}, avail_numel={avail_numel}")
+
+        # Sanity check
+        if offset != avail_numel:
+            raise ValueError(f"consumed {offset} numels out of {avail_numel} - something is wrong")
+
+    print(f"Reconstructed fp32 state dict with {total_params} params {total_numel} elements")
+
+
+def _get_fp32_state_dict_from_zero2_checkpoint(world_size, fp32_flat_groups, zero_model_states):
+    state_dict = OrderedDict()
+
+    # buffers
+    buffers = zero_model_states[0].buffers
+    state_dict.update(buffers)
+    if debug:
+        print(f"added {len(buffers)} buffers")
+
+    _zero2_merge_frozen_params(state_dict, zero_model_states)
+
+    _zero2_merge_trainable_params(state_dict, world_size, fp32_flat_groups, zero_model_states)
+
+    # recover shared parameters
+    for pair in zero_model_states[0].shared_params:
+        state_dict[pair[0]] = state_dict[pair[1]]
+
+    return state_dict
+
+
+def zero3_partitioned_param_info(unpartitioned_numel, world_size):
+    remainder = unpartitioned_numel % world_size
+    padding_numel = (world_size - remainder) if remainder else 0
+    partitioned_numel = math.ceil(unpartitioned_numel / world_size)
+    return partitioned_numel, padding_numel
+
+
+def _zero3_merge_frozen_params(state_dict, world_size, zero_model_states):
+    if zero_model_states[0].frozen_param_shapes is None or len(zero_model_states[0].frozen_param_shapes) == 0:
+        return
+
+    if debug:
+        for i in range(world_size):
+            num_elem = sum(s.numel() for s in zero_model_states[i].frozen_param_fragments.values())
+            print(f'rank {i}: {FROZEN_PARAM_SHAPES}.numel = {num_elem}')
+
+        frozen_param_shapes = zero_model_states[0].frozen_param_shapes
+        wanted_params = len(frozen_param_shapes)
+        wanted_numel = sum(s.numel() for s in frozen_param_shapes.values())
+        avail_numel = sum([p.numel() for p in zero_model_states[0].frozen_param_fragments.values()]) * world_size
+        print(f'Frozen params: Have {avail_numel} numels to process.')
+        print(f'Frozen params: Need {wanted_numel} numels in {wanted_params} params')
+
+    total_params = 0
+    total_numel = 0
+    for name, shape in zero_model_states[0].frozen_param_shapes.items():
+        total_params += 1
+        unpartitioned_numel = shape.numel()
+        total_numel += unpartitioned_numel
+
+        param_frags = tuple(model_state.frozen_param_fragments[name] for model_state in zero_model_states)
+        state_dict[name] = torch.cat(param_frags, 0).narrow(0, 0, unpartitioned_numel).view(shape)
+
+        partitioned_numel, partitioned_padding_numel = zero3_partitioned_param_info(unpartitioned_numel, world_size)
+
+        if debug:
+            print(
+                f"Frozen params: {total_params} {name} full shape: {shape} partition0 numel={partitioned_numel} partitioned_padding_numel={partitioned_padding_numel}"
+            )
+
+    print(f"Reconstructed Frozen fp32 state dict with {total_params} params {total_numel} elements")
+
+
+def _zero3_merge_trainable_params(state_dict, world_size, fp32_flat_groups, zero_model_states):
+    param_shapes = zero_model_states[0].param_shapes
+    avail_numel = fp32_flat_groups[0].numel() * world_size
+    # Reconstruction protocol: For zero3 we need to zip the partitions together at boundary of each
+    # param, re-consolidating each param, while dealing with padding if any
+
+    # merge list of dicts, preserving order
+    param_shapes = {k: v for d in param_shapes for k, v in d.items()}
+
+    if debug:
+        for i in range(world_size):
+            print(f"{FP32_FLAT_GROUPS}[{i}].shape={fp32_flat_groups[i].shape}")
+
+        wanted_params = len(param_shapes)
+        wanted_numel = sum(shape.numel() for shape in param_shapes.values())
+        # not asserting if there is a mismatch due to possible padding
+        avail_numel = fp32_flat_groups[0].numel() * world_size
+        print(f"Trainable params: Have {avail_numel} numels to process.")
+        print(f"Trainable params: Need {wanted_numel} numels in {wanted_params} params.")
+
+    # params
+    # XXX: for huge models that can't fit into the host's RAM we will have to recode this to support
+    # out-of-core computing solution
+    offset = 0
+    total_numel = 0
+    total_params = 0
+    for name, shape in param_shapes.items():
+
+        unpartitioned_numel = shape.numel()
+        total_numel += unpartitioned_numel
+        total_params += 1
+
+        partitioned_numel, partitioned_padding_numel = zero3_partitioned_param_info(unpartitioned_numel, world_size)
+
+        if debug:
+            print(
+                f"Trainable params: {total_params} {name} full shape: {shape} partition0 numel={partitioned_numel} partitioned_padding_numel={partitioned_padding_numel}"
+            )
+
+        # XXX: memory usage doubles here
+        state_dict[name] = torch.cat(
+            tuple(fp32_flat_groups[i].narrow(0, offset, partitioned_numel) for i in range(world_size)),
+            0).narrow(0, 0, unpartitioned_numel).view(shape)
+        offset += partitioned_numel
+
+    offset *= world_size
+
+    # Sanity check
+    if offset != avail_numel:
+        raise ValueError(f"consumed {offset} numels out of {avail_numel} - something is wrong")
+
+    print(f"Reconstructed Trainable fp32 state dict with {total_params} params {total_numel} elements")
+
+
+def _get_fp32_state_dict_from_zero3_checkpoint(world_size, fp32_flat_groups, zero_model_states):
+    state_dict = OrderedDict()
+
+    # buffers
+    buffers = zero_model_states[0].buffers
+    state_dict.update(buffers)
+    if debug:
+        print(f"added {len(buffers)} buffers")
+
+    _zero3_merge_frozen_params(state_dict, world_size, zero_model_states)
+
+    _zero3_merge_trainable_params(state_dict, world_size, fp32_flat_groups, zero_model_states)
+
+    # recover shared parameters
+    for pair in zero_model_states[0].shared_params:
+        state_dict[pair[0]] = state_dict[pair[1]]
+
+    return state_dict
+
+
+def get_fp32_state_dict_from_zero_checkpoint(checkpoint_dir, tag=None):
+    """
+    Convert ZeRO 2 or 3 checkpoint into a single fp32 consolidated state_dict that can be loaded with
+    ``load_state_dict()`` and used for training without DeepSpeed or shared with others, for example
+    via a model hub.
+
+    Args:
+        - ``checkpoint_dir``: path to the desired checkpoint folder
+        - ``tag``: checkpoint tag used as a unique identifier for checkpoint. If not provided will attempt to load tag in 'latest' file. e.g., ``global_step14``
+
+    Returns:
+        - pytorch ``state_dict``
+
+    Note: this approach may not work if your application doesn't have sufficient free CPU memory and
+    you may need to use the offline approach using the ``zero_to_fp32.py`` script that is saved with
+    the checkpoint.
+
+    A typical usage might be ::
+
+        from deepspeed.utils.zero_to_fp32 import get_fp32_state_dict_from_zero_checkpoint
+        # do the training and checkpoint saving
+        state_dict = get_fp32_state_dict_from_zero_checkpoint(checkpoint_dir) # already on cpu
+        model = model.cpu() # move to cpu
+        model.load_state_dict(state_dict)
+        # submit to model hub or save the model to share with others
+
+    In this example the ``model`` will no longer be usable in the deepspeed context of the same
+    application. i.e. you will need to re-initialize the deepspeed engine, since
+    ``model.load_state_dict(state_dict)`` will remove all the deepspeed magic from it.
+
+    If you want it all done for you, use ``load_state_dict_from_zero_checkpoint`` instead.
+
+    """
+    if tag is None:
+        latest_path = os.path.join(checkpoint_dir, 'latest')
+        if os.path.isfile(latest_path):
+            with open(latest_path, 'r') as fd:
+                tag = fd.read().strip()
+        else:
+            raise ValueError(f"Unable to find 'latest' file at {latest_path}")
+
+    ds_checkpoint_dir = os.path.join(checkpoint_dir, tag)
+
+    if not os.path.isdir(ds_checkpoint_dir):
+        raise FileNotFoundError(f"Directory '{ds_checkpoint_dir}' doesn't exist")
+
+    return _get_fp32_state_dict_from_zero_checkpoint(ds_checkpoint_dir)
+
+
+def convert_zero_checkpoint_to_fp32_state_dict(checkpoint_dir, output_file, tag=None):
+    """
+    Convert ZeRO 2 or 3 checkpoint into a single fp32 consolidated ``state_dict`` file that can be
+    loaded with ``torch.load(file)`` + ``load_state_dict()`` and used for training without DeepSpeed.
+
+    Args:
+        - ``checkpoint_dir``: path to the desired checkpoint folder. (one that contains the tag-folder, like ``global_step14``)
+        - ``output_file``: path to the pytorch fp32 state_dict output file (e.g. path/pytorch_model.bin)
+        - ``tag``: checkpoint tag used as a unique identifier for checkpoint. If not provided will attempt to load tag in the file named ``latest`` in the checkpoint folder, e.g., ``global_step14``
+    """
+
+    state_dict = get_fp32_state_dict_from_zero_checkpoint(checkpoint_dir, tag)
+    print(f"Saving fp32 state dict to {output_file}")
+    torch.save(state_dict, output_file)
+
+
+def load_state_dict_from_zero_checkpoint(model, checkpoint_dir, tag=None):
+    """
+    1. Put the provided model to cpu
+    2. Convert ZeRO 2 or 3 checkpoint into a single fp32 consolidated ``state_dict``
+    3. Load it into the provided model
+
+    Args:
+        - ``model``: the model object to update
+        - ``checkpoint_dir``: path to the desired checkpoint folder. (one that contains the tag-folder, like ``global_step14``)
+        - ``tag``: checkpoint tag used as a unique identifier for checkpoint. If not provided will attempt to load tag in the file named ``latest`` in the checkpoint folder, e.g., ``global_step14``
+
+    Returns:
+        - ``model`: modified model
+
+    Make sure you have plenty of CPU memory available before you call this function. If you don't
+    have enough use the ``zero_to_fp32.py`` utility to do the conversion. You will find it
+    conveniently placed for you in the checkpoint folder.
+
+    A typical usage might be ::
+
+        from deepspeed.utils.zero_to_fp32 import load_state_dict_from_zero_checkpoint
+        model = load_state_dict_from_zero_checkpoint(trainer.model, checkpoint_dir)
+        # submit to model hub or save the model to share with others
+
+    Note, that once this was run, the ``model`` will no longer be usable in the deepspeed context
+    of the same application. i.e. you will need to re-initialize the deepspeed engine, since
+    ``model.load_state_dict(state_dict)`` will remove all the deepspeed magic from it.
+
+    """
+    logger.info(f"Extracting fp32 weights")
+    state_dict = get_fp32_state_dict_from_zero_checkpoint(checkpoint_dir, tag)
+
+    logger.info(f"Overwriting model with fp32 weights")
+    model = model.cpu()
+    model.load_state_dict(state_dict, strict=False)
+
+    return model
+
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("checkpoint_dir",
+                        type=str,
+                        help="path to the desired checkpoint folder, e.g., path/checkpoint-12")
+    parser.add_argument(
+        "output_file",
+        type=str,
+        help="path to the pytorch fp32 state_dict output file (e.g. path/checkpoint-12/pytorch_model.bin)")
+    parser.add_argument("-d", "--debug", action='store_true', help="enable debug")
+    args = parser.parse_args()
+
+    debug = args.debug
+
+    convert_zero_checkpoint_to_fp32_state_dict(args.checkpoint_dir, args.output_file)