Model save

README.md

@@ -0,0 +1,98 @@
+---
+tags:
+- trl
+- sft
+- generated_from_trainer
+datasets:
+- generator
+model-index:
+- name: tinyllama_mole_sft_ultrachat_ep3
+  results: []
+---
+
+<!-- This model card has been generated automatically according to the information the Trainer had access to. You
+should probably proofread and complete it, then remove this comment. -->
+
+# tinyllama_mole_sft_ultrachat_ep3
+
+This model was trained from scratch on the generator dataset.
+It achieves the following results on the evaluation set:
+- Loss: 1.1127
+
+## Model description
+
+More information needed
+
+## Intended uses & limitations
+
+More information needed
+
+## Training and evaluation data
+
+More information needed
+
+## Training procedure
+
+### Training hyperparameters
+
+The following hyperparameters were used during training:
+- learning_rate: 2e-05
+- train_batch_size: 16
+- eval_batch_size: 8
+- seed: 42
+- distributed_type: multi-GPU
+- num_devices: 4
+- gradient_accumulation_steps: 2
+- total_train_batch_size: 128
+- total_eval_batch_size: 32
+- optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08
+- lr_scheduler_type: cosine
+- lr_scheduler_warmup_steps: 120
+- num_epochs: 3
+
+### Training results
+
+| Training Loss | Epoch | Step | Validation Loss |
+|:-------------:|:-----:|:----:|:---------------:|
+| 1.3007        | 0.09  | 100  | 1.2780          |
+| 1.2255        | 0.18  | 200  | 1.2158          |
+| 1.192         | 0.26  | 300  | 1.1921          |
+| 1.1696        | 0.35  | 400  | 1.1770          |
+| 1.1426        | 0.44  | 500  | 1.1666          |
+| 1.1628        | 0.53  | 600  | 1.1583          |
+| 1.1501        | 0.61  | 700  | 1.1513          |
+| 1.137         | 0.7   | 800  | 1.1457          |
+| 1.1321        | 0.79  | 900  | 1.1407          |
+| 1.1156        | 0.88  | 1000 | 1.1359          |
+| 1.1395        | 0.96  | 1100 | 1.1318          |
+| 1.0564        | 1.05  | 1200 | 1.1315          |
+| 1.0594        | 1.14  | 1300 | 1.1295          |
+| 1.0711        | 1.23  | 1400 | 1.1274          |
+| 1.0624        | 1.31  | 1500 | 1.1256          |
+| 1.0652        | 1.4   | 1600 | 1.1233          |
+| 1.0626        | 1.49  | 1700 | 1.1213          |
+| 1.0457        | 1.58  | 1800 | 1.1195          |
+| 1.0665        | 1.66  | 1900 | 1.1178          |
+| 1.07          | 1.75  | 2000 | 1.1158          |
+| 1.0567        | 1.84  | 2100 | 1.1141          |
+| 1.0304        | 1.93  | 2200 | 1.1127          |
+| 1.0132        | 2.01  | 2300 | 1.1170          |
+| 1.0203        | 2.1   | 2400 | 1.1170          |
+| 1.0088        | 2.19  | 2500 | 1.1168          |
+| 1.002         | 2.28  | 2600 | 1.1162          |
+| 1.0004        | 2.37  | 2700 | 1.1157          |
+| 1.0058        | 2.45  | 2800 | 1.1156          |
+| 1.0118        | 2.54  | 2900 | 1.1150          |
+| 0.9941        | 2.63  | 3000 | 1.1148          |
+| 1.0127        | 2.72  | 3100 | 1.1147          |
+| 1.0039        | 2.8   | 3200 | 1.1144          |
+| 1.0           | 2.89  | 3300 | 1.1143          |
+| 1.0188        | 2.98  | 3400 | 1.1143          |
+
+
+### Framework versions
+
+- Transformers 4.37.0
+- Pytorch 2.1.2+cu118
+- Datasets 2.16.1
+- Tokenizers 0.15.0

all_results.json

@@ -0,0 +1,13 @@
+{
+    "epoch": 3.0,
+    "eval_loss": 1.1127439737319946,
+    "eval_runtime": 425.9465,
+    "eval_samples": 23110,
+    "eval_samples_per_second": 37.953,
+    "eval_steps_per_second": 1.188,
+    "train_loss": 1.0902616986746403,
+    "train_runtime": 47329.7113,
+    "train_samples": 207865,
+    "train_samples_per_second": 9.258,
+    "train_steps_per_second": 0.072
+}

configuration_mixtral_mole.py

@@ -0,0 +1,176 @@
+# coding=utf-8
+# Copyright 2023 Mixtral AI and the 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.
+""" Mixtral model configuration"""
+
+from transformers.configuration_utils import PretrainedConfig
+from transformers.utils import logging
+
+
+logger = logging.get_logger(__name__)
+
+MIXTRAL_PRETRAINED_CONFIG_ARCHIVE_MAP = {
+    "mistral-ai/Mixtral-8x7B": "https://huggingface.co/mistral-ai/Mixtral-8x7B/resolve/main/config.json",
+}
+
+
+class MixtralMoleConfig(PretrainedConfig):
+    r"""
+    This is the configuration class to store the configuration of a [`MixtralMoleModel`]. It is used to instantiate an
+    Mixtral model according to the specified arguments, defining the model architecture. Instantiating a configuration
+    with the defaults will yield a similar configuration to that of the Mixtral-7B-v0.1 or Mixtral-7B-Instruct-v0.1.
+
+    [mixtralai/Mixtral-8x7B](https://huggingface.co/mixtralai/Mixtral-8x7B)
+    [mixtralai/Mixtral-7B-Instruct-v0.1](https://huggingface.co/mixtralai/Mixtral-7B-Instruct-v0.1)
+
+    Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
+    documentation from [`PretrainedConfig`] for more information.
+
+
+    Args:
+        vocab_size (`int`, *optional*, defaults to 32000):
+            Vocabulary size of the Mixtral model. Defines the number of different tokens that can be represented by the
+            `inputs_ids` passed when calling [`MixtralMoleModel`]
+        hidden_size (`int`, *optional*, defaults to 4096):
+            Dimension of the hidden representations.
+        intermediate_size (`int`, *optional*, defaults to 14336):
+            Dimension of the MLP representations.
+        num_hidden_layers (`int`, *optional*, defaults to 32):
+            Number of hidden layers in the Transformer encoder.
+        num_attention_heads (`int`, *optional*, defaults to 32):
+            Number of attention heads for each attention layer in the Transformer encoder.
+        num_key_value_heads (`int`, *optional*, defaults to 8):
+            This is the number of key_value heads that should be used to implement Grouped Query Attention. If
+            `num_key_value_heads=num_attention_heads`, the model will use Multi Head Attention (MHA), if
+            `num_key_value_heads=1 the model will use Multi Query Attention (MQA) otherwise GQA is used. When
+            converting a multi-head checkpoint to a GQA checkpoint, each group key and value head should be constructed
+            by meanpooling all the original heads within that group. For more details checkout [this
+            paper](https://arxiv.org/pdf/2305.13245.pdf). If it is not specified, will default to `8`.
+        hidden_act (`str` or `function`, *optional*, defaults to `"silu"`):
+            The non-linear activation function (function or string) in the decoder.
+        max_position_embeddings (`int`, *optional*, defaults to `4096*32`):
+            The maximum sequence length that this model might ever be used with. Mixtral's sliding window attention
+            allows sequence of up to 4096*32 tokens.
+        initializer_range (`float`, *optional*, defaults to 0.02):
+            The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
+        rms_norm_eps (`float`, *optional*, defaults to 1e-05):
+            The epsilon used by the rms normalization layers.
+        use_cache (`bool`, *optional*, defaults to `True`):
+            Whether or not the model should return the last key/values attentions (not used by all models). Only
+            relevant if `config.is_decoder=True`.
+        pad_token_id (`int`, *optional*):
+            The id of the padding token.
+        bos_token_id (`int`, *optional*, defaults to 1):
+            The id of the "beginning-of-sequence" token.
+        eos_token_id (`int`, *optional*, defaults to 2):
+            The id of the "end-of-sequence" token.
+        tie_word_embeddings (`bool`, *optional*, defaults to `False`):
+            Whether the model's input and output word embeddings should be tied.
+        rope_theta (`float`, *optional*, defaults to 1000000.0):
+            The base period of the RoPE embeddings.
+        sliding_window (`int`, *optional*):
+            Sliding window attention window size. If not specified, will default to `4096`.
+        attention_dropout (`float`, *optional*, defaults to 0.0):
+            The dropout ratio for the attention probabilities.
+        num_experts_per_tok (`int`, *optional*, defaults to 2):
+            The number of experts to root per-token, can be also interpreted as the `top-p` routing
+            parameter
+        num_local_experts (`int`, *optional*, defaults to 8):
+            Number of experts per Sparse MLP layer.
+        output_router_logits (`bool`, *optional*, defaults to `False`):
+            Whether or not the router logits should be returned by the model. Enabeling this will also
+            allow the model to output the auxiliary loss. See [here]() for more details
+        router_aux_loss_coef (`float`, *optional*, defaults to 0.001):
+            The aux loss factor for the total loss.
+
+    ```python
+    >>> from models import MixtralMoleModel, MixtralMoleConfig
+
+    >>> # Initializing a Mixtral 7B style configuration
+    >>> configuration = MixtralMoleConfig()
+
+    >>> # Initializing a model from the Mixtral 7B style configuration
+    >>> model = MixtralMoleModel(configuration)
+
+    >>> # Accessing the model configuration
+    >>> configuration = model.config
+    ```"""
+
+    model_type = "mixtralmole"
+    keys_to_ignore_at_inference = ["past_key_values"]
+
+    def __init__(
+        self,
+        vocab_size=32000,
+        hidden_size=4096,
+        intermediate_size=14336,
+        num_hidden_layers=32,
+        num_attention_heads=32,
+        num_key_value_heads=8,
+        hidden_act="silu",
+        max_position_embeddings=4096 * 32,
+        initializer_range=0.02,
+        rms_norm_eps=1e-5,
+        use_cache=True,
+        pad_token_id=None,
+        bos_token_id=1,
+        eos_token_id=2,
+        tie_word_embeddings=False,
+        rope_theta=1e6,
+        sliding_window=None,
+        attention_dropout=0.0,
+        num_experts_per_tok=2,
+        num_local_experts=8,
+        output_router_logits=False,
+        router_aux_loss_coef=0.001,
+        adapter_dim=16,
+        adapter_alpha=1.0,
+        **kwargs,
+    ):
+        self.vocab_size = vocab_size
+        self.max_position_embeddings = max_position_embeddings
+        self.hidden_size = hidden_size
+        self.intermediate_size = intermediate_size
+        self.num_hidden_layers = num_hidden_layers
+        self.num_attention_heads = num_attention_heads
+        self.sliding_window = sliding_window
+
+        # for backward compatibility
+        if num_key_value_heads is None:
+            num_key_value_heads = num_attention_heads
+
+        self.num_key_value_heads = num_key_value_heads
+        self.hidden_act = hidden_act
+        self.initializer_range = initializer_range
+        self.rms_norm_eps = rms_norm_eps
+        self.use_cache = use_cache
+        self.rope_theta = rope_theta
+        self.attention_dropout = attention_dropout
+
+        self.num_experts_per_tok = num_experts_per_tok
+        self.num_local_experts = num_local_experts
+        self.output_router_logits = output_router_logits
+        self.router_aux_loss_coef = router_aux_loss_coef
+
+        # lora
+        self.adapter_dim = adapter_dim
+        self.adapter_alpha = adapter_alpha
+
+        super().__init__(
+            pad_token_id=pad_token_id,
+            bos_token_id=bos_token_id,
+            eos_token_id=eos_token_id,
+            tie_word_embeddings=tie_word_embeddings,
+            **kwargs,
+        )

eval_results.json

@@ -0,0 +1,8 @@
+{
+    "epoch": 3.0,
+    "eval_loss": 1.1127439737319946,
+    "eval_runtime": 425.9465,
+    "eval_samples": 23110,
+    "eval_samples_per_second": 37.953,
+    "eval_steps_per_second": 1.188
+}

generation_config.json

@@ -0,0 +1,7 @@
+{
+  "_from_model_config": true,
+  "bos_token_id": 1,
+  "eos_token_id": 2,
+  "transformers_version": "4.37.0",
+  "use_cache": false
+}

model.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ebd53dc49f5adb8ac4399646b86bc0545c85876b50a4530926f6dbe4c6c18952
+oid sha256:9437ee9f304616df308df88427951ab973156df2ce1181c5c57d23dd955911b6
 size 2223960880

modeling_mixtral_mole.py

@@ -0,0 +1,960 @@
+# coding=utf-8
+# Copyright 2023 Mistral AI and the HuggingFace Inc. team. All rights reserved.
+#
+# This code is based on EleutherAI's GPT-NeoX library and the GPT-NeoX
+# and OPT implementations in this library. It has been modified from its
+# original forms to accommodate minor architectural differences compared
+# to GPT-NeoX and OPT used by the Meta AI team that trained the model.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""" PyTorch Mixtral Mole model."""
+import inspect
+import math
+import warnings
+from typing import List, Optional, Tuple, Union
+
+import torch
+import torch.nn.functional as F
+import torch.utils.checkpoint
+from torch import nn
+from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss
+
+from transformers.activations import ACT2FN
+from transformers.cache_utils import Cache, DynamicCache
+from transformers.modeling_attn_mask_utils import (
+    _prepare_4d_causal_attention_mask,
+    _prepare_4d_causal_attention_mask_for_sdpa,
+)
+from transformers.modeling_outputs import (
+    MoeCausalLMOutputWithPast,
+    MoeModelOutputWithPast,
+    SequenceClassifierOutputWithPast,
+)
+from transformers.modeling_utils import PreTrainedModel
+from transformers.pytorch_utils import is_torch_greater_or_equal_than_1_13
+from transformers.utils import (
+    add_start_docstrings,
+    add_start_docstrings_to_model_forward,
+    is_flash_attn_2_available,
+    is_flash_attn_greater_or_equal_2_10,
+    logging,
+    replace_return_docstrings,
+)
+from transformers.utils.import_utils import is_torch_fx_available
+from .configuration_mixtral_mole import MixtralMoleConfig
+
+from transformers.models.mixtral.modeling_mixtral import (
+    MixtralRMSNorm,
+    MixtralRotaryEmbedding,
+    MixtralAttention,
+    MixtralFlashAttention2,
+    MixtralSdpaAttention,
+)
+
+
+# This makes `_prepare_4d_causal_attention_mask` a leaf function in the FX graph.
+# It means that the function will not be traced through and simply appear as a node in the graph.
+if is_torch_fx_available():
+    if not is_torch_greater_or_equal_than_1_13:
+        import torch.fx
+
+    _prepare_4d_causal_attention_mask = torch.fx.wrap(_prepare_4d_causal_attention_mask)
+
+
+logger = logging.get_logger(__name__)
+
+_CONFIG_FOR_DOC = "MixtralMoleConfig"
+
+
+def load_balancing_loss_func(gate_logits: torch.Tensor, num_experts: torch.Tensor = None, top_k=2) -> float:
+    r"""
+    Computes auxiliary load balancing loss as in Switch Transformer - implemented in Pytorch.
+
+    See Switch Transformer (https://arxiv.org/abs/2101.03961) for more details. This function implements the loss
+    function presented in equations (4) - (6) of the paper. It aims at penalizing cases where the routing between
+    experts is too unbalanced.
+
+    Args:
+        gate_logits (Union[`torch.Tensor`, Tuple[torch.Tensor]):
+            Logits from the `gate`, should be a tuple of model.config.num_hidden_layers tensors of
+            shape [batch_size X sequence_length, num_experts].
+        num_experts (`int`, *optional*):
+            Number of experts
+
+    Returns:
+        The auxiliary loss.
+    """
+    if gate_logits is None or not isinstance(gate_logits, tuple):
+        return 0
+
+    if isinstance(gate_logits, tuple):
+        compute_device = gate_logits[0].device
+        concatenated_gate_logits = torch.cat([layer_gate.to(compute_device) for layer_gate in gate_logits], dim=0)
+
+    routing_weights = torch.nn.functional.softmax(concatenated_gate_logits, dim=-1)
+
+    _, selected_experts = torch.topk(routing_weights, top_k, dim=-1)
+
+    expert_mask = torch.nn.functional.one_hot(selected_experts, num_experts)
+
+    # Compute the percentage of tokens routed to each experts
+    tokens_per_expert = torch.mean(expert_mask.float(), dim=0)
+
+    # Compute the average probability of routing to these experts
+    router_prob_per_expert = torch.mean(routing_weights, dim=0)
+
+    overall_loss = torch.sum(tokens_per_expert * router_prob_per_expert.unsqueeze(0))
+    return overall_loss * num_experts
+
+
+MIXTRAL_ATTENTION_CLASSES = {
+    "eager": MixtralAttention,
+    "flash_attention_2": MixtralFlashAttention2,
+    "sdpa": MixtralSdpaAttention,
+}
+
+class LoRALayer(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.config = config
+        self.intermediate_size = config.intermediate_size
+        self.hidden_size = config.hidden_size
+        self.adapter_down = nn.Linear(self.hidden_size, config.adapter_dim, bias=False)
+        self.adapter_up = nn.Linear(config.adapter_dim, self.hidden_size, bias=False)
+        # self.adapter_act = nn.GELU()
+        self.adapter_act = nn.Identity() # Using LoRA not Parallel Adapter
+
+        self.adapter_dropout = nn.Dropout(p=0.01)
+        self.adapter_scaling = config.adapter_alpha / config.adapter_dim
+
+    def forward(self, x):
+        x = self.adapter_dropout(x)
+        x = self.adapter_scaling * self.adapter_up(self.adapter_act(self.adapter_down(x)))
+        return x
+
+
+class MixtralMoleBLockSparseTop2MLP(nn.Module):
+    def __init__(self, config: MixtralMoleConfig):
+        super().__init__()
+        self.ffn_dim = config.intermediate_size
+        self.hidden_dim = config.hidden_size
+
+        self.w1 = nn.Linear(self.hidden_dim, self.ffn_dim, bias=False)
+        self.w2 = nn.Linear(self.ffn_dim, self.hidden_dim, bias=False)
+        self.w3 = nn.Linear(self.hidden_dim, self.ffn_dim, bias=False)
+
+        self.act_fn = ACT2FN[config.hidden_act]
+
+    def forward(self, hidden_states):
+        current_hidden_states = self.act_fn(self.w1(hidden_states)) * self.w3(hidden_states)
+        current_hidden_states = self.w2(current_hidden_states)
+        return current_hidden_states
+
+
+class MixtralMoleSparseMoeBlock(nn.Module):
+    """
+    This implementation is
+    strictly equivalent to standard MoE with full capacity (no
+    dropped tokens). It's faster since it formulates MoE operations
+    in terms of block-sparse operations to accomodate imbalanced
+    assignments of tokens to experts, whereas standard MoE either
+    (1) drop tokens at the cost of reduced performance or (2) set
+    capacity factor to number of experts and thus waste computation
+    and memory on padding.
+    """
+
+    def __init__(self, config):
+        super().__init__()
+        self.hidden_dim = config.hidden_size
+        self.ffn_dim = config.intermediate_size
+        self.num_experts = config.num_local_experts
+        self.top_k = config.num_experts_per_tok
+
+        # gating
+        self.gate = nn.Linear(self.hidden_dim, self.num_experts, bias=False)
+
+        self.ffn = MixtralMoleBLockSparseTop2MLP(config)
+
+        self.experts = nn.ModuleList([LoRALayer(config) for _ in range(self.num_experts)])
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        """ """
+        batch_size, sequence_length, hidden_dim = hidden_states.shape
+        hidden_states = hidden_states.view(-1, hidden_dim)
+        # router_logits: (batch * sequence_length, n_experts)
+        router_logits = self.gate(hidden_states)
+
+        routing_weights = F.softmax(router_logits, dim=1, dtype=torch.float)
+        routing_weights, selected_experts = torch.topk(routing_weights, self.top_k, dim=-1) # (B*N, 2)
+        routing_weights /= routing_weights.sum(dim=-1, keepdim=True)
+        # we cast back to the input dtype
+        routing_weights = routing_weights.to(hidden_states.dtype)
+
+        # hidden_states fed into FFN
+        hidden_states_ffn = self.ffn(hidden_states) # (B*N, dim)
+
+        final_hidden_states = torch.zeros(
+            (batch_size * sequence_length, hidden_dim), dtype=hidden_states.dtype, device=hidden_states.device
+        )
+
+        # One hot encode the selected experts to create an expert mask
+        # this will be used to easily index which expert is going to be sollicitated
+        expert_mask = torch.nn.functional.one_hot(selected_experts, num_classes=self.num_experts).permute(2, 1, 0) # (8, 2, B*N)
+
+        # Loop over all available experts in the model and perform the computation on each expert
+        for expert_idx in range(self.num_experts):
+            expert_layer = self.experts[expert_idx]
+            idx, top_x = torch.where(expert_mask[expert_idx]) # idx: token choose this expert as top-1 or top-2; top_x: whether token choose this expert
+
+            if top_x.shape[0] == 0:
+                continue
+
+            # in torch it is faster to index using lists than torch tensors
+            top_x_list = top_x.tolist()
+            idx_list = idx.tolist()
+
+            # Index the correct hidden states and compute the expert hidden state for
+            # the current expert. We need to make sure to multiply the output hidden
+            # states by `routing_weights` on the corresponding tokens (top-1 and top-2)
+            current_state = hidden_states[None, top_x_list].reshape(-1, hidden_dim)
+            current_ffn = hidden_states_ffn[None, top_x_list].reshape(-1, hidden_dim)
+
+            # fuse ffn and lora hidden states
+            # shall we fuse lora experts before this addition or after?
+            # current implementation is aligned with mixsture of FFN experts
+            current_hidden_states = (expert_layer(current_state) + current_ffn) * routing_weights[top_x_list, idx_list, None]
+
+            # However `index_add_` only support torch tensors for indexing so we'll use
+            # the `top_x` tensor here.
+            final_hidden_states.index_add_(0, top_x, current_hidden_states.to(hidden_states.dtype))
+        final_hidden_states = final_hidden_states.reshape(batch_size, sequence_length, hidden_dim)
+        return final_hidden_states, router_logits
+
+
+class MixtralMoleDecoderLayer(nn.Module):
+    def __init__(self, config: MixtralMoleConfig, layer_idx: int):
+        super().__init__()
+        self.hidden_size = config.hidden_size
+
+        self.self_attn = MIXTRAL_ATTENTION_CLASSES[config._attn_implementation](config, layer_idx)
+
+        self.block_sparse_moe = MixtralMoleSparseMoeBlock(config)
+        self.input_layernorm = MixtralRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+        self.post_attention_layernorm = MixtralRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.LongTensor] = None,
+        past_key_value: Optional[Tuple[torch.Tensor]] = None,
+        output_attentions: Optional[bool] = False,
+        output_router_logits: Optional[bool] = False,
+        use_cache: Optional[bool] = False,
+        **kwargs,
+    ) -> Tuple[torch.FloatTensor, Optional[Tuple[torch.FloatTensor, torch.FloatTensor]]]:
+        if "padding_mask" in kwargs:
+            warnings.warn(
+                "Passing `padding_mask` is deprecated and will be removed in v4.37. Please make sure use `attention_mask` instead.`"
+            )
+        """
+        Args:
+            hidden_states (`torch.FloatTensor`): input to the layer of shape `(batch, seq_len, embed_dim)`
+            attention_mask (`torch.FloatTensor`, *optional*): attention mask of size
+                `(batch, sequence_length)` where padding elements are indicated by 0.
+            past_key_value (`Tuple(torch.FloatTensor)`, *optional*): cached past key and value projection states
+            output_attentions (`bool`, *optional*):
+                Whether or not to return the attentions tensors of all attention layers. See `attentions` under
+                returned tensors for more detail.
+            output_router_logits (`bool`, *optional*):
+                Whether or not to return the logits of all the routers. They are useful for computing the router loss, and
+                should not be returned during inference.
+            use_cache (`bool`, *optional*):
+                If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding
+                (see `past_key_values`).
+        """
+
+        residual = hidden_states
+
+        hidden_states = self.input_layernorm(hidden_states)
+
+        # Self Attention
+        hidden_states, self_attn_weights, present_key_value = self.self_attn(
+            hidden_states=hidden_states,
+            attention_mask=attention_mask,
+            position_ids=position_ids,
+            past_key_value=past_key_value,
+            output_attentions=output_attentions,
+            use_cache=use_cache,
+        )
+        hidden_states = residual + hidden_states
+
+        # Fully Connected
+        residual = hidden_states
+        hidden_states = self.post_attention_layernorm(hidden_states)
+        hidden_states, router_logits = self.block_sparse_moe(hidden_states)
+        hidden_states = residual + hidden_states
+
+        outputs = (hidden_states,)
+
+        if output_attentions:
+            outputs += (self_attn_weights,)
+
+        if use_cache:
+            outputs += (present_key_value,)
+
+        if output_router_logits:
+            outputs += (router_logits,)
+
+        return outputs
+
+
+MIXTRAL_START_DOCSTRING = r"""
+    This model inherits from [`PreTrainedModel`]. Check the superclass documentation for the generic methods the
+    library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads
+    etc.)
+
+    This model is also a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass.
+    Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
+    and behavior.
+
+    Parameters:
+        config ([`MixtralMoleConfig`]):
+            Model configuration class with all the parameters of the model. Initializing with a config file does not
+            load the weights associated with the model, only the configuration. Check out the
+            [`~PreTrainedModel.from_pretrained`] method to load the model weights.
+"""
+
+
+@add_start_docstrings(
+    "The bare Mixtral Model outputting raw hidden-states without any specific head on top.",
+    MIXTRAL_START_DOCSTRING,
+)
+# Copied from transformers.models.mistral.modeling_mistral.MistralPreTrainedModel with Mistral->Mixtral
+class MixtralMolePreTrainedModel(PreTrainedModel):
+    config_class = MixtralMoleConfig
+    base_model_prefix = "model"
+    supports_gradient_checkpointing = True
+    _no_split_modules = ["MixtralMoleDecoderLayer"]
+    _skip_keys_device_placement = "past_key_values"
+    _supports_flash_attn_2 = True
+    _supports_sdpa = True
+    _supports_cache_class = True
+
+    def _init_weights(self, module):
+        std = self.config.initializer_range
+        if isinstance(module, nn.Linear):
+            module.weight.data.normal_(mean=0.0, std=std)
+            if module.bias is not None:
+                module.bias.data.zero_()
+        elif isinstance(module, nn.Embedding):
+            module.weight.data.normal_(mean=0.0, std=std)
+            if module.padding_idx is not None:
+                module.weight.data[module.padding_idx].zero_()
+
+
+MIXTRAL_INPUTS_DOCSTRING = r"""
+    Args:
+        input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
+            Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you provide
+            it.
+
+            Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+            [`PreTrainedTokenizer.__call__`] for details.
+
+            [What are input IDs?](../glossary#input-ids)
+        attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
+            Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:
+
+            - 1 for tokens that are **not masked**,
+            - 0 for tokens that are **masked**.
+
+            [What are attention masks?](../glossary#attention-mask)
+
+            Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+            [`PreTrainedTokenizer.__call__`] for details.
+
+            If `past_key_values` is used, optionally only the last `decoder_input_ids` have to be input (see
+            `past_key_values`).
+
+            If you want to change padding behavior, you should read [`modeling_opt._prepare_decoder_attention_mask`]
+            and modify to your needs. See diagram 1 in [the paper](https://arxiv.org/abs/1910.13461) for more
+            information on the default strategy.
+
+            - 1 indicates the head is **not masked**,
+            - 0 indicates the head is **masked**.
+        position_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+            Indices of positions of each input sequence tokens in the position embeddings. Selected in the range `[0,
+            config.n_positions - 1]`.
+
+            [What are position IDs?](../glossary#position-ids)
+        past_key_values (`tuple(tuple(torch.FloatTensor))`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`):
+            Tuple of `tuple(torch.FloatTensor)` of length `config.n_layers`, with each tuple having 2 tensors of shape
+            `(batch_size, num_heads, sequence_length, embed_size_per_head)`) and 2 additional tensors of shape
+            `(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)`.
+
+            Contains pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention
+            blocks) that can be used (see `past_key_values` input) to speed up sequential decoding.
+
+            If `past_key_values` are used, the user can optionally input only the last `decoder_input_ids` (those that
+            don't have their past key value states given to this model) of shape `(batch_size, 1)` instead of all
+            `decoder_input_ids` of shape `(batch_size, sequence_length)`.
+        inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
+            Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation. This
+            is useful if you want more control over how to convert `input_ids` indices into associated vectors than the
+            model's internal embedding lookup matrix.
+        use_cache (`bool`, *optional*):
+            If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see
+            `past_key_values`).
+        output_attentions (`bool`, *optional*):
+            Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned
+            tensors for more detail.
+        output_hidden_states (`bool`, *optional*):
+            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
+            more detail.
+        output_router_logits (`bool`, *optional*):
+            Whether or not to return the logits of all the routers. They are useful for computing the router loss, and
+            should not be returned during inference.
+        return_dict (`bool`, *optional*):
+            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
+"""
+
+
+@add_start_docstrings(
+    "The bare Mixtral Model outputting raw hidden-states without any specific head on top.",
+    MIXTRAL_START_DOCSTRING,
+)
+# Copied from transformers.models.mistral.modeling_mistral.MistralModel with MISTRAL->MIXTRAL,Mistral->Mixtral
+class MixtralMoleModel(MixtralMolePreTrainedModel):
+    """
+    Transformer decoder consisting of *config.num_hidden_layers* layers. Each layer is a [`MixtralMoleDecoderLayer`]
+
+    Args:
+        config: MixtralMoleConfig
+    """
+
+    def __init__(self, config: MixtralMoleConfig):
+        super().__init__(config)
+        self.padding_idx = config.pad_token_id
+        self.vocab_size = config.vocab_size
+
+        self.embed_tokens = nn.Embedding(config.vocab_size, config.hidden_size, self.padding_idx)
+        self.layers = nn.ModuleList(
+            [MixtralMoleDecoderLayer(config, layer_idx) for layer_idx in range(config.num_hidden_layers)]
+        )
+        self._attn_implementation = config._attn_implementation
+        self.norm = MixtralRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
+
+        self.gradient_checkpointing = False
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def get_input_embeddings(self):
+        return self.embed_tokens
+
+    def set_input_embeddings(self, value):
+        self.embed_tokens = value
+
+    # Ignore copy
+    @add_start_docstrings_to_model_forward(MIXTRAL_INPUTS_DOCSTRING)
+    def forward(
+        self,
+        input_ids: torch.LongTensor = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.LongTensor] = None,
+        past_key_values: Optional[List[torch.FloatTensor]] = None,
+        inputs_embeds: Optional[torch.FloatTensor] = None,
+        use_cache: Optional[bool] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        output_router_logits: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple, MoeModelOutputWithPast]:
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        output_router_logits = (
+            output_router_logits if output_router_logits is not None else self.config.output_router_logits
+        )
+        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
+
+        # retrieve input_ids and inputs_embeds
+        if input_ids is not None and inputs_embeds is not None:
+            raise ValueError("You cannot specify both decoder_input_ids and decoder_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 decoder_input_ids or decoder_inputs_embeds")
+
+        past_key_values_length = 0
+
+        if self.gradient_checkpointing and self.training:
+            if use_cache:
+                logger.warning_once(
+                    "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..."
+                )
+                use_cache = False
+
+        if use_cache:
+            use_legacy_cache = not isinstance(past_key_values, Cache)
+            if use_legacy_cache:
+                past_key_values = DynamicCache.from_legacy_cache(past_key_values)
+            past_key_values_length = past_key_values.get_usable_length(seq_length)
+
+        if position_ids is None:
+            device = input_ids.device if input_ids is not None else inputs_embeds.device
+            position_ids = torch.arange(
+                past_key_values_length, seq_length + past_key_values_length, dtype=torch.long, device=device
+            )
+            position_ids = position_ids.unsqueeze(0).view(-1, seq_length)
+        else:
+            position_ids = position_ids.view(-1, seq_length).long()
+
+        if inputs_embeds is None:
+            inputs_embeds = self.embed_tokens(input_ids)
+
+        if attention_mask is not None and self._attn_implementation == "flash_attention_2" and use_cache:
+            is_padding_right = attention_mask[:, -1].sum().item() != batch_size
+            if is_padding_right:
+                raise ValueError(
+                    "You are attempting to perform batched generation with padding_side='right'"
+                    " this may lead to unexpected behaviour for Flash Attention version of Mixtral. Make sure to "
+                    " call `tokenizer.padding_side  = 'left'` before tokenizing the input. "
+                )
+
+        if self._attn_implementation == "flash_attention_2":
+            # 2d mask is passed through the layers
+            attention_mask = attention_mask if (attention_mask is not None and 0 in attention_mask) else None
+        elif self._attn_implementation == "sdpa" and not output_attentions:
+            # output_attentions=True can not be supported when using SDPA, and we fall back on
+            # the manual implementation that requires a 4D causal mask in all cases.
+            attention_mask = _prepare_4d_causal_attention_mask_for_sdpa(
+                attention_mask,
+                (batch_size, seq_length),
+                inputs_embeds,
+                past_key_values_length,
+            )
+        else:
+            # 4d mask is passed through the layers
+            attention_mask = _prepare_4d_causal_attention_mask(
+                attention_mask,
+                (batch_size, seq_length),
+                inputs_embeds,
+                past_key_values_length,
+                sliding_window=self.config.sliding_window,
+            )
+
+        hidden_states = inputs_embeds
+
+        # decoder layers
+        all_hidden_states = () if output_hidden_states else None
+        all_self_attns = () if output_attentions else None
+        all_router_logits = () if output_router_logits else None
+        next_decoder_cache = None
+
+        for decoder_layer in self.layers:
+            if output_hidden_states:
+                all_hidden_states += (hidden_states,)
+
+            if self.gradient_checkpointing and self.training:
+                layer_outputs = self._gradient_checkpointing_func(
+                    decoder_layer.__call__,
+                    hidden_states,
+                    attention_mask,
+                    position_ids,
+                    past_key_values,
+                    output_attentions,
+                    output_router_logits,
+                    use_cache,
+                )
+            else:
+                layer_outputs = decoder_layer(
+                    hidden_states,
+                    attention_mask=attention_mask,
+                    position_ids=position_ids,
+                    past_key_value=past_key_values,
+                    output_attentions=output_attentions,
+                    output_router_logits=output_router_logits,
+                    use_cache=use_cache,
+                )
+
+            hidden_states = layer_outputs[0]
+
+            if use_cache:
+                next_decoder_cache = layer_outputs[2 if output_attentions else 1]
+
+            if output_attentions:
+                all_self_attns += (layer_outputs[1],)
+
+            if output_router_logits:
+                all_router_logits += (layer_outputs[-1],)
+
+        hidden_states = self.norm(hidden_states)
+
+        # add hidden states from the last decoder layer
+        if output_hidden_states:
+            all_hidden_states += (hidden_states,)
+
+        next_cache = None
+        if use_cache:
+            next_cache = next_decoder_cache.to_legacy_cache() if use_legacy_cache else next_decoder_cache
+
+        if not return_dict:
+            return tuple(
+                v
+                for v in [hidden_states, next_cache, all_hidden_states, all_self_attns, all_router_logits]
+                if v is not None
+            )
+        return MoeModelOutputWithPast(
+            last_hidden_state=hidden_states,
+            past_key_values=next_cache,
+            hidden_states=all_hidden_states,
+            attentions=all_self_attns,
+            router_logits=all_router_logits,
+        )
+
+
+class MixtralMoleForCausalLM(MixtralMolePreTrainedModel):
+    _tied_weights_keys = ["lm_head.weight"]
+
+    def __init__(self, config):
+        super().__init__(config)
+        self.model = MixtralMoleModel(config)
+        self.vocab_size = config.vocab_size
+        self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
+        self.router_aux_loss_coef = config.router_aux_loss_coef
+        self.num_experts = config.num_local_experts
+        self.num_experts_per_tok = config.num_experts_per_tok
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def get_input_embeddings(self):
+        return self.model.embed_tokens
+
+    def set_input_embeddings(self, value):
+        self.model.embed_tokens = value
+
+    def get_output_embeddings(self):
+        return self.lm_head
+
+    def set_output_embeddings(self, new_embeddings):
+        self.lm_head = new_embeddings
+
+    def set_decoder(self, decoder):
+        self.model = decoder
+
+    def get_decoder(self):
+        return self.model
+
+    @add_start_docstrings_to_model_forward(MIXTRAL_INPUTS_DOCSTRING)
+    @replace_return_docstrings(output_type=MoeCausalLMOutputWithPast, config_class=_CONFIG_FOR_DOC)
+    # Ignore copy
+    def forward(
+        self,
+        input_ids: torch.LongTensor = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.LongTensor] = None,
+        past_key_values: Optional[List[torch.FloatTensor]] = None,
+        inputs_embeds: Optional[torch.FloatTensor] = None,
+        labels: Optional[torch.LongTensor] = None,
+        use_cache: Optional[bool] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        output_router_logits: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple, MoeCausalLMOutputWithPast]:
+        r"""
+        Args:
+            labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+                Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,
+                config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored
+                (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`.
+
+        Returns:
+
+        Example:
+
+        ```python
+        >>> from transformers import AutoTokenizer, MixtralMoleForCausalLM
+
+        >>> model = MixtralMoleForCausalLM.from_pretrained("mistralai/Mixtral-8x7B-v0.1")
+        >>> tokenizer = AutoTokenizer.from_pretrained("mistralai/Mixtral-8x7B-v0.1")
+
+        >>> prompt = "Hey, are you conscious? Can you talk to me?"
+        >>> inputs = tokenizer(prompt, return_tensors="pt")
+
+        >>> # Generate
+        >>> generate_ids = model.generate(inputs.input_ids, max_length=30)
+        >>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
+        "Hey, are you conscious? Can you talk to me?\nI'm not conscious, but I can talk to you."
+        ```"""
+
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        output_router_logits = (
+            output_router_logits if output_router_logits is not None else self.config.output_router_logits
+        )
+
+        output_hidden_states = (
+            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        )
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        # decoder outputs consists of (dec_features, layer_state, dec_hidden, dec_attn)
+        outputs = self.model(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            position_ids=position_ids,
+            past_key_values=past_key_values,
+            inputs_embeds=inputs_embeds,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            output_router_logits=output_router_logits,
+            return_dict=return_dict,
+        )
+
+        hidden_states = outputs[0]
+        logits = self.lm_head(hidden_states)
+        logits = logits.float()
+
+        loss = None
+        if labels is not None:
+            # Shift so that tokens < n predict n
+            shift_logits = logits[..., :-1, :].contiguous()
+            shift_labels = labels[..., 1:].contiguous()
+            # Flatten the tokens
+            loss_fct = CrossEntropyLoss()
+            shift_logits = shift_logits.view(-1, self.config.vocab_size)
+            shift_labels = shift_labels.view(-1)
+            # Enable model parallelism
+            shift_labels = shift_labels.to(shift_logits.device)
+            loss = loss_fct(shift_logits, shift_labels)
+
+        aux_loss = None
+        if output_router_logits:
+            aux_loss = load_balancing_loss_func(
+                outputs.router_logits if return_dict else outputs[-1], self.num_experts, self.num_experts_per_tok
+            )
+            if labels is not None:
+                loss += self.router_aux_loss_coef * aux_loss
+
+        if not return_dict:
+            output = (logits,) + outputs[1:]
+            if output_router_logits:
+                output = (aux_loss,) + output
+            return (loss,) + output if loss is not None else output
+
+        return MoeCausalLMOutputWithPast(
+            loss=loss,
+            aux_loss=aux_loss,
+            logits=logits,
+            past_key_values=outputs.past_key_values,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+            router_logits=outputs.router_logits,
+        )
+
+    def prepare_inputs_for_generation(
+        self, input_ids, past_key_values=None, attention_mask=None, inputs_embeds=None, **kwargs
+    ):
+        # Omit tokens covered by past_key_values
+        if past_key_values is not None:
+            if isinstance(past_key_values, Cache):
+                cache_length = past_key_values.get_seq_length()
+                past_length = past_key_values.seen_tokens
+                max_cache_length = past_key_values.get_max_length()
+            else:
+                cache_length = past_length = past_key_values[0][0].shape[2]
+                max_cache_length = None
+
+            # Keep only the unprocessed tokens:
+            # 1 - If the length of the attention_mask exceeds the length of input_ids, then we are in a setting where
+            # some of the inputs are exclusively passed as part of the cache (e.g. when passing input_embeds as
+            # input)
+            if attention_mask is not None and attention_mask.shape[1] > input_ids.shape[1]:
+                input_ids = input_ids[:, -(attention_mask.shape[1] - past_length) :]
+            # 2 - If the past_length is smaller than input_ids', then input_ids holds all input tokens. We can discard
+            # input_ids based on the past_length.
+            elif past_length < input_ids.shape[1]:
+                input_ids = input_ids[:, past_length:]
+            # 3 - Otherwise (past_length >= input_ids.shape[1]), let's assume input_ids only has unprocessed tokens.
+
+            # If we are about to go beyond the maximum cache length, we need to crop the input attention mask.
+            if (
+                max_cache_length is not None
+                and attention_mask is not None
+                and cache_length + input_ids.shape[1] > max_cache_length
+            ):
+                attention_mask = attention_mask[:, -max_cache_length:]
+
+        position_ids = kwargs.get("position_ids", None)
+        if attention_mask is not None and position_ids is None:
+            # create position_ids on the fly for batch generation
+            position_ids = attention_mask.long().cumsum(-1) - 1
+            position_ids.masked_fill_(attention_mask == 0, 1)
+            if past_key_values:
+                position_ids = position_ids[:, -input_ids.shape[1] :]
+
+        # if `inputs_embeds` are passed, we only want to use them in the 1st generation step
+        if inputs_embeds is not None and past_key_values is None:
+            model_inputs = {"inputs_embeds": inputs_embeds}
+        else:
+            model_inputs = {"input_ids": input_ids}
+
+        model_inputs.update(
+            {
+                "position_ids": position_ids,
+                "past_key_values": past_key_values,
+                "use_cache": kwargs.get("use_cache"),
+                "attention_mask": attention_mask,
+            }
+        )
+        return model_inputs
+
+    @staticmethod
+    def _reorder_cache(past_key_values, beam_idx):
+        reordered_past = ()
+        for layer_past in past_key_values:
+            reordered_past += (
+                tuple(past_state.index_select(0, beam_idx.to(past_state.device)) for past_state in layer_past),
+            )
+        return reordered_past
+
+
+@add_start_docstrings(
+    """
+    The Mixtral Model transformer with a sequence classification head on top (linear layer).
+
+    [`MixtralMoleForSequenceClassification`] uses the last token in order to do the classification, as other causal models
+    (e.g. GPT-2) do.
+
+    Since it does classification on the last token, it requires to know the position of the last token. If a
+    `pad_token_id` is defined in the configuration, it finds the last token that is not a padding token in each row. If
+    no `pad_token_id` is defined, it simply takes the last value in each row of the batch. Since it cannot guess the
+    padding tokens when `inputs_embeds` are passed instead of `input_ids`, it does the same (take the last value in
+    each row of the batch).
+    """,
+    MIXTRAL_START_DOCSTRING,
+)
+# Copied from transformers.models.llama.modeling_llama.LlamaForSequenceClassification with Llama->Mixtral, LLAMA->MIXTRAL
+class MixtralMoleForSequenceClassification(MixtralMolePreTrainedModel):
+    def __init__(self, config):
+        super().__init__(config)
+        self.num_labels = config.num_labels
+        self.model = MixtralMoleModel(config)
+        self.score = nn.Linear(config.hidden_size, self.num_labels, bias=False)
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def get_input_embeddings(self):
+        return self.model.embed_tokens
+
+    def set_input_embeddings(self, value):
+        self.model.embed_tokens = value
+
+    @add_start_docstrings_to_model_forward(MIXTRAL_INPUTS_DOCSTRING)
+    def forward(
+        self,
+        input_ids: torch.LongTensor = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.LongTensor] = None,
+        past_key_values: Optional[List[torch.FloatTensor]] = None,
+        inputs_embeds: Optional[torch.FloatTensor] = None,
+        labels: 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,
+    ) -> Union[Tuple, 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).
+        """
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        transformer_outputs = self.model(
+            input_ids,
+            attention_mask=attention_mask,
+            position_ids=position_ids,
+            past_key_values=past_key_values,
+            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:
+                # if no pad token found, use modulo instead of reverse indexing for ONNX compatibility
+                sequence_lengths = torch.eq(input_ids, self.config.pad_token_id).int().argmax(-1) - 1
+                sequence_lengths = sequence_lengths % input_ids.shape[-1]
+                sequence_lengths = sequence_lengths.to(logits.device)
+            else:
+                sequence_lengths = -1
+
+        pooled_logits = logits[torch.arange(batch_size, device=logits.device), sequence_lengths]
+
+        loss = None
+        if labels is not None:
+            labels = labels.to(logits.device)
+            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.view(-1, self.num_labels), labels.view(-1))
+            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,
+        )

runs/Jan23_12-59-12_main1/events.out.tfevents.1706014802.main1.65865.0

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:fa443b537f60f0f975c5ef0d78c91eaaee9f9310012dda9cad8af344251d46f0
-size 121084
+oid sha256:2ca8ba4c05907405476633105cb3e4e5fb8372f701e78ea49be4a9cfc02d89ca
+size 122066

runs/Jan23_12-59-12_main1/events.out.tfevents.1706062627.main1.65865.1

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

train_results.json

@@ -0,0 +1,8 @@
+{
+    "epoch": 3.0,
+    "train_loss": 1.0902616986746403,
+    "train_runtime": 47329.7113,
+    "train_samples": 207865,
+    "train_samples_per_second": 9.258,
+    "train_steps_per_second": 0.072
+}

trainer_state.json

@@ -0,0 +1,4412 @@
+{
+  "best_metric": 1.1127439737319946,
+  "best_model_checkpoint": "data/tinyllama_mole_sft_ultrachat_ep3/checkpoint-2200",
+  "epoch": 2.9986859395532193,
+  "eval_steps": 100,
+  "global_step": 3423,
+  "is_hyper_param_search": false,
+  "is_local_process_zero": true,
+  "is_world_process_zero": true,
+  "log_history": [
+    {
+      "epoch": 0.0,
+      "learning_rate": 1.6666666666666668e-07,
+      "loss": 2.7824,
+      "step": 1
+    },
+    {
+      "epoch": 0.0,
+      "learning_rate": 8.333333333333333e-07,
+      "loss": 2.7372,
+      "step": 5
+    },
+    {
+      "epoch": 0.01,
+      "learning_rate": 1.6666666666666667e-06,
+      "loss": 2.7223,
+      "step": 10
+    },
+    {
+      "epoch": 0.01,
+      "learning_rate": 2.5e-06,
+      "loss": 2.5564,
+      "step": 15
+    },
+    {
+      "epoch": 0.02,
+      "learning_rate": 3.3333333333333333e-06,
+      "loss": 2.2279,
+      "step": 20
+    },
+    {
+      "epoch": 0.02,
+      "learning_rate": 4.166666666666667e-06,
+      "loss": 1.8858,
+      "step": 25
+    },
+    {
+      "epoch": 0.03,
+      "learning_rate": 5e-06,
+      "loss": 1.7341,
+      "step": 30
+    },
+    {
+      "epoch": 0.03,
+      "learning_rate": 5.833333333333334e-06,
+      "loss": 1.629,
+      "step": 35
+    },
+    {
+      "epoch": 0.04,
+      "learning_rate": 6.666666666666667e-06,
+      "loss": 1.5663,
+      "step": 40
+    },
+    {
+      "epoch": 0.04,
+      "learning_rate": 7.500000000000001e-06,
+      "loss": 1.5049,
+      "step": 45
+    },
+    {
+      "epoch": 0.04,
+      "learning_rate": 8.333333333333334e-06,
+      "loss": 1.4663,
+      "step": 50
+    },
+    {
+      "epoch": 0.05,
+      "learning_rate": 9.166666666666666e-06,
+      "loss": 1.4061,
+      "step": 55
+    },
+    {
+      "epoch": 0.05,
+      "learning_rate": 1e-05,
+      "loss": 1.3948,
+      "step": 60
+    },
+    {
+      "epoch": 0.06,
+      "learning_rate": 1.0833333333333334e-05,
+      "loss": 1.3597,
+      "step": 65
+    },
+    {
+      "epoch": 0.06,
+      "learning_rate": 1.1666666666666668e-05,
+      "loss": 1.3542,
+      "step": 70
+    },
+    {
+      "epoch": 0.07,
+      "learning_rate": 1.25e-05,
+      "loss": 1.3161,
+      "step": 75
+    },
+    {
+      "epoch": 0.07,
+      "learning_rate": 1.3333333333333333e-05,
+      "loss": 1.3134,
+      "step": 80
+    },
+    {
+      "epoch": 0.07,
+      "learning_rate": 1.416666666666667e-05,
+      "loss": 1.3123,
+      "step": 85
+    },
+    {
+      "epoch": 0.08,
+      "learning_rate": 1.5000000000000002e-05,
+      "loss": 1.3025,
+      "step": 90
+    },
+    {
+      "epoch": 0.08,
+      "learning_rate": 1.5833333333333333e-05,
+      "loss": 1.2728,
+      "step": 95
+    },
+    {
+      "epoch": 0.09,
+      "learning_rate": 1.6666666666666667e-05,
+      "loss": 1.3007,
+      "step": 100
+    },
+    {
+      "epoch": 0.09,
+      "eval_loss": 1.2780451774597168,
+      "eval_runtime": 443.4938,
+      "eval_samples_per_second": 36.451,
+      "eval_steps_per_second": 1.141,
+      "step": 100
+    },
+    {
+      "epoch": 0.09,
+      "learning_rate": 1.7500000000000002e-05,
+      "loss": 1.2749,
+      "step": 105
+    },
+    {
+      "epoch": 0.1,
+      "learning_rate": 1.8333333333333333e-05,
+      "loss": 1.2661,
+      "step": 110
+    },
+    {
+      "epoch": 0.1,
+      "learning_rate": 1.916666666666667e-05,
+      "loss": 1.2678,
+      "step": 115
+    },
+    {
+      "epoch": 0.11,
+      "learning_rate": 2e-05,
+      "loss": 1.2441,
+      "step": 120
+    },
+    {
+      "epoch": 0.11,
+      "learning_rate": 1.9999886918439637e-05,
+      "loss": 1.249,
+      "step": 125
+    },
+    {
+      "epoch": 0.11,
+      "learning_rate": 1.9999547676316034e-05,
+      "loss": 1.2267,
+      "step": 130
+    },
+    {
+      "epoch": 0.12,
+      "learning_rate": 1.99989822813016e-05,
+      "loss": 1.2418,
+      "step": 135
+    },
+    {
+      "epoch": 0.12,
+      "learning_rate": 1.999819074618348e-05,
+      "loss": 1.2541,
+      "step": 140
+    },
+    {
+      "epoch": 0.13,
+      "learning_rate": 1.9997173088863285e-05,
+      "loss": 1.2339,
+      "step": 145
+    },
+    {
+      "epoch": 0.13,
+      "learning_rate": 1.9995929332356666e-05,
+      "loss": 1.2366,
+      "step": 150
+    },
+    {
+      "epoch": 0.14,
+      "learning_rate": 1.999445950479281e-05,
+      "loss": 1.2296,
+      "step": 155
+    },
+    {
+      "epoch": 0.14,
+      "learning_rate": 1.9992763639413796e-05,
+      "loss": 1.2246,
+      "step": 160
+    },
+    {
+      "epoch": 0.14,
+      "learning_rate": 1.9990841774573843e-05,
+      "loss": 1.22,
+      "step": 165
+    },
+    {
+      "epoch": 0.15,
+      "learning_rate": 1.9988693953738446e-05,
+      "loss": 1.2232,
+      "step": 170
+    },
+    {
+      "epoch": 0.15,
+      "learning_rate": 1.9986320225483396e-05,
+      "loss": 1.2337,
+      "step": 175
+    },
+    {
+      "epoch": 0.16,
+      "learning_rate": 1.9983720643493665e-05,
+      "loss": 1.2096,
+      "step": 180
+    },
+    {
+      "epoch": 0.16,
+      "learning_rate": 1.9980895266562217e-05,
+      "loss": 1.2099,
+      "step": 185
+    },
+    {
+      "epoch": 0.17,
+      "learning_rate": 1.9977844158588655e-05,
+      "loss": 1.2165,
+      "step": 190
+    },
+    {
+      "epoch": 0.17,
+      "learning_rate": 1.997456738857779e-05,
+      "loss": 1.2075,
+      "step": 195
+    },
+    {
+      "epoch": 0.18,
+      "learning_rate": 1.9971065030638076e-05,
+      "loss": 1.2255,
+      "step": 200
+    },
+    {
+      "epoch": 0.18,
+      "eval_loss": 1.215826153755188,
+      "eval_runtime": 441.9342,
+      "eval_samples_per_second": 36.58,
+      "eval_steps_per_second": 1.145,
+      "step": 200
+    },
+    {
+      "epoch": 0.18,
+      "learning_rate": 1.996733716397993e-05,
+      "loss": 1.2178,
+      "step": 205
+    },
+    {
+      "epoch": 0.18,
+      "learning_rate": 1.996338387291395e-05,
+      "loss": 1.1935,
+      "step": 210
+    },
+    {
+      "epoch": 0.19,
+      "learning_rate": 1.9959205246849e-05,
+      "loss": 1.2246,
+      "step": 215
+    },
+    {
+      "epoch": 0.19,
+      "learning_rate": 1.9954801380290194e-05,
+      "loss": 1.2003,
+      "step": 220
+    },
+    {
+      "epoch": 0.2,
+      "learning_rate": 1.995017237283675e-05,
+      "loss": 1.1842,
+      "step": 225
+    },
+    {
+      "epoch": 0.2,
+      "learning_rate": 1.994531832917974e-05,
+      "loss": 1.2052,
+      "step": 230
+    },
+    {
+      "epoch": 0.21,
+      "learning_rate": 1.994023935909974e-05,
+      "loss": 1.214,
+      "step": 235
+    },
+    {
+      "epoch": 0.21,
+      "learning_rate": 1.9934935577464312e-05,
+      "loss": 1.1859,
+      "step": 240
+    },
+    {
+      "epoch": 0.21,
+      "learning_rate": 1.9929407104225444e-05,
+      "loss": 1.2139,
+      "step": 245
+    },
+    {
+      "epoch": 0.22,
+      "learning_rate": 1.9923654064416813e-05,
+      "loss": 1.1902,
+      "step": 250
+    },
+    {
+      "epoch": 0.22,
+      "learning_rate": 1.991767658815096e-05,
+      "loss": 1.1991,
+      "step": 255
+    },
+    {
+      "epoch": 0.23,
+      "learning_rate": 1.9911474810616348e-05,
+      "loss": 1.2027,
+      "step": 260
+    },
+    {
+      "epoch": 0.23,
+      "learning_rate": 1.9905048872074322e-05,
+      "loss": 1.184,
+      "step": 265
+    },
+    {
+      "epoch": 0.24,
+      "learning_rate": 1.989839891785591e-05,
+      "loss": 1.1857,
+      "step": 270
+    },
+    {
+      "epoch": 0.24,
+      "learning_rate": 1.9891525098358553e-05,
+      "loss": 1.199,
+      "step": 275
+    },
+    {
+      "epoch": 0.25,
+      "learning_rate": 1.9884427569042693e-05,
+      "loss": 1.1751,
+      "step": 280
+    },
+    {
+      "epoch": 0.25,
+      "learning_rate": 1.9877106490428275e-05,
+      "loss": 1.2092,
+      "step": 285
+    },
+    {
+      "epoch": 0.25,
+      "learning_rate": 1.9869562028091092e-05,
+      "loss": 1.1751,
+      "step": 290
+    },
+    {
+      "epoch": 0.26,
+      "learning_rate": 1.986179435265906e-05,
+      "loss": 1.196,
+      "step": 295
+    },
+    {
+      "epoch": 0.26,
+      "learning_rate": 1.9853803639808357e-05,
+      "loss": 1.192,
+      "step": 300
+    },
+    {
+      "epoch": 0.26,
+      "eval_loss": 1.1921414136886597,
+      "eval_runtime": 444.0535,
+      "eval_samples_per_second": 36.406,
+      "eval_steps_per_second": 1.14,
+      "step": 300
+    },
+    {
+      "epoch": 0.27,
+      "learning_rate": 1.984559007025943e-05,
+      "loss": 1.1938,
+      "step": 305
+    },
+    {
+      "epoch": 0.27,
+      "learning_rate": 1.983715382977293e-05,
+      "loss": 1.1638,
+      "step": 310
+    },
+    {
+      "epoch": 0.28,
+      "learning_rate": 1.9828495109145516e-05,
+      "loss": 1.1807,
+      "step": 315
+    },
+    {
+      "epoch": 0.28,
+      "learning_rate": 1.9819614104205504e-05,
+      "loss": 1.1772,
+      "step": 320
+    },
+    {
+      "epoch": 0.28,
+      "learning_rate": 1.9810511015808477e-05,
+      "loss": 1.1755,
+      "step": 325
+    },
+    {
+      "epoch": 0.29,
+      "learning_rate": 1.980118604983273e-05,
+      "loss": 1.17,
+      "step": 330
+    },
+    {
+      "epoch": 0.29,
+      "learning_rate": 1.979163941717459e-05,
+      "loss": 1.2216,
+      "step": 335
+    },
+    {
+      "epoch": 0.3,
+      "learning_rate": 1.9781871333743695e-05,
+      "loss": 1.1751,
+      "step": 340
+    },
+    {
+      "epoch": 0.3,
+      "learning_rate": 1.9771882020458055e-05,
+      "loss": 1.1799,
+      "step": 345
+    },
+    {
+      "epoch": 0.31,
+      "learning_rate": 1.9761671703239108e-05,
+      "loss": 1.1752,
+      "step": 350
+    },
+    {
+      "epoch": 0.31,
+      "learning_rate": 1.9751240613006568e-05,
+      "loss": 1.1753,
+      "step": 355
+    },
+    {
+      "epoch": 0.32,
+      "learning_rate": 1.9740588985673226e-05,
+      "loss": 1.181,
+      "step": 360
+    },
+    {
+      "epoch": 0.32,
+      "learning_rate": 1.9729717062139616e-05,
+      "loss": 1.176,
+      "step": 365
+    },
+    {
+      "epoch": 0.32,
+      "learning_rate": 1.9718625088288544e-05,
+      "loss": 1.1694,
+      "step": 370
+    },
+    {
+      "epoch": 0.33,
+      "learning_rate": 1.970731331497956e-05,
+      "loss": 1.164,
+      "step": 375
+    },
+    {
+      "epoch": 0.33,
+      "learning_rate": 1.969578199804326e-05,
+      "loss": 1.1784,
+      "step": 380
+    },
+    {
+      "epoch": 0.34,
+      "learning_rate": 1.96840313982755e-05,
+      "loss": 1.1669,
+      "step": 385
+    },
+    {
+      "epoch": 0.34,
+      "learning_rate": 1.967206178143152e-05,
+      "loss": 1.1611,
+      "step": 390
+    },
+    {
+      "epoch": 0.35,
+      "learning_rate": 1.96598734182199e-05,
+      "loss": 1.1622,
+      "step": 395
+    },
+    {
+      "epoch": 0.35,
+      "learning_rate": 1.9647466584296474e-05,
+      "loss": 1.1696,
+      "step": 400
+    },
+    {
+      "epoch": 0.35,
+      "eval_loss": 1.1770251989364624,
+      "eval_runtime": 440.3334,
+      "eval_samples_per_second": 36.713,
+      "eval_steps_per_second": 1.149,
+      "step": 400
+    },
+    {
+      "epoch": 0.35,
+      "learning_rate": 1.9634841560258063e-05,
+      "loss": 1.1899,
+      "step": 405
+    },
+    {
+      "epoch": 0.36,
+      "learning_rate": 1.9621998631636156e-05,
+      "loss": 1.1843,
+      "step": 410
+    },
+    {
+      "epoch": 0.36,
+      "learning_rate": 1.960893808889043e-05,
+      "loss": 1.1701,
+      "step": 415
+    },
+    {
+      "epoch": 0.37,
+      "learning_rate": 1.9595660227402204e-05,
+      "loss": 1.1703,
+      "step": 420
+    },
+    {
+      "epoch": 0.37,
+      "learning_rate": 1.958216534746773e-05,
+      "loss": 1.1633,
+      "step": 425
+    },
+    {
+      "epoch": 0.38,
+      "learning_rate": 1.9568453754291424e-05,
+      "loss": 1.171,
+      "step": 430
+    },
+    {
+      "epoch": 0.38,
+      "learning_rate": 1.9554525757978958e-05,
+      "loss": 1.157,
+      "step": 435
+    },
+    {
+      "epoch": 0.39,
+      "learning_rate": 1.9540381673530247e-05,
+      "loss": 1.1708,
+      "step": 440
+    },
+    {
+      "epoch": 0.39,
+      "learning_rate": 1.952602182083231e-05,
+      "loss": 1.1612,
+      "step": 445
+    },
+    {
+      "epoch": 0.39,
+      "learning_rate": 1.9511446524652062e-05,
+      "loss": 1.1861,
+      "step": 450
+    },
+    {
+      "epoch": 0.4,
+      "learning_rate": 1.949665611462895e-05,
+      "loss": 1.1564,
+      "step": 455
+    },
+    {
+      "epoch": 0.4,
+      "learning_rate": 1.9481650925267506e-05,
+      "loss": 1.1559,
+      "step": 460
+    },
+    {
+      "epoch": 0.41,
+      "learning_rate": 1.946643129592977e-05,
+      "loss": 1.1676,
+      "step": 465
+    },
+    {
+      "epoch": 0.41,
+      "learning_rate": 1.945099757082763e-05,
+      "loss": 1.1698,
+      "step": 470
+    },
+    {
+      "epoch": 0.42,
+      "learning_rate": 1.9435350099015028e-05,
+      "loss": 1.1639,
+      "step": 475
+    },
+    {
+      "epoch": 0.42,
+      "learning_rate": 1.9419489234380077e-05,
+      "loss": 1.1722,
+      "step": 480
+    },
+    {
+      "epoch": 0.42,
+      "learning_rate": 1.940341533563703e-05,
+      "loss": 1.1382,
+      "step": 485
+    },
+    {
+      "epoch": 0.43,
+      "learning_rate": 1.9387128766318205e-05,
+      "loss": 1.1711,
+      "step": 490
+    },
+    {
+      "epoch": 0.43,
+      "learning_rate": 1.9370629894765737e-05,
+      "loss": 1.1552,
+      "step": 495
+    },
+    {
+      "epoch": 0.44,
+      "learning_rate": 1.935391909412325e-05,
+      "loss": 1.1426,
+      "step": 500
+    },
+    {
+      "epoch": 0.44,
+      "eval_loss": 1.1665772199630737,
+      "eval_runtime": 442.1456,
+      "eval_samples_per_second": 36.563,
+      "eval_steps_per_second": 1.144,
+      "step": 500
+    },
+    {
+      "epoch": 0.44,
+      "learning_rate": 1.9336996742327424e-05,
+      "loss": 1.157,
+      "step": 505
+    },
+    {
+      "epoch": 0.45,
+      "learning_rate": 1.931986322209946e-05,
+      "loss": 1.1594,
+      "step": 510
+    },
+    {
+      "epoch": 0.45,
+      "learning_rate": 1.930251892093638e-05,
+      "loss": 1.1641,
+      "step": 515
+    },
+    {
+      "epoch": 0.46,
+      "learning_rate": 1.928496423110233e-05,
+      "loss": 1.1382,
+      "step": 520
+    },
+    {
+      "epoch": 0.46,
+      "learning_rate": 1.9267199549619643e-05,
+      "loss": 1.1556,
+      "step": 525
+    },
+    {
+      "epoch": 0.46,
+      "learning_rate": 1.92492252782599e-05,
+      "loss": 1.1473,
+      "step": 530
+    },
+    {
+      "epoch": 0.47,
+      "learning_rate": 1.9231041823534835e-05,
+      "loss": 1.1431,
+      "step": 535
+    },
+    {
+      "epoch": 0.47,
+      "learning_rate": 1.9212649596687136e-05,
+      "loss": 1.1588,
+      "step": 540
+    },
+    {
+      "epoch": 0.48,
+      "learning_rate": 1.9194049013681134e-05,
+      "loss": 1.1478,
+      "step": 545
+    },
+    {
+      "epoch": 0.48,
+      "learning_rate": 1.9175240495193433e-05,
+      "loss": 1.1595,
+      "step": 550
+    },
+    {
+      "epoch": 0.49,
+      "learning_rate": 1.915622446660335e-05,
+      "loss": 1.1614,
+      "step": 555
+    },
+    {
+      "epoch": 0.49,
+      "learning_rate": 1.9137001357983323e-05,
+      "loss": 1.1662,
+      "step": 560
+    },
+    {
+      "epoch": 0.49,
+      "learning_rate": 1.9117571604089172e-05,
+      "loss": 1.1647,
+      "step": 565
+    },
+    {
+      "epoch": 0.5,
+      "learning_rate": 1.9097935644350284e-05,
+      "loss": 1.1551,
+      "step": 570
+    },
+    {
+      "epoch": 0.5,
+      "learning_rate": 1.9078093922859642e-05,
+      "loss": 1.157,
+      "step": 575
+    },
+    {
+      "epoch": 0.51,
+      "learning_rate": 1.9058046888363814e-05,
+      "loss": 1.1419,
+      "step": 580
+    },
+    {
+      "epoch": 0.51,
+      "learning_rate": 1.9037794994252792e-05,
+      "loss": 1.1605,
+      "step": 585
+    },
+    {
+      "epoch": 0.52,
+      "learning_rate": 1.901733869854973e-05,
+      "loss": 1.149,
+      "step": 590
+    },
+    {
+      "epoch": 0.52,
+      "learning_rate": 1.8996678463900596e-05,
+      "loss": 1.173,
+      "step": 595
+    },
+    {
+      "epoch": 0.53,
+      "learning_rate": 1.8975814757563707e-05,
+      "loss": 1.1628,
+      "step": 600
+    },
+    {
+      "epoch": 0.53,
+      "eval_loss": 1.158300757408142,
+      "eval_runtime": 426.2016,
+      "eval_samples_per_second": 37.93,
+      "eval_steps_per_second": 1.187,
+      "step": 600
+    },
+    {
+      "epoch": 0.53,
+      "learning_rate": 1.8954748051399153e-05,
+      "loss": 1.1337,
+      "step": 605
+    },
+    {
+      "epoch": 0.53,
+      "learning_rate": 1.893347882185814e-05,
+      "loss": 1.1455,
+      "step": 610
+    },
+    {
+      "epoch": 0.54,
+      "learning_rate": 1.891200754997219e-05,
+      "loss": 1.1667,
+      "step": 615
+    },
+    {
+      "epoch": 0.54,
+      "learning_rate": 1.88903347213423e-05,
+      "loss": 1.1419,
+      "step": 620
+    },
+    {
+      "epoch": 0.55,
+      "learning_rate": 1.886846082612792e-05,
+      "loss": 1.1458,
+      "step": 625
+    },
+    {
+      "epoch": 0.55,
+      "learning_rate": 1.8846386359035892e-05,
+      "loss": 1.1459,
+      "step": 630
+    },
+    {
+      "epoch": 0.56,
+      "learning_rate": 1.8824111819309256e-05,
+      "loss": 1.1676,
+      "step": 635
+    },
+    {
+      "epoch": 0.56,
+      "learning_rate": 1.8801637710715945e-05,
+      "loss": 1.1556,
+      "step": 640
+    },
+    {
+      "epoch": 0.57,
+      "learning_rate": 1.8778964541537422e-05,
+      "loss": 1.1544,
+      "step": 645
+    },
+    {
+      "epoch": 0.57,
+      "learning_rate": 1.8756092824557148e-05,
+      "loss": 1.1434,
+      "step": 650
+    },
+    {
+      "epoch": 0.57,
+      "learning_rate": 1.873302307704902e-05,
+      "loss": 1.1492,
+      "step": 655
+    },
+    {
+      "epoch": 0.58,
+      "learning_rate": 1.870975582076564e-05,
+      "loss": 1.1547,
+      "step": 660
+    },
+    {
+      "epoch": 0.58,
+      "learning_rate": 1.8686291581926546e-05,
+      "loss": 1.1438,
+      "step": 665
+    },
+    {
+      "epoch": 0.59,
+      "learning_rate": 1.8662630891206276e-05,
+      "loss": 1.1334,
+      "step": 670
+    },
+    {
+      "epoch": 0.59,
+      "learning_rate": 1.86387742837224e-05,
+      "loss": 1.1553,
+      "step": 675
+    },
+    {
+      "epoch": 0.6,
+      "learning_rate": 1.86147222990234e-05,
+      "loss": 1.1647,
+      "step": 680
+    },
+    {
+      "epoch": 0.6,
+      "learning_rate": 1.8590475481076468e-05,
+      "loss": 1.1443,
+      "step": 685
+    },
+    {
+      "epoch": 0.6,
+      "learning_rate": 1.8566034378255198e-05,
+      "loss": 1.1461,
+      "step": 690
+    },
+    {
+      "epoch": 0.61,
+      "learning_rate": 1.8541399543327206e-05,
+      "loss": 1.1391,
+      "step": 695
+    },
+    {
+      "epoch": 0.61,
+      "learning_rate": 1.8516571533441606e-05,
+      "loss": 1.1501,
+      "step": 700
+    },
+    {
+      "epoch": 0.61,
+      "eval_loss": 1.151345133781433,
+      "eval_runtime": 426.3067,
+      "eval_samples_per_second": 37.921,
+      "eval_steps_per_second": 1.187,
+      "step": 700
+    },
+    {
+      "epoch": 0.62,
+      "learning_rate": 1.8491550910116415e-05,
+      "loss": 1.1488,
+      "step": 705
+    },
+    {
+      "epoch": 0.62,
+      "learning_rate": 1.8466338239225862e-05,
+      "loss": 1.1213,
+      "step": 710
+    },
+    {
+      "epoch": 0.63,
+      "learning_rate": 1.8440934090987576e-05,
+      "loss": 1.1292,
+      "step": 715
+    },
+    {
+      "epoch": 0.63,
+      "learning_rate": 1.8415339039949702e-05,
+      "loss": 1.1585,
+      "step": 720
+    },
+    {
+      "epoch": 0.64,
+      "learning_rate": 1.8389553664977905e-05,
+      "loss": 1.1279,
+      "step": 725
+    },
+    {
+      "epoch": 0.64,
+      "learning_rate": 1.8363578549242266e-05,
+      "loss": 1.167,
+      "step": 730
+    },
+    {
+      "epoch": 0.64,
+      "learning_rate": 1.8337414280204116e-05,
+      "loss": 1.1522,
+      "step": 735
+    },
+    {
+      "epoch": 0.65,
+      "learning_rate": 1.8311061449602725e-05,
+      "loss": 1.143,
+      "step": 740
+    },
+    {
+      "epoch": 0.65,
+      "learning_rate": 1.8284520653441936e-05,
+      "loss": 1.1549,
+      "step": 745
+    },
+    {
+      "epoch": 0.66,
+      "learning_rate": 1.8257792491976676e-05,
+      "loss": 1.1412,
+      "step": 750
+    },
+    {
+      "epoch": 0.66,
+      "learning_rate": 1.8230877569699387e-05,
+      "loss": 1.1554,
+      "step": 755
+    },
+    {
+      "epoch": 0.67,
+      "learning_rate": 1.8203776495326346e-05,
+      "loss": 1.1423,
+      "step": 760
+    },
+    {
+      "epoch": 0.67,
+      "learning_rate": 1.8176489881783915e-05,
+      "loss": 1.1276,
+      "step": 765
+    },
+    {
+      "epoch": 0.67,
+      "learning_rate": 1.8149018346194655e-05,
+      "loss": 1.1276,
+      "step": 770
+    },
+    {
+      "epoch": 0.68,
+      "learning_rate": 1.8121362509863397e-05,
+      "loss": 1.1334,
+      "step": 775
+    },
+    {
+      "epoch": 0.68,
+      "learning_rate": 1.8093522998263154e-05,
+      "loss": 1.1267,
+      "step": 780
+    },
+    {
+      "epoch": 0.69,
+      "learning_rate": 1.8065500441021018e-05,
+      "loss": 1.1465,
+      "step": 785
+    },
+    {
+      "epoch": 0.69,
+      "learning_rate": 1.803729547190389e-05,
+      "loss": 1.1207,
+      "step": 790
+    },
+    {
+      "epoch": 0.7,
+      "learning_rate": 1.800890872880414e-05,
+      "loss": 1.1483,
+      "step": 795
+    },
+    {
+      "epoch": 0.7,
+      "learning_rate": 1.7980340853725223e-05,
+      "loss": 1.137,
+      "step": 800
+    },
+    {
+      "epoch": 0.7,
+      "eval_loss": 1.1456836462020874,
+      "eval_runtime": 426.0503,
+      "eval_samples_per_second": 37.944,
+      "eval_steps_per_second": 1.188,
+      "step": 800
+    },
+    {
+      "epoch": 0.71,
+      "learning_rate": 1.795159249276711e-05,
+      "loss": 1.1212,
+      "step": 805
+    },
+    {
+      "epoch": 0.71,
+      "learning_rate": 1.792266429611171e-05,
+      "loss": 1.1259,
+      "step": 810
+    },
+    {
+      "epoch": 0.71,
+      "learning_rate": 1.7893556918008136e-05,
+      "loss": 1.1232,
+      "step": 815
+    },
+    {
+      "epoch": 0.72,
+      "learning_rate": 1.7864271016757942e-05,
+      "loss": 1.1163,
+      "step": 820
+    },
+    {
+      "epoch": 0.72,
+      "learning_rate": 1.7834807254700212e-05,
+      "loss": 1.138,
+      "step": 825
+    },
+    {
+      "epoch": 0.73,
+      "learning_rate": 1.7805166298196577e-05,
+      "loss": 1.134,
+      "step": 830
+    },
+    {
+      "epoch": 0.73,
+      "learning_rate": 1.7775348817616164e-05,
+      "loss": 1.1575,
+      "step": 835
+    },
+    {
+      "epoch": 0.74,
+      "learning_rate": 1.7745355487320418e-05,
+      "loss": 1.138,
+      "step": 840
+    },
+    {
+      "epoch": 0.74,
+      "learning_rate": 1.7715186985647857e-05,
+      "loss": 1.1504,
+      "step": 845
+    },
+    {
+      "epoch": 0.74,
+      "learning_rate": 1.768484399489873e-05,
+      "loss": 1.1296,
+      "step": 850
+    },
+    {
+      "epoch": 0.75,
+      "learning_rate": 1.7654327201319584e-05,
+      "loss": 1.1413,
+      "step": 855
+    },
+    {
+      "epoch": 0.75,
+      "learning_rate": 1.762363729508775e-05,
+      "loss": 1.1365,
+      "step": 860
+    },
+    {
+      "epoch": 0.76,
+      "learning_rate": 1.7592774970295714e-05,
+      "loss": 1.1515,
+      "step": 865
+    },
+    {
+      "epoch": 0.76,
+      "learning_rate": 1.7561740924935456e-05,
+      "loss": 1.1423,
+      "step": 870
+    },
+    {
+      "epoch": 0.77,
+      "learning_rate": 1.753053586088263e-05,
+      "loss": 1.1244,
+      "step": 875
+    },
+    {
+      "epoch": 0.77,
+      "learning_rate": 1.7499160483880694e-05,
+      "loss": 1.1376,
+      "step": 880
+    },
+    {
+      "epoch": 0.78,
+      "learning_rate": 1.7467615503524973e-05,
+      "loss": 1.1232,
+      "step": 885
+    },
+    {
+      "epoch": 0.78,
+      "learning_rate": 1.7435901633246585e-05,
+      "loss": 1.1233,
+      "step": 890
+    },
+    {
+      "epoch": 0.78,
+      "learning_rate": 1.740401959029632e-05,
+      "loss": 1.1284,
+      "step": 895
+    },
+    {
+      "epoch": 0.79,
+      "learning_rate": 1.7371970095728408e-05,
+      "loss": 1.1321,
+      "step": 900
+    },
+    {
+      "epoch": 0.79,
+      "eval_loss": 1.140657663345337,
+      "eval_runtime": 424.8606,
+      "eval_samples_per_second": 38.05,
+      "eval_steps_per_second": 1.191,
+      "step": 900
+    },
+    {
+      "epoch": 0.79,
+      "learning_rate": 1.7339753874384218e-05,
+      "loss": 1.1389,
+      "step": 905
+    },
+    {
+      "epoch": 0.8,
+      "learning_rate": 1.730737165487587e-05,
+      "loss": 1.1325,
+      "step": 910
+    },
+    {
+      "epoch": 0.8,
+      "learning_rate": 1.7274824169569747e-05,
+      "loss": 1.1477,
+      "step": 915
+    },
+    {
+      "epoch": 0.81,
+      "learning_rate": 1.7242112154569928e-05,
+      "loss": 1.1233,
+      "step": 920
+    },
+    {
+      "epoch": 0.81,
+      "learning_rate": 1.7209236349701553e-05,
+      "loss": 1.1324,
+      "step": 925
+    },
+    {
+      "epoch": 0.81,
+      "learning_rate": 1.717619749849409e-05,
+      "loss": 1.1241,
+      "step": 930
+    },
+    {
+      "epoch": 0.82,
+      "learning_rate": 1.7142996348164508e-05,
+      "loss": 1.1471,
+      "step": 935
+    },
+    {
+      "epoch": 0.82,
+      "learning_rate": 1.710963364960038e-05,
+      "loss": 1.1388,
+      "step": 940
+    },
+    {
+      "epoch": 0.83,
+      "learning_rate": 1.707611015734291e-05,
+      "loss": 1.1375,
+      "step": 945
+    },
+    {
+      "epoch": 0.83,
+      "learning_rate": 1.704242662956986e-05,
+      "loss": 1.1476,
+      "step": 950
+    },
+    {
+      "epoch": 0.84,
+      "learning_rate": 1.700858382807841e-05,
+      "loss": 1.1454,
+      "step": 955
+    },
+    {
+      "epoch": 0.84,
+      "learning_rate": 1.6974582518267913e-05,
+      "loss": 1.1263,
+      "step": 960
+    },
+    {
+      "epoch": 0.85,
+      "learning_rate": 1.694042346912261e-05,
+      "loss": 1.1206,
+      "step": 965
+    },
+    {
+      "epoch": 0.85,
+      "learning_rate": 1.6906107453194207e-05,
+      "loss": 1.1315,
+      "step": 970
+    },
+    {
+      "epoch": 0.85,
+      "learning_rate": 1.687163524658444e-05,
+      "loss": 1.1444,
+      "step": 975
+    },
+    {
+      "epoch": 0.86,
+      "learning_rate": 1.6837007628927483e-05,
+      "loss": 1.1397,
+      "step": 980
+    },
+    {
+      "epoch": 0.86,
+      "learning_rate": 1.680222538337235e-05,
+      "loss": 1.1232,
+      "step": 985
+    },
+    {
+      "epoch": 0.87,
+      "learning_rate": 1.6767289296565155e-05,
+      "loss": 1.1276,
+      "step": 990
+    },
+    {
+      "epoch": 0.87,
+      "learning_rate": 1.6732200158631343e-05,
+      "loss": 1.1415,
+      "step": 995
+    },
+    {
+      "epoch": 0.88,
+      "learning_rate": 1.6696958763157808e-05,
+      "loss": 1.1156,
+      "step": 1000
+    },
+    {
+      "epoch": 0.88,
+      "eval_loss": 1.1359467506408691,
+      "eval_runtime": 426.3548,
+      "eval_samples_per_second": 37.917,
+      "eval_steps_per_second": 1.187,
+      "step": 1000
+    },
+    {
+      "epoch": 0.88,
+      "learning_rate": 1.666156590717495e-05,
+      "loss": 1.1168,
+      "step": 1005
+    },
+    {
+      "epoch": 0.88,
+      "learning_rate": 1.6626022391138643e-05,
+      "loss": 1.1237,
+      "step": 1010
+    },
+    {
+      "epoch": 0.89,
+      "learning_rate": 1.6590329018912134e-05,
+      "loss": 1.1189,
+      "step": 1015
+    },
+    {
+      "epoch": 0.89,
+      "learning_rate": 1.655448659774787e-05,
+      "loss": 1.1146,
+      "step": 1020
+    },
+    {
+      "epoch": 0.9,
+      "learning_rate": 1.6518495938269242e-05,
+      "loss": 1.135,
+      "step": 1025
+    },
+    {
+      "epoch": 0.9,
+      "learning_rate": 1.6482357854452223e-05,
+      "loss": 1.113,
+      "step": 1030
+    },
+    {
+      "epoch": 0.91,
+      "learning_rate": 1.6446073163607e-05,
+      "loss": 1.1233,
+      "step": 1035
+    },
+    {
+      "epoch": 0.91,
+      "learning_rate": 1.6409642686359472e-05,
+      "loss": 1.1344,
+      "step": 1040
+    },
+    {
+      "epoch": 0.92,
+      "learning_rate": 1.637306724663267e-05,
+      "loss": 1.1327,
+      "step": 1045
+    },
+    {
+      "epoch": 0.92,
+      "learning_rate": 1.6336347671628162e-05,
+      "loss": 1.1236,
+      "step": 1050
+    },
+    {
+      "epoch": 0.92,
+      "learning_rate": 1.629948479180731e-05,
+      "loss": 1.1192,
+      "step": 1055
+    },
+    {
+      "epoch": 0.93,
+      "learning_rate": 1.6262479440872505e-05,
+      "loss": 1.1621,
+      "step": 1060
+    },
+    {
+      "epoch": 0.93,
+      "learning_rate": 1.622533245574832e-05,
+      "loss": 1.1318,
+      "step": 1065
+    },
+    {
+      "epoch": 0.94,
+      "learning_rate": 1.618804467656256e-05,
+      "loss": 1.1231,
+      "step": 1070
+    },
+    {
+      "epoch": 0.94,
+      "learning_rate": 1.6150616946627272e-05,
+      "loss": 1.1166,
+      "step": 1075
+    },
+    {
+      "epoch": 0.95,
+      "learning_rate": 1.6113050112419683e-05,
+      "loss": 1.1252,
+      "step": 1080
+    },
+    {
+      "epoch": 0.95,
+      "learning_rate": 1.6075345023563035e-05,
+      "loss": 1.113,
+      "step": 1085
+    },
+    {
+      "epoch": 0.95,
+      "learning_rate": 1.6037502532807382e-05,
+      "loss": 1.1102,
+      "step": 1090
+    },
+    {
+      "epoch": 0.96,
+      "learning_rate": 1.599952349601031e-05,
+      "loss": 1.1273,
+      "step": 1095
+    },
+    {
+      "epoch": 0.96,
+      "learning_rate": 1.5961408772117567e-05,
+      "loss": 1.1395,
+      "step": 1100
+    },
+    {
+      "epoch": 0.96,
+      "eval_loss": 1.1318247318267822,
+      "eval_runtime": 426.4822,
+      "eval_samples_per_second": 37.905,
+      "eval_steps_per_second": 1.186,
+      "step": 1100
+    },
+    {
+      "epoch": 0.97,
+      "learning_rate": 1.592315922314364e-05,
+      "loss": 1.134,
+      "step": 1105
+    },
+    {
+      "epoch": 0.97,
+      "learning_rate": 1.588477571415226e-05,
+      "loss": 1.108,
+      "step": 1110
+    },
+    {
+      "epoch": 0.98,
+      "learning_rate": 1.5846259113236855e-05,
+      "loss": 1.103,
+      "step": 1115
+    },
+    {
+      "epoch": 0.98,
+      "learning_rate": 1.580761029150089e-05,
+      "loss": 1.1193,
+      "step": 1120
+    },
+    {
+      "epoch": 0.99,
+      "learning_rate": 1.5768830123038172e-05,
+      "loss": 1.1121,
+      "step": 1125
+    },
+    {
+      "epoch": 0.99,
+      "learning_rate": 1.57299194849131e-05,
+      "loss": 1.1311,
+      "step": 1130
+    },
+    {
+      "epoch": 0.99,
+      "learning_rate": 1.5690879257140804e-05,
+      "loss": 1.1179,
+      "step": 1135
+    },
+    {
+      "epoch": 1.0,
+      "learning_rate": 1.5651710322667262e-05,
+      "loss": 1.1305,
+      "step": 1140
+    },
+    {
+      "epoch": 1.0,
+      "learning_rate": 1.5612413567349314e-05,
+      "loss": 1.0956,
+      "step": 1145
+    },
+    {
+      "epoch": 1.01,
+      "learning_rate": 1.557298987993465e-05,
+      "loss": 1.0383,
+      "step": 1150
+    },
+    {
+      "epoch": 1.01,
+      "learning_rate": 1.553344015204168e-05,
+      "loss": 1.0692,
+      "step": 1155
+    },
+    {
+      "epoch": 1.02,
+      "learning_rate": 1.5493765278139397e-05,
+      "loss": 1.0767,
+      "step": 1160
+    },
+    {
+      "epoch": 1.02,
+      "learning_rate": 1.5453966155527133e-05,
+      "loss": 1.0617,
+      "step": 1165
+    },
+    {
+      "epoch": 1.02,
+      "learning_rate": 1.541404368431426e-05,
+      "loss": 1.075,
+      "step": 1170
+    },
+    {
+      "epoch": 1.03,
+      "learning_rate": 1.537399876739985e-05,
+      "loss": 1.0709,
+      "step": 1175
+    },
+    {
+      "epoch": 1.03,
+      "learning_rate": 1.5333832310452232e-05,
+      "loss": 1.0725,
+      "step": 1180
+    },
+    {
+      "epoch": 1.04,
+      "learning_rate": 1.5293545221888542e-05,
+      "loss": 1.071,
+      "step": 1185
+    },
+    {
+      "epoch": 1.04,
+      "learning_rate": 1.525313841285414e-05,
+      "loss": 1.0702,
+      "step": 1190
+    },
+    {
+      "epoch": 1.05,
+      "learning_rate": 1.5212612797202033e-05,
+      "loss": 1.0801,
+      "step": 1195
+    },
+    {
+      "epoch": 1.05,
+      "learning_rate": 1.517196929147219e-05,
+      "loss": 1.0564,
+      "step": 1200
+    },
+    {
+      "epoch": 1.05,
+      "eval_loss": 1.1314754486083984,
+      "eval_runtime": 425.7152,
+      "eval_samples_per_second": 37.974,
+      "eval_steps_per_second": 1.189,
+      "step": 1200
+    },
+    {
+      "epoch": 1.06,
+      "learning_rate": 1.5131208814870822e-05,
+      "loss": 1.0822,
+      "step": 1205
+    },
+    {
+      "epoch": 1.06,
+      "learning_rate": 1.5090332289249586e-05,
+      "loss": 1.0505,
+      "step": 1210
+    },
+    {
+      "epoch": 1.06,
+      "learning_rate": 1.5049340639084742e-05,
+      "loss": 1.0704,
+      "step": 1215
+    },
+    {
+      "epoch": 1.07,
+      "learning_rate": 1.5008234791456242e-05,
+      "loss": 1.0645,
+      "step": 1220
+    },
+    {
+      "epoch": 1.07,
+      "learning_rate": 1.4967015676026768e-05,
+      "loss": 1.0748,
+      "step": 1225
+    },
+    {
+      "epoch": 1.08,
+      "learning_rate": 1.4925684225020694e-05,
+      "loss": 1.0557,
+      "step": 1230
+    },
+    {
+      "epoch": 1.08,
+      "learning_rate": 1.4884241373203014e-05,
+      "loss": 1.0557,
+      "step": 1235
+    },
+    {
+      "epoch": 1.09,
+      "learning_rate": 1.4842688057858203e-05,
+      "loss": 1.0669,
+      "step": 1240
+    },
+    {
+      "epoch": 1.09,
+      "learning_rate": 1.4801025218769001e-05,
+      "loss": 1.0655,
+      "step": 1245
+    },
+    {
+      "epoch": 1.1,
+      "learning_rate": 1.4759253798195183e-05,
+      "loss": 1.0675,
+      "step": 1250
+    },
+    {
+      "epoch": 1.1,
+      "learning_rate": 1.4717374740852236e-05,
+      "loss": 1.0824,
+      "step": 1255
+    },
+    {
+      "epoch": 1.1,
+      "learning_rate": 1.467538899388998e-05,
+      "loss": 1.0723,
+      "step": 1260
+    },
+    {
+      "epoch": 1.11,
+      "learning_rate": 1.463329750687118e-05,
+      "loss": 1.0569,
+      "step": 1265
+    },
+    {
+      "epoch": 1.11,
+      "learning_rate": 1.459110123175004e-05,
+      "loss": 1.0472,
+      "step": 1270
+    },
+    {
+      "epoch": 1.12,
+      "learning_rate": 1.4548801122850682e-05,
+      "loss": 1.0633,
+      "step": 1275
+    },
+    {
+      "epoch": 1.12,
+      "learning_rate": 1.450639813684558e-05,
+      "loss": 1.0774,
+      "step": 1280
+    },
+    {
+      "epoch": 1.13,
+      "learning_rate": 1.4463893232733886e-05,
+      "loss": 1.0695,
+      "step": 1285
+    },
+    {
+      "epoch": 1.13,
+      "learning_rate": 1.4421287371819781e-05,
+      "loss": 1.0711,
+      "step": 1290
+    },
+    {
+      "epoch": 1.13,
+      "learning_rate": 1.4378581517690711e-05,
+      "loss": 1.0562,
+      "step": 1295
+    },
+    {
+      "epoch": 1.14,
+      "learning_rate": 1.4335776636195605e-05,
+      "loss": 1.0594,
+      "step": 1300
+    },
+    {
+      "epoch": 1.14,
+      "eval_loss": 1.1295197010040283,
+      "eval_runtime": 425.2423,
+      "eval_samples_per_second": 38.016,
+      "eval_steps_per_second": 1.19,
+      "step": 1300
+    },
+    {
+      "epoch": 1.14,
+      "learning_rate": 1.4292873695423012e-05,
+      "loss": 1.0657,
+      "step": 1305
+    },
+    {
+      "epoch": 1.15,
+      "learning_rate": 1.4249873665679241e-05,
+      "loss": 1.0535,
+      "step": 1310
+    },
+    {
+      "epoch": 1.15,
+      "learning_rate": 1.4206777519466375e-05,
+      "loss": 1.0706,
+      "step": 1315
+    },
+    {
+      "epoch": 1.16,
+      "learning_rate": 1.4163586231460307e-05,
+      "loss": 1.0553,
+      "step": 1320
+    },
+    {
+      "epoch": 1.16,
+      "learning_rate": 1.4120300778488687e-05,
+      "loss": 1.068,
+      "step": 1325
+    },
+    {
+      "epoch": 1.17,
+      "learning_rate": 1.4076922139508828e-05,
+      "loss": 1.0535,
+      "step": 1330
+    },
+    {
+      "epoch": 1.17,
+      "learning_rate": 1.4033451295585565e-05,
+      "loss": 1.0633,
+      "step": 1335
+    },
+    {
+      "epoch": 1.17,
+      "learning_rate": 1.3989889229869071e-05,
+      "loss": 1.0646,
+      "step": 1340
+    },
+    {
+      "epoch": 1.18,
+      "learning_rate": 1.394623692757262e-05,
+      "loss": 1.0881,
+      "step": 1345
+    },
+    {
+      "epoch": 1.18,
+      "learning_rate": 1.3902495375950303e-05,
+      "loss": 1.0478,
+      "step": 1350
+    },
+    {
+      "epoch": 1.19,
+      "learning_rate": 1.3858665564274699e-05,
+      "loss": 1.0718,
+      "step": 1355
+    },
+    {
+      "epoch": 1.19,
+      "learning_rate": 1.3814748483814511e-05,
+      "loss": 1.0504,
+      "step": 1360
+    },
+    {
+      "epoch": 1.2,
+      "learning_rate": 1.3770745127812134e-05,
+      "loss": 1.0751,
+      "step": 1365
+    },
+    {
+      "epoch": 1.2,
+      "learning_rate": 1.3726656491461196e-05,
+      "loss": 1.0644,
+      "step": 1370
+    },
+    {
+      "epoch": 1.2,
+      "learning_rate": 1.3682483571884064e-05,
+      "loss": 1.0691,
+      "step": 1375
+    },
+    {
+      "epoch": 1.21,
+      "learning_rate": 1.3638227368109268e-05,
+      "loss": 1.067,
+      "step": 1380
+    },
+    {
+      "epoch": 1.21,
+      "learning_rate": 1.3593888881048922e-05,
+      "loss": 1.06,
+      "step": 1385
+    },
+    {
+      "epoch": 1.22,
+      "learning_rate": 1.3549469113476087e-05,
+      "loss": 1.0621,
+      "step": 1390
+    },
+    {
+      "epoch": 1.22,
+      "learning_rate": 1.3504969070002091e-05,
+      "loss": 1.0634,
+      "step": 1395
+    },
+    {
+      "epoch": 1.23,
+      "learning_rate": 1.3460389757053802e-05,
+      "loss": 1.0711,
+      "step": 1400
+    },
+    {
+      "epoch": 1.23,
+      "eval_loss": 1.1273547410964966,
+      "eval_runtime": 424.8164,
+      "eval_samples_per_second": 38.054,
+      "eval_steps_per_second": 1.191,
+      "step": 1400
+    },
+    {
+      "epoch": 1.23,
+      "learning_rate": 1.3415732182850873e-05,
+      "loss": 1.0606,
+      "step": 1405
+    },
+    {
+      "epoch": 1.24,
+      "learning_rate": 1.3370997357382943e-05,
+      "loss": 1.0958,
+      "step": 1410
+    },
+    {
+      "epoch": 1.24,
+      "learning_rate": 1.3326186292386778e-05,
+      "loss": 1.069,
+      "step": 1415
+    },
+    {
+      "epoch": 1.24,
+      "learning_rate": 1.3281300001323416e-05,
+      "loss": 1.071,
+      "step": 1420
+    },
+    {
+      "epoch": 1.25,
+      "learning_rate": 1.3236339499355217e-05,
+      "loss": 1.071,
+      "step": 1425
+    },
+    {
+      "epoch": 1.25,
+      "learning_rate": 1.3191305803322929e-05,
+      "loss": 1.0537,
+      "step": 1430
+    },
+    {
+      "epoch": 1.26,
+      "learning_rate": 1.3146199931722674e-05,
+      "loss": 1.0743,
+      "step": 1435
+    },
+    {
+      "epoch": 1.26,
+      "learning_rate": 1.3101022904682918e-05,
+      "loss": 1.0541,
+      "step": 1440
+    },
+    {
+      "epoch": 1.27,
+      "learning_rate": 1.3055775743941409e-05,
+      "loss": 1.0694,
+      "step": 1445
+    },
+    {
+      "epoch": 1.27,
+      "learning_rate": 1.3010459472822046e-05,
+      "loss": 1.0468,
+      "step": 1450
+    },
+    {
+      "epoch": 1.27,
+      "learning_rate": 1.2965075116211769e-05,
+      "loss": 1.0636,
+      "step": 1455
+    },
+    {
+      "epoch": 1.28,
+      "learning_rate": 1.2919623700537342e-05,
+      "loss": 1.0709,
+      "step": 1460
+    },
+    {
+      "epoch": 1.28,
+      "learning_rate": 1.287410625374217e-05,
+      "loss": 1.0631,
+      "step": 1465
+    },
+    {
+      "epoch": 1.29,
+      "learning_rate": 1.282852380526303e-05,
+      "loss": 1.0554,
+      "step": 1470
+    },
+    {
+      "epoch": 1.29,
+      "learning_rate": 1.2782877386006807e-05,
+      "loss": 1.0683,
+      "step": 1475
+    },
+    {
+      "epoch": 1.3,
+      "learning_rate": 1.2737168028327163e-05,
+      "loss": 1.0509,
+      "step": 1480
+    },
+    {
+      "epoch": 1.3,
+      "learning_rate": 1.2691396766001192e-05,
+      "loss": 1.0449,
+      "step": 1485
+    },
+    {
+      "epoch": 1.31,
+      "learning_rate": 1.2645564634206054e-05,
+      "loss": 1.0571,
+      "step": 1490
+    },
+    {
+      "epoch": 1.31,
+      "learning_rate": 1.2599672669495537e-05,
+      "loss": 1.0684,
+      "step": 1495
+    },
+    {
+      "epoch": 1.31,
+      "learning_rate": 1.2553721909776644e-05,
+      "loss": 1.0624,
+      "step": 1500
+    },
+    {
+      "epoch": 1.31,
+      "eval_loss": 1.125585675239563,
+      "eval_runtime": 426.6579,
+      "eval_samples_per_second": 37.89,
+      "eval_steps_per_second": 1.186,
+      "step": 1500
+    },
+    {
+      "epoch": 1.32,
+      "learning_rate": 1.2507713394286088e-05,
+      "loss": 1.0529,
+      "step": 1505
+    },
+    {
+      "epoch": 1.32,
+      "learning_rate": 1.246164816356682e-05,
+      "loss": 1.0729,
+      "step": 1510
+    },
+    {
+      "epoch": 1.33,
+      "learning_rate": 1.2415527259444471e-05,
+      "loss": 1.0738,
+      "step": 1515
+    },
+    {
+      "epoch": 1.33,
+      "learning_rate": 1.2369351725003802e-05,
+      "loss": 1.0858,
+      "step": 1520
+    },
+    {
+      "epoch": 1.34,
+      "learning_rate": 1.232312260456511e-05,
+      "loss": 1.0608,
+      "step": 1525
+    },
+    {
+      "epoch": 1.34,
+      "learning_rate": 1.2276840943660613e-05,
+      "loss": 1.0667,
+      "step": 1530
+    },
+    {
+      "epoch": 1.34,
+      "learning_rate": 1.2230507789010792e-05,
+      "loss": 1.0672,
+      "step": 1535
+    },
+    {
+      "epoch": 1.35,
+      "learning_rate": 1.2184124188500735e-05,
+      "loss": 1.0576,
+      "step": 1540
+    },
+    {
+      "epoch": 1.35,
+      "learning_rate": 1.2137691191156425e-05,
+      "loss": 1.049,
+      "step": 1545
+    },
+    {
+      "epoch": 1.36,
+      "learning_rate": 1.209120984712102e-05,
+      "loss": 1.0601,
+      "step": 1550
+    },
+    {
+      "epoch": 1.36,
+      "learning_rate": 1.2044681207631104e-05,
+      "loss": 1.0605,
+      "step": 1555
+    },
+    {
+      "epoch": 1.37,
+      "learning_rate": 1.1998106324992906e-05,
+      "loss": 1.0784,
+      "step": 1560
+    },
+    {
+      "epoch": 1.37,
+      "learning_rate": 1.1951486252558508e-05,
+      "loss": 1.0623,
+      "step": 1565
+    },
+    {
+      "epoch": 1.38,
+      "learning_rate": 1.1904822044702017e-05,
+      "loss": 1.0658,
+      "step": 1570
+    },
+    {
+      "epoch": 1.38,
+      "learning_rate": 1.1858114756795718e-05,
+      "loss": 1.0739,
+      "step": 1575
+    },
+    {
+      "epoch": 1.38,
+      "learning_rate": 1.1811365445186213e-05,
+      "loss": 1.073,
+      "step": 1580
+    },
+    {
+      "epoch": 1.39,
+      "learning_rate": 1.1764575167170525e-05,
+      "loss": 1.0548,
+      "step": 1585
+    },
+    {
+      "epoch": 1.39,
+      "learning_rate": 1.1717744980972178e-05,
+      "loss": 1.0725,
+      "step": 1590
+    },
+    {
+      "epoch": 1.4,
+      "learning_rate": 1.1670875945717282e-05,
+      "loss": 1.0649,
+      "step": 1595
+    },
+    {
+      "epoch": 1.4,
+      "learning_rate": 1.1623969121410563e-05,
+      "loss": 1.0652,
+      "step": 1600
+    },
+    {
+      "epoch": 1.4,
+      "eval_loss": 1.1232975721359253,
+      "eval_runtime": 426.1914,
+      "eval_samples_per_second": 37.931,
+      "eval_steps_per_second": 1.187,
+      "step": 1600
+    },
+    {
+      "epoch": 1.41,
+      "learning_rate": 1.1577025568911395e-05,
+      "loss": 1.0705,
+      "step": 1605
+    },
+    {
+      "epoch": 1.41,
+      "learning_rate": 1.1530046349909816e-05,
+      "loss": 1.0584,
+      "step": 1610
+    },
+    {
+      "epoch": 1.41,
+      "learning_rate": 1.1483032526902502e-05,
+      "loss": 1.0655,
+      "step": 1615
+    },
+    {
+      "epoch": 1.42,
+      "learning_rate": 1.1435985163168745e-05,
+      "loss": 1.0515,
+      "step": 1620
+    },
+    {
+      "epoch": 1.42,
+      "learning_rate": 1.1388905322746406e-05,
+      "loss": 1.071,
+      "step": 1625
+    },
+    {
+      "epoch": 1.43,
+      "learning_rate": 1.1341794070407847e-05,
+      "loss": 1.064,
+      "step": 1630
+    },
+    {
+      "epoch": 1.43,
+      "learning_rate": 1.1294652471635857e-05,
+      "loss": 1.0576,
+      "step": 1635
+    },
+    {
+      "epoch": 1.44,
+      "learning_rate": 1.124748159259954e-05,
+      "loss": 1.0586,
+      "step": 1640
+    },
+    {
+      "epoch": 1.44,
+      "learning_rate": 1.1200282500130222e-05,
+      "loss": 1.0596,
+      "step": 1645
+    },
+    {
+      "epoch": 1.45,
+      "learning_rate": 1.1153056261697303e-05,
+      "loss": 1.0633,
+      "step": 1650
+    },
+    {
+      "epoch": 1.45,
+      "learning_rate": 1.1105803945384134e-05,
+      "loss": 1.0529,
+      "step": 1655
+    },
+    {
+      "epoch": 1.45,
+      "learning_rate": 1.1058526619863846e-05,
+      "loss": 1.0574,
+      "step": 1660
+    },
+    {
+      "epoch": 1.46,
+      "learning_rate": 1.1011225354375184e-05,
+      "loss": 1.0768,
+      "step": 1665
+    },
+    {
+      "epoch": 1.46,
+      "learning_rate": 1.0963901218698331e-05,
+      "loss": 1.061,
+      "step": 1670
+    },
+    {
+      "epoch": 1.47,
+      "learning_rate": 1.0916555283130714e-05,
+      "loss": 1.0585,
+      "step": 1675
+    },
+    {
+      "epoch": 1.47,
+      "learning_rate": 1.0869188618462778e-05,
+      "loss": 1.0675,
+      "step": 1680
+    },
+    {
+      "epoch": 1.48,
+      "learning_rate": 1.0821802295953795e-05,
+      "loss": 1.0437,
+      "step": 1685
+    },
+    {
+      "epoch": 1.48,
+      "learning_rate": 1.0774397387307628e-05,
+      "loss": 1.059,
+      "step": 1690
+    },
+    {
+      "epoch": 1.48,
+      "learning_rate": 1.0726974964648478e-05,
+      "loss": 1.047,
+      "step": 1695
+    },
+    {
+      "epoch": 1.49,
+      "learning_rate": 1.0679536100496661e-05,
+      "loss": 1.0626,
+      "step": 1700
+    },
+    {
+      "epoch": 1.49,
+      "eval_loss": 1.1213114261627197,
+      "eval_runtime": 426.3267,
+      "eval_samples_per_second": 37.919,
+      "eval_steps_per_second": 1.187,
+      "step": 1700
+    },
+    {
+      "epoch": 1.49,
+      "learning_rate": 1.063208186774433e-05,
+      "loss": 1.0578,
+      "step": 1705
+    },
+    {
+      "epoch": 1.5,
+      "learning_rate": 1.0584613339631222e-05,
+      "loss": 1.0652,
+      "step": 1710
+    },
+    {
+      "epoch": 1.5,
+      "learning_rate": 1.0537131589720387e-05,
+      "loss": 1.0497,
+      "step": 1715
+    },
+    {
+      "epoch": 1.51,
+      "learning_rate": 1.0489637691873889e-05,
+      "loss": 1.0764,
+      "step": 1720
+    },
+    {
+      "epoch": 1.51,
+      "learning_rate": 1.0442132720228551e-05,
+      "loss": 1.071,
+      "step": 1725
+    },
+    {
+      "epoch": 1.52,
+      "learning_rate": 1.0394617749171636e-05,
+      "loss": 1.0666,
+      "step": 1730
+    },
+    {
+      "epoch": 1.52,
+      "learning_rate": 1.0347093853316555e-05,
+      "loss": 1.0495,
+      "step": 1735
+    },
+    {
+      "epoch": 1.52,
+      "learning_rate": 1.0299562107478569e-05,
+      "loss": 1.0489,
+      "step": 1740
+    },
+    {
+      "epoch": 1.53,
+      "learning_rate": 1.0252023586650476e-05,
+      "loss": 1.0737,
+      "step": 1745
+    },
+    {
+      "epoch": 1.53,
+      "learning_rate": 1.0204479365978298e-05,
+      "loss": 1.045,
+      "step": 1750
+    },
+    {
+      "epoch": 1.54,
+      "learning_rate": 1.0156930520736965e-05,
+      "loss": 1.0637,
+      "step": 1755
+    },
+    {
+      "epoch": 1.54,
+      "learning_rate": 1.0109378126306002e-05,
+      "loss": 1.0737,
+      "step": 1760
+    },
+    {
+      "epoch": 1.55,
+      "learning_rate": 1.00618232581452e-05,
+      "loss": 1.0626,
+      "step": 1765
+    },
+    {
+      "epoch": 1.55,
+      "learning_rate": 1.0014266991770299e-05,
+      "loss": 1.0483,
+      "step": 1770
+    },
+    {
+      "epoch": 1.55,
+      "learning_rate": 9.966710402728658e-06,
+      "loss": 1.0653,
+      "step": 1775
+    },
+    {
+      "epoch": 1.56,
+      "learning_rate": 9.919154566574942e-06,
+      "loss": 1.07,
+      "step": 1780
+    },
+    {
+      "epoch": 1.56,
+      "learning_rate": 9.871600558846772e-06,
+      "loss": 1.0668,
+      "step": 1785
+    },
+    {
+      "epoch": 1.57,
+      "learning_rate": 9.82404945504044e-06,
+      "loss": 1.0525,
+      "step": 1790
+    },
+    {
+      "epoch": 1.57,
+      "learning_rate": 9.776502330586535e-06,
+      "loss": 1.0578,
+      "step": 1795
+    },
+    {
+      "epoch": 1.58,
+      "learning_rate": 9.728960260825675e-06,
+      "loss": 1.0457,
+      "step": 1800
+    },
+    {
+      "epoch": 1.58,
+      "eval_loss": 1.1195377111434937,
+      "eval_runtime": 425.5901,
+      "eval_samples_per_second": 37.985,
+      "eval_steps_per_second": 1.189,
+      "step": 1800
+    },
+    {
+      "epoch": 1.58,
+      "learning_rate": 9.681424320984136e-06,
+      "loss": 1.0608,
+      "step": 1805
+    },
+    {
+      "epoch": 1.59,
+      "learning_rate": 9.633895586149575e-06,
+      "loss": 1.042,
+      "step": 1810
+    },
+    {
+      "epoch": 1.59,
+      "learning_rate": 9.586375131246688e-06,
+      "loss": 1.0456,
+      "step": 1815
+    },
+    {
+      "epoch": 1.59,
+      "learning_rate": 9.538864031012913e-06,
+      "loss": 1.0777,
+      "step": 1820
+    },
+    {
+      "epoch": 1.6,
+      "learning_rate": 9.491363359974121e-06,
+      "loss": 1.0497,
+      "step": 1825
+    },
+    {
+      "epoch": 1.6,
+      "learning_rate": 9.443874192420312e-06,
+      "loss": 1.0441,
+      "step": 1830
+    },
+    {
+      "epoch": 1.61,
+      "learning_rate": 9.396397602381318e-06,
+      "loss": 1.0767,
+      "step": 1835
+    },
+    {
+      "epoch": 1.61,
+      "learning_rate": 9.34893466360252e-06,
+      "loss": 1.0545,
+      "step": 1840
+    },
+    {
+      "epoch": 1.62,
+      "learning_rate": 9.301486449520543e-06,
+      "loss": 1.0691,
+      "step": 1845
+    },
+    {
+      "epoch": 1.62,
+      "learning_rate": 9.254054033239017e-06,
+      "loss": 1.0398,
+      "step": 1850
+    },
+    {
+      "epoch": 1.63,
+      "learning_rate": 9.206638487504265e-06,
+      "loss": 1.0498,
+      "step": 1855
+    },
+    {
+      "epoch": 1.63,
+      "learning_rate": 9.15924088468106e-06,
+      "loss": 1.0486,
+      "step": 1860
+    },
+    {
+      "epoch": 1.63,
+      "learning_rate": 9.11186229672839e-06,
+      "loss": 1.0574,
+      "step": 1865
+    },
+    {
+      "epoch": 1.64,
+      "learning_rate": 9.064503795175175e-06,
+      "loss": 1.06,
+      "step": 1870
+    },
+    {
+      "epoch": 1.64,
+      "learning_rate": 9.017166451096077e-06,
+      "loss": 1.0461,
+      "step": 1875
+    },
+    {
+      "epoch": 1.65,
+      "learning_rate": 8.969851335087233e-06,
+      "loss": 1.0605,
+      "step": 1880
+    },
+    {
+      "epoch": 1.65,
+      "learning_rate": 8.922559517242078e-06,
+      "loss": 1.0398,
+      "step": 1885
+    },
+    {
+      "epoch": 1.66,
+      "learning_rate": 8.87529206712712e-06,
+      "loss": 1.0581,
+      "step": 1890
+    },
+    {
+      "epoch": 1.66,
+      "learning_rate": 8.828050053757764e-06,
+      "loss": 1.0431,
+      "step": 1895
+    },
+    {
+      "epoch": 1.66,
+      "learning_rate": 8.780834545574122e-06,
+      "loss": 1.0665,
+      "step": 1900
+    },
+    {
+      "epoch": 1.66,
+      "eval_loss": 1.1177818775177002,
+      "eval_runtime": 425.4649,
+      "eval_samples_per_second": 37.996,
+      "eval_steps_per_second": 1.189,
+      "step": 1900
+    },
+    {
+      "epoch": 1.67,
+      "learning_rate": 8.73364661041687e-06,
+      "loss": 1.0675,
+      "step": 1905
+    },
+    {
+      "epoch": 1.67,
+      "learning_rate": 8.686487315503066e-06,
+      "loss": 1.0327,
+      "step": 1910
+    },
+    {
+      "epoch": 1.68,
+      "learning_rate": 8.63935772740205e-06,
+      "loss": 1.0395,
+      "step": 1915
+    },
+    {
+      "epoch": 1.68,
+      "learning_rate": 8.59225891201129e-06,
+      "loss": 1.0442,
+      "step": 1920
+    },
+    {
+      "epoch": 1.69,
+      "learning_rate": 8.545191934532294e-06,
+      "loss": 1.0605,
+      "step": 1925
+    },
+    {
+      "epoch": 1.69,
+      "learning_rate": 8.498157859446512e-06,
+      "loss": 1.0384,
+      "step": 1930
+    },
+    {
+      "epoch": 1.7,
+      "learning_rate": 8.451157750491265e-06,
+      "loss": 1.0631,
+      "step": 1935
+    },
+    {
+      "epoch": 1.7,
+      "learning_rate": 8.404192670635683e-06,
+      "loss": 1.0804,
+      "step": 1940
+    },
+    {
+      "epoch": 1.7,
+      "learning_rate": 8.35726368205667e-06,
+      "loss": 1.0556,
+      "step": 1945
+    },
+    {
+      "epoch": 1.71,
+      "learning_rate": 8.310371846114875e-06,
+      "loss": 1.0428,
+      "step": 1950
+    },
+    {
+      "epoch": 1.71,
+      "learning_rate": 8.263518223330698e-06,
+      "loss": 1.0596,
+      "step": 1955
+    },
+    {
+      "epoch": 1.72,
+      "learning_rate": 8.216703873360292e-06,
+      "loss": 1.0443,
+      "step": 1960
+    },
+    {
+      "epoch": 1.72,
+      "learning_rate": 8.169929854971598e-06,
+      "loss": 1.0637,
+      "step": 1965
+    },
+    {
+      "epoch": 1.73,
+      "learning_rate": 8.123197226020426e-06,
+      "loss": 1.0336,
+      "step": 1970
+    },
+    {
+      "epoch": 1.73,
+      "learning_rate": 8.076507043426482e-06,
+      "loss": 1.0734,
+      "step": 1975
+    },
+    {
+      "epoch": 1.73,
+      "learning_rate": 8.02986036314952e-06,
+      "loss": 1.0465,
+      "step": 1980
+    },
+    {
+      "epoch": 1.74,
+      "learning_rate": 7.983258240165406e-06,
+      "loss": 1.0622,
+      "step": 1985
+    },
+    {
+      "epoch": 1.74,
+      "learning_rate": 7.936701728442308e-06,
+      "loss": 1.0638,
+      "step": 1990
+    },
+    {
+      "epoch": 1.75,
+      "learning_rate": 7.890191880916813e-06,
+      "loss": 1.0572,
+      "step": 1995
+    },
+    {
+      "epoch": 1.75,
+      "learning_rate": 7.84372974947016e-06,
+      "loss": 1.07,
+      "step": 2000
+    },
+    {
+      "epoch": 1.75,
+      "eval_loss": 1.1158109903335571,
+      "eval_runtime": 425.626,
+      "eval_samples_per_second": 37.982,
+      "eval_steps_per_second": 1.189,
+      "step": 2000
+    },
+    {
+      "epoch": 1.76,
+      "learning_rate": 7.797316384904402e-06,
+      "loss": 1.0536,
+      "step": 2005
+    },
+    {
+      "epoch": 1.76,
+      "learning_rate": 7.750952836918679e-06,
+      "loss": 1.0543,
+      "step": 2010
+    },
+    {
+      "epoch": 1.77,
+      "learning_rate": 7.704640154085466e-06,
+      "loss": 1.06,
+      "step": 2015
+    },
+    {
+      "epoch": 1.77,
+      "learning_rate": 7.658379383826841e-06,
+      "loss": 1.0623,
+      "step": 2020
+    },
+    {
+      "epoch": 1.77,
+      "learning_rate": 7.612171572390834e-06,
+      "loss": 1.0611,
+      "step": 2025
+    },
+    {
+      "epoch": 1.78,
+      "learning_rate": 7.566017764827717e-06,
+      "loss": 1.0635,
+      "step": 2030
+    },
+    {
+      "epoch": 1.78,
+      "learning_rate": 7.519919004966414e-06,
+      "loss": 1.0583,
+      "step": 2035
+    },
+    {
+      "epoch": 1.79,
+      "learning_rate": 7.473876335390857e-06,
+      "loss": 1.0371,
+      "step": 2040
+    },
+    {
+      "epoch": 1.79,
+      "learning_rate": 7.427890797416435e-06,
+      "loss": 1.0538,
+      "step": 2045
+    },
+    {
+      "epoch": 1.8,
+      "learning_rate": 7.3819634310664224e-06,
+      "loss": 1.0404,
+      "step": 2050
+    },
+    {
+      "epoch": 1.8,
+      "learning_rate": 7.336095275048474e-06,
+      "loss": 1.0607,
+      "step": 2055
+    },
+    {
+      "epoch": 1.8,
+      "learning_rate": 7.29028736673111e-06,
+      "loss": 1.0592,
+      "step": 2060
+    },
+    {
+      "epoch": 1.81,
+      "learning_rate": 7.244540742120294e-06,
+      "loss": 1.0323,
+      "step": 2065
+    },
+    {
+      "epoch": 1.81,
+      "learning_rate": 7.1988564358359566e-06,
+      "loss": 1.0516,
+      "step": 2070
+    },
+    {
+      "epoch": 1.82,
+      "learning_rate": 7.153235481088624e-06,
+      "loss": 1.0695,
+      "step": 2075
+    },
+    {
+      "epoch": 1.82,
+      "learning_rate": 7.107678909656052e-06,
+      "loss": 1.0659,
+      "step": 2080
+    },
+    {
+      "epoch": 1.83,
+      "learning_rate": 7.062187751859868e-06,
+      "loss": 1.0667,
+      "step": 2085
+    },
+    {
+      "epoch": 1.83,
+      "learning_rate": 7.016763036542305e-06,
+      "loss": 1.0574,
+      "step": 2090
+    },
+    {
+      "epoch": 1.84,
+      "learning_rate": 6.971405791042889e-06,
+      "loss": 1.0494,
+      "step": 2095
+    },
+    {
+      "epoch": 1.84,
+      "learning_rate": 6.92611704117525e-06,
+      "loss": 1.0567,
+      "step": 2100
+    },
+    {
+      "epoch": 1.84,
+      "eval_loss": 1.114147663116455,
+      "eval_runtime": 424.5226,
+      "eval_samples_per_second": 38.08,
+      "eval_steps_per_second": 1.192,
+      "step": 2100
+    },
+    {
+      "epoch": 1.84,
+      "learning_rate": 6.880897811203877e-06,
+      "loss": 1.0624,
+      "step": 2105
+    },
+    {
+      "epoch": 1.85,
+      "learning_rate": 6.835749123820997e-06,
+      "loss": 1.048,
+      "step": 2110
+    },
+    {
+      "epoch": 1.85,
+      "learning_rate": 6.790672000123405e-06,
+      "loss": 1.0783,
+      "step": 2115
+    },
+    {
+      "epoch": 1.86,
+      "learning_rate": 6.7456674595894065e-06,
+      "loss": 1.0464,
+      "step": 2120
+    },
+    {
+      "epoch": 1.86,
+      "learning_rate": 6.700736520055725e-06,
+      "loss": 1.0437,
+      "step": 2125
+    },
+    {
+      "epoch": 1.87,
+      "learning_rate": 6.6558801976945206e-06,
+      "loss": 1.0552,
+      "step": 2130
+    },
+    {
+      "epoch": 1.87,
+      "learning_rate": 6.611099506990372e-06,
+      "loss": 1.0622,
+      "step": 2135
+    },
+    {
+      "epoch": 1.87,
+      "learning_rate": 6.566395460717356e-06,
+      "loss": 1.0519,
+      "step": 2140
+    },
+    {
+      "epoch": 1.88,
+      "learning_rate": 6.521769069916136e-06,
+      "loss": 1.0433,
+      "step": 2145
+    },
+    {
+      "epoch": 1.88,
+      "learning_rate": 6.477221343871088e-06,
+      "loss": 1.0578,
+      "step": 2150
+    },
+    {
+      "epoch": 1.89,
+      "learning_rate": 6.4327532900874945e-06,
+      "loss": 1.0628,
+      "step": 2155
+    },
+    {
+      "epoch": 1.89,
+      "learning_rate": 6.38836591426873e-06,
+      "loss": 1.0376,
+      "step": 2160
+    },
+    {
+      "epoch": 1.9,
+      "learning_rate": 6.344060220293542e-06,
+      "loss": 1.056,
+      "step": 2165
+    },
+    {
+      "epoch": 1.9,
+      "learning_rate": 6.299837210193331e-06,
+      "loss": 1.0485,
+      "step": 2170
+    },
+    {
+      "epoch": 1.91,
+      "learning_rate": 6.255697884129495e-06,
+      "loss": 1.073,
+      "step": 2175
+    },
+    {
+      "epoch": 1.91,
+      "learning_rate": 6.2116432403708015e-06,
+      "loss": 1.0604,
+      "step": 2180
+    },
+    {
+      "epoch": 1.91,
+      "learning_rate": 6.167674275270832e-06,
+      "loss": 1.0579,
+      "step": 2185
+    },
+    {
+      "epoch": 1.92,
+      "learning_rate": 6.123791983245411e-06,
+      "loss": 1.0493,
+      "step": 2190
+    },
+    {
+      "epoch": 1.92,
+      "learning_rate": 6.0799973567501616e-06,
+      "loss": 1.0583,
+      "step": 2195
+    },
+    {
+      "epoch": 1.93,
+      "learning_rate": 6.036291386258013e-06,
+      "loss": 1.0304,
+      "step": 2200
+    },
+    {
+      "epoch": 1.93,
+      "eval_loss": 1.1127439737319946,
+      "eval_runtime": 425.0783,
+      "eval_samples_per_second": 38.031,
+      "eval_steps_per_second": 1.19,
+      "step": 2200
+    },
+    {
+      "epoch": 1.93,
+      "learning_rate": 5.992675060236841e-06,
+      "loss": 1.0728,
+      "step": 2205
+    },
+    {
+      "epoch": 1.94,
+      "learning_rate": 5.94914936512708e-06,
+      "loss": 1.0472,
+      "step": 2210
+    },
+    {
+      "epoch": 1.94,
+      "learning_rate": 5.905715285319442e-06,
+      "loss": 1.0555,
+      "step": 2215
+    },
+    {
+      "epoch": 1.94,
+      "learning_rate": 5.862373803132625e-06,
+      "loss": 1.067,
+      "step": 2220
+    },
+    {
+      "epoch": 1.95,
+      "learning_rate": 5.819125898791115e-06,
+      "loss": 1.0504,
+      "step": 2225
+    },
+    {
+      "epoch": 1.95,
+      "learning_rate": 5.775972550403015e-06,
+      "loss": 1.0541,
+      "step": 2230
+    },
+    {
+      "epoch": 1.96,
+      "learning_rate": 5.732914733937917e-06,
+      "loss": 1.0508,
+      "step": 2235
+    },
+    {
+      "epoch": 1.96,
+      "learning_rate": 5.6899534232048395e-06,
+      "loss": 1.0763,
+      "step": 2240
+    },
+    {
+      "epoch": 1.97,
+      "learning_rate": 5.647089589830186e-06,
+      "loss": 1.0592,
+      "step": 2245
+    },
+    {
+      "epoch": 1.97,
+      "learning_rate": 5.604324203235798e-06,
+      "loss": 1.0535,
+      "step": 2250
+    },
+    {
+      "epoch": 1.98,
+      "learning_rate": 5.561658230616997e-06,
+      "loss": 1.0667,
+      "step": 2255
+    },
+    {
+      "epoch": 1.98,
+      "learning_rate": 5.519092636920741e-06,
+      "loss": 1.05,
+      "step": 2260
+    },
+    {
+      "epoch": 1.98,
+      "learning_rate": 5.476628384823773e-06,
+      "loss": 1.0721,
+      "step": 2265
+    },
+    {
+      "epoch": 1.99,
+      "learning_rate": 5.434266434710879e-06,
+      "loss": 1.0546,
+      "step": 2270
+    },
+    {
+      "epoch": 1.99,
+      "learning_rate": 5.392007744653134e-06,
+      "loss": 1.0448,
+      "step": 2275
+    },
+    {
+      "epoch": 2.0,
+      "learning_rate": 5.3498532703862685e-06,
+      "loss": 1.0486,
+      "step": 2280
+    },
+    {
+      "epoch": 2.0,
+      "learning_rate": 5.307803965289023e-06,
+      "loss": 1.036,
+      "step": 2285
+    },
+    {
+      "epoch": 2.01,
+      "learning_rate": 5.265860780361602e-06,
+      "loss": 0.9944,
+      "step": 2290
+    },
+    {
+      "epoch": 2.01,
+      "learning_rate": 5.2240246642041705e-06,
+      "loss": 0.9918,
+      "step": 2295
+    },
+    {
+      "epoch": 2.01,
+      "learning_rate": 5.182296562995383e-06,
+      "loss": 1.0132,
+      "step": 2300
+    },
+    {
+      "epoch": 2.01,
+      "eval_loss": 1.1170079708099365,
+      "eval_runtime": 424.7277,
+      "eval_samples_per_second": 38.062,
+      "eval_steps_per_second": 1.191,
+      "step": 2300
+    },
+    {
+      "epoch": 2.02,
+      "learning_rate": 5.140677420471003e-06,
+      "loss": 1.0045,
+      "step": 2305
+    },
+    {
+      "epoch": 2.02,
+      "learning_rate": 5.099168177902539e-06,
+      "loss": 1.0096,
+      "step": 2310
+    },
+    {
+      "epoch": 2.03,
+      "learning_rate": 5.057769774075985e-06,
+      "loss": 1.0135,
+      "step": 2315
+    },
+    {
+      "epoch": 2.03,
+      "learning_rate": 5.0164831452705494e-06,
+      "loss": 1.015,
+      "step": 2320
+    },
+    {
+      "epoch": 2.04,
+      "learning_rate": 4.9753092252375245e-06,
+      "loss": 1.008,
+      "step": 2325
+    },
+    {
+      "epoch": 2.04,
+      "learning_rate": 4.934248945179127e-06,
+      "loss": 1.0101,
+      "step": 2330
+    },
+    {
+      "epoch": 2.05,
+      "learning_rate": 4.893303233727472e-06,
+      "loss": 1.0,
+      "step": 2335
+    },
+    {
+      "epoch": 2.05,
+      "learning_rate": 4.8524730169235404e-06,
+      "loss": 1.0187,
+      "step": 2340
+    },
+    {
+      "epoch": 2.05,
+      "learning_rate": 4.811759218196262e-06,
+      "loss": 1.009,
+      "step": 2345
+    },
+    {
+      "epoch": 2.06,
+      "learning_rate": 4.771162758341612e-06,
+      "loss": 1.0071,
+      "step": 2350
+    },
+    {
+      "epoch": 2.06,
+      "learning_rate": 4.730684555501799e-06,
+      "loss": 1.0141,
+      "step": 2355
+    },
+    {
+      "epoch": 2.07,
+      "learning_rate": 4.690325525144488e-06,
+      "loss": 1.0091,
+      "step": 2360
+    },
+    {
+      "epoch": 2.07,
+      "learning_rate": 4.6500865800421015e-06,
+      "loss": 1.0098,
+      "step": 2365
+    },
+    {
+      "epoch": 2.08,
+      "learning_rate": 4.609968630251187e-06,
+      "loss": 1.0056,
+      "step": 2370
+    },
+    {
+      "epoch": 2.08,
+      "learning_rate": 4.569972583091807e-06,
+      "loss": 0.9974,
+      "step": 2375
+    },
+    {
+      "epoch": 2.08,
+      "learning_rate": 4.5300993431270565e-06,
+      "loss": 1.0151,
+      "step": 2380
+    },
+    {
+      "epoch": 2.09,
+      "learning_rate": 4.490349812142564e-06,
+      "loss": 1.0208,
+      "step": 2385
+    },
+    {
+      "epoch": 2.09,
+      "learning_rate": 4.450724889126135e-06,
+      "loss": 1.0104,
+      "step": 2390
+    },
+    {
+      "epoch": 2.1,
+      "learning_rate": 4.411225470247387e-06,
+      "loss": 0.9955,
+      "step": 2395
+    },
+    {
+      "epoch": 2.1,
+      "learning_rate": 4.371852448837511e-06,
+      "loss": 1.0203,
+      "step": 2400
+    },
+    {
+      "epoch": 2.1,
+      "eval_loss": 1.1169644594192505,
+      "eval_runtime": 424.5951,
+      "eval_samples_per_second": 38.074,
+      "eval_steps_per_second": 1.192,
+      "step": 2400
+    },
+    {
+      "epoch": 2.11,
+      "learning_rate": 4.332606715369041e-06,
+      "loss": 1.0023,
+      "step": 2405
+    },
+    {
+      "epoch": 2.11,
+      "learning_rate": 4.2934891574357375e-06,
+      "loss": 0.9944,
+      "step": 2410
+    },
+    {
+      "epoch": 2.12,
+      "learning_rate": 4.254500659732496e-06,
+      "loss": 1.015,
+      "step": 2415
+    },
+    {
+      "epoch": 2.12,
+      "learning_rate": 4.2156421040353435e-06,
+      "loss": 1.0193,
+      "step": 2420
+    },
+    {
+      "epoch": 2.12,
+      "learning_rate": 4.1769143691815095e-06,
+      "loss": 1.0124,
+      "step": 2425
+    },
+    {
+      "epoch": 2.13,
+      "learning_rate": 4.138318331049525e-06,
+      "loss": 1.0151,
+      "step": 2430
+    },
+    {
+      "epoch": 2.13,
+      "learning_rate": 4.09985486253944e-06,
+      "loss": 0.9957,
+      "step": 2435
+    },
+    {
+      "epoch": 2.14,
+      "learning_rate": 4.061524833553058e-06,
+      "loss": 1.0116,
+      "step": 2440
+    },
+    {
+      "epoch": 2.14,
+      "learning_rate": 4.0233291109742726e-06,
+      "loss": 1.0087,
+      "step": 2445
+    },
+    {
+      "epoch": 2.15,
+      "learning_rate": 3.985268558649472e-06,
+      "loss": 0.991,
+      "step": 2450
+    },
+    {
+      "epoch": 2.15,
+      "learning_rate": 3.947344037367983e-06,
+      "loss": 1.0072,
+      "step": 2455
+    },
+    {
+      "epoch": 2.16,
+      "learning_rate": 3.909556404842609e-06,
+      "loss": 0.9968,
+      "step": 2460
+    },
+    {
+      "epoch": 2.16,
+      "learning_rate": 3.871906515690249e-06,
+      "loss": 1.0264,
+      "step": 2465
+    },
+    {
+      "epoch": 2.16,
+      "learning_rate": 3.834395221412537e-06,
+      "loss": 1.0041,
+      "step": 2470
+    },
+    {
+      "epoch": 2.17,
+      "learning_rate": 3.797023370376618e-06,
+      "loss": 1.0179,
+      "step": 2475
+    },
+    {
+      "epoch": 2.17,
+      "learning_rate": 3.7597918077959306e-06,
+      "loss": 0.9973,
+      "step": 2480
+    },
+    {
+      "epoch": 2.18,
+      "learning_rate": 3.7227013757111197e-06,
+      "loss": 1.0187,
+      "step": 2485
+    },
+    {
+      "epoch": 2.18,
+      "learning_rate": 3.6857529129709655e-06,
+      "loss": 0.9903,
+      "step": 2490
+    },
+    {
+      "epoch": 2.19,
+      "learning_rate": 3.64894725521344e-06,
+      "loss": 1.0046,
+      "step": 2495
+    },
+    {
+      "epoch": 2.19,
+      "learning_rate": 3.61228523484678e-06,
+      "loss": 1.0088,
+      "step": 2500
+    },
+    {
+      "epoch": 2.19,
+      "eval_loss": 1.116758108139038,
+      "eval_runtime": 424.4029,
+      "eval_samples_per_second": 38.091,
+      "eval_steps_per_second": 1.192,
+      "step": 2500
+    },
+    {
+      "epoch": 2.19,
+      "learning_rate": 3.5757676810306775e-06,
+      "loss": 1.0017,
+      "step": 2505
+    },
+    {
+      "epoch": 2.2,
+      "learning_rate": 3.539395419657531e-06,
+      "loss": 1.012,
+      "step": 2510
+    },
+    {
+      "epoch": 2.2,
+      "learning_rate": 3.5031692733337475e-06,
+      "loss": 1.0044,
+      "step": 2515
+    },
+    {
+      "epoch": 2.21,
+      "learning_rate": 3.4670900613611656e-06,
+      "loss": 0.9957,
+      "step": 2520
+    },
+    {
+      "epoch": 2.21,
+      "learning_rate": 3.431158599718496e-06,
+      "loss": 1.0168,
+      "step": 2525
+    },
+    {
+      "epoch": 2.22,
+      "learning_rate": 3.3953757010428946e-06,
+      "loss": 1.0231,
+      "step": 2530
+    },
+    {
+      "epoch": 2.22,
+      "learning_rate": 3.359742174611558e-06,
+      "loss": 1.0059,
+      "step": 2535
+    },
+    {
+      "epoch": 2.23,
+      "learning_rate": 3.3242588263234467e-06,
+      "loss": 1.0014,
+      "step": 2540
+    },
+    {
+      "epoch": 2.23,
+      "learning_rate": 3.2889264586810323e-06,
+      "loss": 0.9925,
+      "step": 2545
+    },
+    {
+      "epoch": 2.23,
+      "learning_rate": 3.2537458707721735e-06,
+      "loss": 1.0068,
+      "step": 2550
+    },
+    {
+      "epoch": 2.24,
+      "learning_rate": 3.2187178582520206e-06,
+      "loss": 1.0192,
+      "step": 2555
+    },
+    {
+      "epoch": 2.24,
+      "learning_rate": 3.183843213325042e-06,
+      "loss": 0.9856,
+      "step": 2560
+    },
+    {
+      "epoch": 2.25,
+      "learning_rate": 3.149122724727083e-06,
+      "loss": 1.018,
+      "step": 2565
+    },
+    {
+      "epoch": 2.25,
+      "learning_rate": 3.1145571777075577e-06,
+      "loss": 1.0022,
+      "step": 2570
+    },
+    {
+      "epoch": 2.26,
+      "learning_rate": 3.080147354011659e-06,
+      "loss": 0.9909,
+      "step": 2575
+    },
+    {
+      "epoch": 2.26,
+      "learning_rate": 3.0458940318626963e-06,
+      "loss": 1.0082,
+      "step": 2580
+    },
+    {
+      "epoch": 2.26,
+      "learning_rate": 3.011797985944499e-06,
+      "loss": 1.0178,
+      "step": 2585
+    },
+    {
+      "epoch": 2.27,
+      "learning_rate": 2.977859987383874e-06,
+      "loss": 1.0055,
+      "step": 2590
+    },
+    {
+      "epoch": 2.27,
+      "learning_rate": 2.944080803733197e-06,
+      "loss": 0.9863,
+      "step": 2595
+    },
+    {
+      "epoch": 2.28,
+      "learning_rate": 2.9104611989530196e-06,
+      "loss": 1.002,
+      "step": 2600
+    },
+    {
+      "epoch": 2.28,
+      "eval_loss": 1.116153359413147,
+      "eval_runtime": 424.7781,
+      "eval_samples_per_second": 38.058,
+      "eval_steps_per_second": 1.191,
+      "step": 2600
+    },
+    {
+      "epoch": 2.28,
+      "learning_rate": 2.8770019333948197e-06,
+      "loss": 1.0141,
+      "step": 2605
+    },
+    {
+      "epoch": 2.29,
+      "learning_rate": 2.843703763783785e-06,
+      "loss": 1.0078,
+      "step": 2610
+    },
+    {
+      "epoch": 2.29,
+      "learning_rate": 2.810567443201717e-06,
+      "loss": 1.0025,
+      "step": 2615
+    },
+    {
+      "epoch": 2.3,
+      "learning_rate": 2.7775937210699754e-06,
+      "loss": 1.009,
+      "step": 2620
+    },
+    {
+      "epoch": 2.3,
+      "learning_rate": 2.7447833431325566e-06,
+      "loss": 0.9782,
+      "step": 2625
+    },
+    {
+      "epoch": 2.3,
+      "learning_rate": 2.712137051439202e-06,
+      "loss": 1.0158,
+      "step": 2630
+    },
+    {
+      "epoch": 2.31,
+      "learning_rate": 2.6796555843286375e-06,
+      "loss": 1.007,
+      "step": 2635
+    },
+    {
+      "epoch": 2.31,
+      "learning_rate": 2.6473396764118575e-06,
+      "loss": 1.0088,
+      "step": 2640
+    },
+    {
+      "epoch": 2.32,
+      "learning_rate": 2.6151900585555178e-06,
+      "loss": 1.0053,
+      "step": 2645
+    },
+    {
+      "epoch": 2.32,
+      "learning_rate": 2.583207457865413e-06,
+      "loss": 1.0002,
+      "step": 2650
+    },
+    {
+      "epoch": 2.33,
+      "learning_rate": 2.5513925976700217e-06,
+      "loss": 1.0031,
+      "step": 2655
+    },
+    {
+      "epoch": 2.33,
+      "learning_rate": 2.519746197504144e-06,
+      "loss": 1.0156,
+      "step": 2660
+    },
+    {
+      "epoch": 2.33,
+      "learning_rate": 2.488268973092649e-06,
+      "loss": 1.0093,
+      "step": 2665
+    },
+    {
+      "epoch": 2.34,
+      "learning_rate": 2.456961636334265e-06,
+      "loss": 1.0296,
+      "step": 2670
+    },
+    {
+      "epoch": 2.34,
+      "learning_rate": 2.425824895285488e-06,
+      "loss": 1.0007,
+      "step": 2675
+    },
+    {
+      "epoch": 2.35,
+      "learning_rate": 2.3948594541445735e-06,
+      "loss": 1.0107,
+      "step": 2680
+    },
+    {
+      "epoch": 2.35,
+      "learning_rate": 2.3640660132356e-06,
+      "loss": 0.9927,
+      "step": 2685
+    },
+    {
+      "epoch": 2.36,
+      "learning_rate": 2.333445268992639e-06,
+      "loss": 1.0004,
+      "step": 2690
+    },
+    {
+      "epoch": 2.36,
+      "learning_rate": 2.302997913943994e-06,
+      "loss": 1.014,
+      "step": 2695
+    },
+    {
+      "epoch": 2.37,
+      "learning_rate": 2.272724636696555e-06,
+      "loss": 1.0004,
+      "step": 2700
+    },
+    {
+      "epoch": 2.37,
+      "eval_loss": 1.1156811714172363,
+      "eval_runtime": 425.4077,
+      "eval_samples_per_second": 38.001,
+      "eval_steps_per_second": 1.189,
+      "step": 2700
+    },
+    {
+      "epoch": 2.37,
+      "learning_rate": 2.2426261219202006e-06,
+      "loss": 1.0019,
+      "step": 2705
+    },
+    {
+      "epoch": 2.37,
+      "learning_rate": 2.21270305033234e-06,
+      "loss": 1.0127,
+      "step": 2710
+    },
+    {
+      "epoch": 2.38,
+      "learning_rate": 2.1829560986824937e-06,
+      "loss": 1.0168,
+      "step": 2715
+    },
+    {
+      "epoch": 2.38,
+      "learning_rate": 2.1533859397370084e-06,
+      "loss": 1.0059,
+      "step": 2720
+    },
+    {
+      "epoch": 2.39,
+      "learning_rate": 2.1239932422638234e-06,
+      "loss": 1.0172,
+      "step": 2725
+    },
+    {
+      "epoch": 2.39,
+      "learning_rate": 2.0947786710173545e-06,
+      "loss": 1.0097,
+      "step": 2730
+    },
+    {
+      "epoch": 2.4,
+      "learning_rate": 2.06574288672347e-06,
+      "loss": 1.0079,
+      "step": 2735
+    },
+    {
+      "epoch": 2.4,
+      "learning_rate": 2.0368865460645202e-06,
+      "loss": 0.9919,
+      "step": 2740
+    },
+    {
+      "epoch": 2.4,
+      "learning_rate": 2.008210301664518e-06,
+      "loss": 1.0132,
+      "step": 2745
+    },
+    {
+      "epoch": 2.41,
+      "learning_rate": 1.9797148020743496e-06,
+      "loss": 1.0044,
+      "step": 2750
+    },
+    {
+      "epoch": 2.41,
+      "learning_rate": 1.951400691757133e-06,
+      "loss": 1.0037,
+      "step": 2755
+    },
+    {
+      "epoch": 2.42,
+      "learning_rate": 1.9232686110736165e-06,
+      "loss": 1.0074,
+      "step": 2760
+    },
+    {
+      "epoch": 2.42,
+      "learning_rate": 1.895319196267722e-06,
+      "loss": 1.0179,
+      "step": 2765
+    },
+    {
+      "epoch": 2.43,
+      "learning_rate": 1.8675530794521312e-06,
+      "loss": 0.9982,
+      "step": 2770
+    },
+    {
+      "epoch": 2.43,
+      "learning_rate": 1.8399708885940136e-06,
+      "loss": 1.0088,
+      "step": 2775
+    },
+    {
+      "epoch": 2.44,
+      "learning_rate": 1.8125732475007983e-06,
+      "loss": 1.0117,
+      "step": 2780
+    },
+    {
+      "epoch": 2.44,
+      "learning_rate": 1.785360775806093e-06,
+      "loss": 1.0079,
+      "step": 2785
+    },
+    {
+      "epoch": 2.44,
+      "learning_rate": 1.7583340889556456e-06,
+      "loss": 0.9921,
+      "step": 2790
+    },
+    {
+      "epoch": 2.45,
+      "learning_rate": 1.7314937981934399e-06,
+      "loss": 1.0013,
+      "step": 2795
+    },
+    {
+      "epoch": 2.45,
+      "learning_rate": 1.7048405105478717e-06,
+      "loss": 1.0058,
+      "step": 2800
+    },
+    {
+      "epoch": 2.45,
+      "eval_loss": 1.115598440170288,
+      "eval_runtime": 425.102,
+      "eval_samples_per_second": 38.029,
+      "eval_steps_per_second": 1.19,
+      "step": 2800
+    },
+    {
+      "epoch": 2.46,
+      "learning_rate": 1.6783748288180058e-06,
+      "loss": 1.0048,
+      "step": 2805
+    },
+    {
+      "epoch": 2.46,
+      "learning_rate": 1.652097351559967e-06,
+      "loss": 1.0108,
+      "step": 2810
+    },
+    {
+      "epoch": 2.47,
+      "learning_rate": 1.6260086730733749e-06,
+      "loss": 1.014,
+      "step": 2815
+    },
+    {
+      "epoch": 2.47,
+      "learning_rate": 1.6001093833879288e-06,
+      "loss": 1.0037,
+      "step": 2820
+    },
+    {
+      "epoch": 2.47,
+      "learning_rate": 1.5744000682500426e-06,
+      "loss": 0.9953,
+      "step": 2825
+    },
+    {
+      "epoch": 2.48,
+      "learning_rate": 1.5488813091096145e-06,
+      "loss": 1.0152,
+      "step": 2830
+    },
+    {
+      "epoch": 2.48,
+      "learning_rate": 1.523553683106861e-06,
+      "loss": 1.0242,
+      "step": 2835
+    },
+    {
+      "epoch": 2.49,
+      "learning_rate": 1.49841776305928e-06,
+      "loss": 1.0172,
+      "step": 2840
+    },
+    {
+      "epoch": 2.49,
+      "learning_rate": 1.4734741174486788e-06,
+      "loss": 0.9999,
+      "step": 2845
+    },
+    {
+      "epoch": 2.5,
+      "learning_rate": 1.4487233104083354e-06,
+      "loss": 1.011,
+      "step": 2850
+    },
+    {
+      "epoch": 2.5,
+      "learning_rate": 1.424165901710224e-06,
+      "loss": 1.0154,
+      "step": 2855
+    },
+    {
+      "epoch": 2.51,
+      "learning_rate": 1.3998024467523596e-06,
+      "loss": 0.9912,
+      "step": 2860
+    },
+    {
+      "epoch": 2.51,
+      "learning_rate": 1.3756334965462502e-06,
+      "loss": 1.0276,
+      "step": 2865
+    },
+    {
+      "epoch": 2.51,
+      "learning_rate": 1.3516595977044112e-06,
+      "loss": 1.0051,
+      "step": 2870
+    },
+    {
+      "epoch": 2.52,
+      "learning_rate": 1.3278812924280192e-06,
+      "loss": 0.9893,
+      "step": 2875
+    },
+    {
+      "epoch": 2.52,
+      "learning_rate": 1.304299118494652e-06,
+      "loss": 1.0048,
+      "step": 2880
+    },
+    {
+      "epoch": 2.53,
+      "learning_rate": 1.2809136092461084e-06,
+      "loss": 1.0196,
+      "step": 2885
+    },
+    {
+      "epoch": 2.53,
+      "learning_rate": 1.2577252935763695e-06,
+      "loss": 1.0261,
+      "step": 2890
+    },
+    {
+      "epoch": 2.54,
+      "learning_rate": 1.234734695919616e-06,
+      "loss": 1.0118,
+      "step": 2895
+    },
+    {
+      "epoch": 2.54,
+      "learning_rate": 1.2119423362383776e-06,
+      "loss": 1.0118,
+      "step": 2900
+    },
+    {
+      "epoch": 2.54,
+      "eval_loss": 1.1150012016296387,
+      "eval_runtime": 425.4063,
+      "eval_samples_per_second": 38.001,
+      "eval_steps_per_second": 1.189,
+      "step": 2900
+    },
+    {
+      "epoch": 2.54,
+      "learning_rate": 1.189348730011778e-06,
+      "loss": 0.9927,
+      "step": 2905
+    },
+    {
+      "epoch": 2.55,
+      "learning_rate": 1.166954388223862e-06,
+      "loss": 1.0023,
+      "step": 2910
+    },
+    {
+      "epoch": 2.55,
+      "learning_rate": 1.1447598173520558e-06,
+      "loss": 1.009,
+      "step": 2915
+    },
+    {
+      "epoch": 2.56,
+      "learning_rate": 1.1227655193556973e-06,
+      "loss": 1.0049,
+      "step": 2920
+    },
+    {
+      "epoch": 2.56,
+      "learning_rate": 1.1009719916646977e-06,
+      "loss": 1.0065,
+      "step": 2925
+    },
+    {
+      "epoch": 2.57,
+      "learning_rate": 1.079379727168276e-06,
+      "loss": 1.0006,
+      "step": 2930
+    },
+    {
+      "epoch": 2.57,
+      "learning_rate": 1.0579892142038284e-06,
+      "loss": 1.0174,
+      "step": 2935
+    },
+    {
+      "epoch": 2.58,
+      "learning_rate": 1.0368009365458697e-06,
+      "loss": 1.0044,
+      "step": 2940
+    },
+    {
+      "epoch": 2.58,
+      "learning_rate": 1.0158153733950981e-06,
+      "loss": 1.0045,
+      "step": 2945
+    },
+    {
+      "epoch": 2.58,
+      "learning_rate": 9.950329993675623e-07,
+      "loss": 0.9917,
+      "step": 2950
+    },
+    {
+      "epoch": 2.59,
+      "learning_rate": 9.744542844839145e-07,
+      "loss": 1.006,
+      "step": 2955
+    },
+    {
+      "epoch": 2.59,
+      "learning_rate": 9.540796941587983e-07,
+      "loss": 0.9955,
+      "step": 2960
+    },
+    {
+      "epoch": 2.6,
+      "learning_rate": 9.33909689190301e-07,
+      "loss": 1.0065,
+      "step": 2965
+    },
+    {
+      "epoch": 2.6,
+      "learning_rate": 9.139447257495537e-07,
+      "loss": 1.0212,
+      "step": 2970
+    },
+    {
+      "epoch": 2.61,
+      "learning_rate": 8.941852553703966e-07,
+      "loss": 1.0156,
+      "step": 2975
+    },
+    {
+      "epoch": 2.61,
+      "learning_rate": 8.746317249391834e-07,
+      "loss": 1.0045,
+      "step": 2980
+    },
+    {
+      "epoch": 2.61,
+      "learning_rate": 8.55284576684654e-07,
+      "loss": 1.0163,
+      "step": 2985
+    },
+    {
+      "epoch": 2.62,
+      "learning_rate": 8.361442481679561e-07,
+      "loss": 1.0048,
+      "step": 2990
+    },
+    {
+      "epoch": 2.62,
+      "learning_rate": 8.172111722727294e-07,
+      "loss": 1.0107,
+      "step": 2995
+    },
+    {
+      "epoch": 2.63,
+      "learning_rate": 7.984857771953303e-07,
+      "loss": 0.9941,
+      "step": 3000
+    },
+    {
+      "epoch": 2.63,
+      "eval_loss": 1.1147677898406982,
+      "eval_runtime": 425.2487,
+      "eval_samples_per_second": 38.015,
+      "eval_steps_per_second": 1.19,
+      "step": 3000
+    },
+    {
+      "epoch": 2.63,
+      "learning_rate": 7.799684864351342e-07,
+      "loss": 1.0063,
+      "step": 3005
+    },
+    {
+      "epoch": 2.64,
+      "learning_rate": 7.616597187849683e-07,
+      "loss": 0.9949,
+      "step": 3010
+    },
+    {
+      "epoch": 2.64,
+      "learning_rate": 7.435598883216377e-07,
+      "loss": 1.0021,
+      "step": 3015
+    },
+    {
+      "epoch": 2.65,
+      "learning_rate": 7.256694043965528e-07,
+      "loss": 1.001,
+      "step": 3020
+    },
+    {
+      "epoch": 2.65,
+      "learning_rate": 7.07988671626485e-07,
+      "loss": 1.018,
+      "step": 3025
+    },
+    {
+      "epoch": 2.65,
+      "learning_rate": 6.905180898844022e-07,
+      "loss": 0.9964,
+      "step": 3030
+    },
+    {
+      "epoch": 2.66,
+      "learning_rate": 6.732580542904343e-07,
+      "loss": 0.9887,
+      "step": 3035
+    },
+    {
+      "epoch": 2.66,
+      "learning_rate": 6.562089552029305e-07,
+      "loss": 1.0085,
+      "step": 3040
+    },
+    {
+      "epoch": 2.67,
+      "learning_rate": 6.39371178209639e-07,
+      "loss": 1.0064,
+      "step": 3045
+    },
+    {
+      "epoch": 2.67,
+      "learning_rate": 6.227451041189759e-07,
+      "loss": 1.0034,
+      "step": 3050
+    },
+    {
+      "epoch": 2.68,
+      "learning_rate": 6.063311089514256e-07,
+      "loss": 1.0158,
+      "step": 3055
+    },
+    {
+      "epoch": 2.68,
+      "learning_rate": 5.901295639310212e-07,
+      "loss": 1.0108,
+      "step": 3060
+    },
+    {
+      "epoch": 2.69,
+      "learning_rate": 5.74140835476964e-07,
+      "loss": 1.0218,
+      "step": 3065
+    },
+    {
+      "epoch": 2.69,
+      "learning_rate": 5.583652851953225e-07,
+      "loss": 1.0002,
+      "step": 3070
+    },
+    {
+      "epoch": 2.69,
+      "learning_rate": 5.428032698708696e-07,
+      "loss": 0.9974,
+      "step": 3075
+    },
+    {
+      "epoch": 2.7,
+      "learning_rate": 5.274551414589979e-07,
+      "loss": 1.0071,
+      "step": 3080
+    },
+    {
+      "epoch": 2.7,
+      "learning_rate": 5.123212470777684e-07,
+      "loss": 1.0226,
+      "step": 3085
+    },
+    {
+      "epoch": 2.71,
+      "learning_rate": 4.97401929000062e-07,
+      "loss": 1.005,
+      "step": 3090
+    },
+    {
+      "epoch": 2.71,
+      "learning_rate": 4.826975246458299e-07,
+      "loss": 1.0073,
+      "step": 3095
+    },
+    {
+      "epoch": 2.72,
+      "learning_rate": 4.6820836657446964e-07,
+      "loss": 1.0127,
+      "step": 3100
+    },
+    {
+      "epoch": 2.72,
+      "eval_loss": 1.11471688747406,
+      "eval_runtime": 425.0331,
+      "eval_samples_per_second": 38.035,
+      "eval_steps_per_second": 1.19,
+      "step": 3100
+    },
+    {
+      "epoch": 2.72,
+      "learning_rate": 4.5393478247730436e-07,
+      "loss": 1.0162,
+      "step": 3105
+    },
+    {
+      "epoch": 2.72,
+      "learning_rate": 4.398770951701647e-07,
+      "loss": 1.0037,
+      "step": 3110
+    },
+    {
+      "epoch": 2.73,
+      "learning_rate": 4.2603562258609176e-07,
+      "loss": 1.0036,
+      "step": 3115
+    },
+    {
+      "epoch": 2.73,
+      "learning_rate": 4.124106777681536e-07,
+      "loss": 0.9959,
+      "step": 3120
+    },
+    {
+      "epoch": 2.74,
+      "learning_rate": 3.9900256886235e-07,
+      "loss": 0.9993,
+      "step": 3125
+    },
+    {
+      "epoch": 2.74,
+      "learning_rate": 3.8581159911065926e-07,
+      "loss": 1.0137,
+      "step": 3130
+    },
+    {
+      "epoch": 2.75,
+      "learning_rate": 3.7283806684416777e-07,
+      "loss": 1.0166,
+      "step": 3135
+    },
+    {
+      "epoch": 2.75,
+      "learning_rate": 3.600822654763314e-07,
+      "loss": 0.9931,
+      "step": 3140
+    },
+    {
+      "epoch": 2.76,
+      "learning_rate": 3.4754448349633374e-07,
+      "loss": 0.9939,
+      "step": 3145
+    },
+    {
+      "epoch": 2.76,
+      "learning_rate": 3.35225004462566e-07,
+      "loss": 1.0135,
+      "step": 3150
+    },
+    {
+      "epoch": 2.76,
+      "learning_rate": 3.2312410699620986e-07,
+      "loss": 1.0142,
+      "step": 3155
+    },
+    {
+      "epoch": 2.77,
+      "learning_rate": 3.11242064774937e-07,
+      "loss": 0.993,
+      "step": 3160
+    },
+    {
+      "epoch": 2.77,
+      "learning_rate": 2.99579146526725e-07,
+      "loss": 0.9925,
+      "step": 3165
+    },
+    {
+      "epoch": 2.78,
+      "learning_rate": 2.8813561602377025e-07,
+      "loss": 1.0074,
+      "step": 3170
+    },
+    {
+      "epoch": 2.78,
+      "learning_rate": 2.7691173207653355e-07,
+      "loss": 1.0099,
+      "step": 3175
+    },
+    {
+      "epoch": 2.79,
+      "learning_rate": 2.659077485278716e-07,
+      "loss": 1.0112,
+      "step": 3180
+    },
+    {
+      "epoch": 2.79,
+      "learning_rate": 2.551239142473161e-07,
+      "loss": 1.0004,
+      "step": 3185
+    },
+    {
+      "epoch": 2.79,
+      "learning_rate": 2.4456047312542365e-07,
+      "loss": 1.0155,
+      "step": 3190
+    },
+    {
+      "epoch": 2.8,
+      "learning_rate": 2.3421766406827807e-07,
+      "loss": 1.0085,
+      "step": 3195
+    },
+    {
+      "epoch": 2.8,
+      "learning_rate": 2.2409572099207576e-07,
+      "loss": 1.0039,
+      "step": 3200
+    },
+    {
+      "epoch": 2.8,
+      "eval_loss": 1.114408254623413,
+      "eval_runtime": 425.0695,
+      "eval_samples_per_second": 38.031,
+      "eval_steps_per_second": 1.19,
+      "step": 3200
+    },
+    {
+      "epoch": 2.81,
+      "learning_rate": 2.1419487281784002e-07,
+      "loss": 0.9914,
+      "step": 3205
+    },
+    {
+      "epoch": 2.81,
+      "learning_rate": 2.045153434662428e-07,
+      "loss": 1.0038,
+      "step": 3210
+    },
+    {
+      "epoch": 2.82,
+      "learning_rate": 1.9505735185254226e-07,
+      "loss": 0.9977,
+      "step": 3215
+    },
+    {
+      "epoch": 2.82,
+      "learning_rate": 1.8582111188162555e-07,
+      "loss": 1.0048,
+      "step": 3220
+    },
+    {
+      "epoch": 2.83,
+      "learning_rate": 1.7680683244318154e-07,
+      "loss": 1.0028,
+      "step": 3225
+    },
+    {
+      "epoch": 2.83,
+      "learning_rate": 1.6801471740696462e-07,
+      "loss": 1.0116,
+      "step": 3230
+    },
+    {
+      "epoch": 2.83,
+      "learning_rate": 1.594449656181918e-07,
+      "loss": 1.0002,
+      "step": 3235
+    },
+    {
+      "epoch": 2.84,
+      "learning_rate": 1.510977708930461e-07,
+      "loss": 1.0176,
+      "step": 3240
+    },
+    {
+      "epoch": 2.84,
+      "learning_rate": 1.4297332201428703e-07,
+      "loss": 0.9904,
+      "step": 3245
+    },
+    {
+      "epoch": 2.85,
+      "learning_rate": 1.3507180272698594e-07,
+      "loss": 1.025,
+      "step": 3250
+    },
+    {
+      "epoch": 2.85,
+      "learning_rate": 1.2739339173436838e-07,
+      "loss": 1.0045,
+      "step": 3255
+    },
+    {
+      "epoch": 2.86,
+      "learning_rate": 1.1993826269377506e-07,
+      "loss": 1.0145,
+      "step": 3260
+    },
+    {
+      "epoch": 2.86,
+      "learning_rate": 1.1270658421273062e-07,
+      "loss": 0.9961,
+      "step": 3265
+    },
+    {
+      "epoch": 2.86,
+      "learning_rate": 1.0569851984513102e-07,
+      "loss": 0.9992,
+      "step": 3270
+    },
+    {
+      "epoch": 2.87,
+      "learning_rate": 9.89142280875477e-08,
+      "loss": 1.0086,
+      "step": 3275
+    },
+    {
+      "epoch": 2.87,
+      "learning_rate": 9.235386237564148e-08,
+      "loss": 1.0101,
+      "step": 3280
+    },
+    {
+      "epoch": 2.88,
+      "learning_rate": 8.601757108068876e-08,
+      "loss": 0.9943,
+      "step": 3285
+    },
+    {
+      "epoch": 2.88,
+      "learning_rate": 7.990549750623189e-08,
+      "loss": 1.0004,
+      "step": 3290
+    },
+    {
+      "epoch": 2.89,
+      "learning_rate": 7.401777988483406e-08,
+      "loss": 1.0132,
+      "step": 3295
+    },
+    {
+      "epoch": 2.89,
+      "learning_rate": 6.835455137495395e-08,
+      "loss": 1.0,
+      "step": 3300
+    },
+    {
+      "epoch": 2.89,
+      "eval_loss": 1.1143468618392944,
+      "eval_runtime": 425.1593,
+      "eval_samples_per_second": 38.023,
+      "eval_steps_per_second": 1.19,
+      "step": 3300
+    },
+    {
+      "epoch": 2.9,
+      "learning_rate": 6.2915940057936e-08,
+      "loss": 0.9879,
+      "step": 3305
+    },
+    {
+      "epoch": 2.9,
+      "learning_rate": 5.7702068935109324e-08,
+      "loss": 0.9821,
+      "step": 3310
+    },
+    {
+      "epoch": 2.9,
+      "learning_rate": 5.271305592501108e-08,
+      "loss": 0.9954,
+      "step": 3315
+    },
+    {
+      "epoch": 2.91,
+      "learning_rate": 4.794901386071749e-08,
+      "loss": 1.0052,
+      "step": 3320
+    },
+    {
+      "epoch": 2.91,
+      "learning_rate": 4.341005048728919e-08,
+      "loss": 1.0061,
+      "step": 3325
+    },
+    {
+      "epoch": 2.92,
+      "learning_rate": 3.9096268459339893e-08,
+      "loss": 1.0068,
+      "step": 3330
+    },
+    {
+      "epoch": 2.92,
+      "learning_rate": 3.50077653387082e-08,
+      "loss": 1.0101,
+      "step": 3335
+    },
+    {
+      "epoch": 2.93,
+      "learning_rate": 3.114463359225717e-08,
+      "loss": 1.0068,
+      "step": 3340
+    },
+    {
+      "epoch": 2.93,
+      "learning_rate": 2.7506960589781527e-08,
+      "loss": 1.0072,
+      "step": 3345
+    },
+    {
+      "epoch": 2.93,
+      "learning_rate": 2.4094828602027052e-08,
+      "loss": 0.9931,
+      "step": 3350
+    },
+    {
+      "epoch": 2.94,
+      "learning_rate": 2.0908314798836483e-08,
+      "loss": 1.0091,
+      "step": 3355
+    },
+    {
+      "epoch": 2.94,
+      "learning_rate": 1.7947491247399808e-08,
+      "loss": 1.0162,
+      "step": 3360
+    },
+    {
+      "epoch": 2.95,
+      "learning_rate": 1.5212424910627797e-08,
+      "loss": 1.0119,
+      "step": 3365
+    },
+    {
+      "epoch": 2.95,
+      "learning_rate": 1.2703177645634335e-08,
+      "loss": 1.0053,
+      "step": 3370
+    },
+    {
+      "epoch": 2.96,
+      "learning_rate": 1.0419806202336403e-08,
+      "loss": 1.0044,
+      "step": 3375
+    },
+    {
+      "epoch": 2.96,
+      "learning_rate": 8.362362222177345e-09,
+      "loss": 1.008,
+      "step": 3380
+    },
+    {
+      "epoch": 2.97,
+      "learning_rate": 6.530892236951136e-09,
+      "loss": 0.9943,
+      "step": 3385
+    },
+    {
+      "epoch": 2.97,
+      "learning_rate": 4.925437667755439e-09,
+      "loss": 1.005,
+      "step": 3390
+    },
+    {
+      "epoch": 2.97,
+      "learning_rate": 3.5460348240501376e-09,
+      "loss": 0.9884,
+      "step": 3395
+    },
+    {
+      "epoch": 2.98,
+      "learning_rate": 2.39271490284243e-09,
+      "loss": 1.0188,
+      "step": 3400
+    },
+    {
+      "epoch": 2.98,
+      "eval_loss": 1.114337682723999,
+      "eval_runtime": 425.2781,
+      "eval_samples_per_second": 38.013,
+      "eval_steps_per_second": 1.19,
+      "step": 3400
+    },
+    {
+      "epoch": 2.98,
+      "learning_rate": 1.4655039879740706e-09,
+      "loss": 1.0096,
+      "step": 3405
+    },
+    {
+      "epoch": 2.99,
+      "learning_rate": 7.644230495373884e-10,
+      "loss": 1.0001,
+      "step": 3410
+    },
+    {
+      "epoch": 2.99,
+      "learning_rate": 2.8948794339789255e-10,
+      "loss": 1.0028,
+      "step": 3415
+    },
+    {
+      "epoch": 3.0,
+      "learning_rate": 4.07094108345607e-11,
+      "loss": 1.009,
+      "step": 3420
+    },
+    {
+      "epoch": 3.0,
+      "step": 3423,
+      "total_flos": 5.633765648992567e+18,
+      "train_loss": 1.0902616986746403,
+      "train_runtime": 47329.7113,
+      "train_samples_per_second": 9.258,
+      "train_steps_per_second": 0.072
+    }
+  ],
+  "logging_steps": 5,
+  "max_steps": 3423,
+  "num_input_tokens_seen": 0,
+  "num_train_epochs": 3,
+  "save_steps": 100,
+  "total_flos": 5.633765648992567e+18,
+  "train_batch_size": 16,
+  "trial_name": null,
+  "trial_params": null
+}