Upload lm-boosted decoder

.gitattributes

@@ -25,3 +25,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zstandard filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+language_model/CV_8.0_3gram_correct.arpa filter=lfs diff=lfs merge=lfs -text

added_tokens.json

@@ -0,0 +1 @@
+{"<s>": 48, "</s>": 49}

alphabet.json

@@ -0,0 +1 @@
+{"labels": ["e", "n", "a", "i", "t", "o", "d", "r", " ", "l", "s", "h", "g", "m", "k", "v", "j", "w", "z", "u", "b", "c", "p", "f", "y", "\u00e9", "'", "x", "\u00eb", "q", "-", "\u00ea", "\u00e0", "\u00e4", "\u00e8", "\u00ef", "\u00e2", "\u00fb", "\u00f6", "\u00f4", "\u00fc", "\u00ee", "\u00e7", "\u00e6", "\u00f9", "\u0153", "\u2047", "", "<s>", "</s>"], "is_bpe": false}

config.json

@@ -0,0 +1,108 @@
+{
+  "_name_or_path": "facebook/wav2vec2-xls-r-300m",
+  "activation_dropout": 0.0,
+  "adapter_kernel_size": 3,
+  "adapter_stride": 2,
+  "add_adapter": false,
+  "apply_spec_augment": true,
+  "architectures": [
+    "Wav2Vec2ForCTC"
+  ],
+  "attention_dropout": 0.1,
+  "bos_token_id": 1,
+  "classifier_proj_size": 256,
+  "codevector_dim": 768,
+  "contrastive_logits_temperature": 0.1,
+  "conv_bias": true,
+  "conv_dim": [
+    512,
+    512,
+    512,
+    512,
+    512,
+    512,
+    512
+  ],
+  "conv_kernel": [
+    10,
+    3,
+    3,
+    3,
+    3,
+    2,
+    2
+  ],
+  "conv_stride": [
+    5,
+    2,
+    2,
+    2,
+    2,
+    2,
+    2
+  ],
+  "ctc_loss_reduction": "mean",
+  "ctc_zero_infinity": false,
+  "diversity_loss_weight": 0.1,
+  "do_stable_layer_norm": true,
+  "eos_token_id": 2,
+  "feat_extract_activation": "gelu",
+  "feat_extract_dropout": 0.0,
+  "feat_extract_norm": "layer",
+  "feat_proj_dropout": 0.0,
+  "feat_quantizer_dropout": 0.0,
+  "final_dropout": 0.0,
+  "gradient_checkpointing": false,
+  "hidden_act": "gelu",
+  "hidden_dropout": 0.1,
+  "hidden_size": 1024,
+  "initializer_range": 0.02,
+  "intermediate_size": 4096,
+  "layer_norm_eps": 1e-05,
+  "layerdrop": 0.1,
+  "mask_feature_length": 10,
+  "mask_feature_min_masks": 0,
+  "mask_feature_prob": 0.0,
+  "mask_time_length": 10,
+  "mask_time_min_masks": 2,
+  "mask_time_prob": 0.05,
+  "model_type": "wav2vec2",
+  "num_adapter_layers": 3,
+  "num_attention_heads": 16,
+  "num_codevector_groups": 2,
+  "num_codevectors_per_group": 320,
+  "num_conv_pos_embedding_groups": 16,
+  "num_conv_pos_embeddings": 128,
+  "num_feat_extract_layers": 7,
+  "num_hidden_layers": 24,
+  "num_negatives": 100,
+  "output_hidden_size": 1024,
+  "pad_token_id": 47,
+  "proj_codevector_dim": 768,
+  "tdnn_dilation": [
+    1,
+    2,
+    3,
+    1,
+    1
+  ],
+  "tdnn_dim": [
+    512,
+    512,
+    512,
+    512,
+    1500
+  ],
+  "tdnn_kernel": [
+    5,
+    3,
+    3,
+    1,
+    1
+  ],
+  "torch_dtype": "float32",
+  "transformers_version": "4.15.0",
+  "use_weighted_layer_sum": false,
+  "vocab_size": 48,
+  "xvector_output_dim": 512
+}

eval.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+import argparse
+import re
+from typing import Dict
+
+from datasets import Audio, Dataset, load_dataset, load_metric
+
+from transformers import AutoFeatureExtractor, pipeline
+
+
+def log_results(result: Dataset, args: Dict[str, str]):
+    """DO NOT CHANGE. This function computes and logs the result metrics."""
+
+    log_outputs = args.log_outputs
+    dataset_id = "_".join(args.dataset.split("/") + [args.config, args.split])
+
+    # load metric
+    wer = load_metric("wer")
+    cer = load_metric("cer")
+
+    # compute metrics
+    wer_result = wer.compute(references=result["target"], predictions=result["prediction"])
+    cer_result = cer.compute(references=result["target"], predictions=result["prediction"])
+
+    # print & log results
+    result_str = f"WER: {wer_result}\n" f"CER: {cer_result}"
+    print(result_str)
+
+    with open(f"{dataset_id}_eval_results.txt", "w") as f:
+        f.write(result_str)
+
+    # log all results in text file. Possibly interesting for analysis
+    if log_outputs is not None:
+        pred_file = f"log_{dataset_id}_predictions.txt"
+        target_file = f"log_{dataset_id}_targets.txt"
+
+        with open(pred_file, "w") as p, open(target_file, "w") as t:
+
+            # mapping function to write output
+            def write_to_file(batch, i):
+                p.write(f"{i}" + "\n")
+                p.write(batch["prediction"] + "\n")
+                t.write(f"{i}" + "\n")
+                t.write(batch["target"] + "\n")
+
+            result.map(write_to_file, with_indices=True)
+
+
+def normalize_text(text: str) -> str:
+    """DO ADAPT FOR YOUR USE CASE. this function normalizes the target text."""
+
+    chars_to_ignore_regex = '[,?.!\-\;\:"“%‘”�—’…–]'  # noqa: W605 IMPORTANT: this should correspond to the chars that were ignored during training
+
+    text = re.sub(chars_to_ignore_regex, "", text.lower())
+
+    # In addition, we can normalize the target text, e.g. removing new lines characters etc...
+    # note that order is important here!
+    token_sequences_to_ignore = ["\n\n", "\n", "   ", "  "]
+
+    for t in token_sequences_to_ignore:
+        text = " ".join(text.split(t))
+
+    return text
+
+
+def main(args):
+    # load dataset
+    dataset = load_dataset(args.dataset, args.config, split=args.split, use_auth_token=True)
+
+    # for testing: only process the first two examples as a test
+    # dataset = dataset.select(range(10))
+
+    # load processor
+    feature_extractor = AutoFeatureExtractor.from_pretrained(args.model_id)
+    sampling_rate = feature_extractor.sampling_rate
+
+    # resample audio
+    dataset = dataset.cast_column("audio", Audio(sampling_rate=sampling_rate))
+
+    # load eval pipeline
+    asr = pipeline("automatic-speech-recognition", model=args.model_id)
+
+    # map function to decode audio
+    def map_to_pred(batch):
+        prediction = asr(
+            batch["audio"]["array"], chunk_length_s=args.chunk_length_s, stride_length_s=args.stride_length_s
+        )
+
+        batch["prediction"] = prediction["text"]
+        batch["target"] = normalize_text(batch["sentence"])
+        return batch
+
+    # run inference on all examples
+    result = dataset.map(map_to_pred, remove_columns=dataset.column_names)
+
+    # compute and log_results
+    # do not change function below
+    log_results(result, args)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument(
+        "--model_id", type=str, required=True, help="Model identifier. Should be loadable with 🤗 Transformers"
+    )
+    parser.add_argument(
+        "--dataset",
+        type=str,
+        required=True,
+        help="Dataset name to evaluate the `model_id`. Should be loadable with 🤗 Datasets",
+    )
+    parser.add_argument(
+        "--config", type=str, required=True, help="Config of the dataset. *E.g.* `'en'`  for Common Voice"
+    )
+    parser.add_argument("--split", type=str, required=True, help="Split of the dataset. *E.g.* `'test'`")
+    parser.add_argument(
+        "--chunk_length_s", type=float, default=None, help="Chunk length in seconds. Defaults to 5 seconds."
+    )
+    parser.add_argument(
+        "--stride_length_s", type=float, default=None, help="Stride of the audio chunks. Defaults to 1 second."
+    )
+    parser.add_argument(
+        "--log_outputs", action="store_true", help="If defined, write outputs to log file for analysis."
+    )
+    args = parser.parse_args()
+
+    main(args)

language_model/CV_8.0_3gram_correct.arpa

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

language_model/attrs.json

@@ -0,0 +1 @@
+{"alpha": 0.5, "beta": 1.5, "unk_score_offset": -10.0, "score_boundary": true}

optimizer.pt

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

preprocessor_config.json

@@ -0,0 +1,10 @@
+{
+  "do_normalize": true,
+  "feature_extractor_type": "Wav2Vec2FeatureExtractor",
+  "feature_size": 1,
+  "padding_side": "right",
+  "padding_value": 0.0,
+  "processor_class": "Wav2Vec2ProcessorWithLM",
+  "return_attention_mask": true,
+  "sampling_rate": 16000
+}

pytorch_model.bin

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

rng_state.pth

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

run_speech_recognition_ctc.py

@@ -0,0 +1,737 @@
+#!/usr/bin/env python
+# coding=utf-8
+# Copyright 2021 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
+
+""" Fine-tuning a 🤗 Transformers CTC model for automatic speech recognition"""
+
+import functools
+import json
+import logging
+import os
+import re
+import sys
+import warnings
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Union
+
+import datasets
+import numpy as np
+import torch
+from datasets import DatasetDict, load_dataset, load_metric
+
+import transformers
+from transformers import (
+    AutoConfig,
+    AutoFeatureExtractor,
+    AutoModelForCTC,
+    AutoProcessor,
+    AutoTokenizer,
+    HfArgumentParser,
+    Trainer,
+    TrainingArguments,
+    Wav2Vec2Processor,
+    set_seed,
+)
+from transformers.trainer_utils import get_last_checkpoint, is_main_process
+from transformers.utils import check_min_version
+from transformers.utils.versions import require_version
+
+
+# Will error if the minimal version of Transformers is not installed. Remove at your own risks.
+check_min_version("4.16.0.dev0")
+
+require_version("datasets>=1.13.3", "To fix: pip install -r examples/pytorch/text-classification/requirements.txt")
+
+
+logger = logging.getLogger(__name__)
+
+
+def list_field(default=None, metadata=None):
+    return field(default_factory=lambda: default, metadata=metadata)
+
+
+@dataclass
+class ModelArguments:
+    """
+    Arguments pertaining to which model/config/tokenizer we are going to fine-tune from.
+    """
+
+    model_name_or_path: str = field(
+        metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"}
+    )
+    tokenizer_name_or_path: Optional[str] = field(
+        default=None,
+        metadata={"help": "Path to pretrained tokenizer or tokenizer identifier from huggingface.co/models"},
+    )
+    cache_dir: Optional[str] = field(
+        default=None,
+        metadata={"help": "Where do you want to store the pretrained models downloaded from huggingface.co"},
+    )
+    freeze_feature_encoder: bool = field(
+        default=True, metadata={"help": "Whether to freeze the feature encoder layers of the model."}
+    )
+    attention_dropout: float = field(
+        default=0.0, metadata={"help": "The dropout ratio for the attention probabilities."}
+    )
+    activation_dropout: float = field(
+        default=0.0, metadata={"help": "The dropout ratio for activations inside the fully connected layer."}
+    )
+    feat_proj_dropout: float = field(default=0.0, metadata={"help": "The dropout ratio for the projected features."})
+    hidden_dropout: float = field(
+        default=0.0,
+        metadata={
+            "help": "The dropout probability for all fully connected layers in the embeddings, encoder, and pooler."
+        },
+    )
+    final_dropout: float = field(
+        default=0.0,
+        metadata={"help": "The dropout probability for the final projection layer."},
+    )
+    mask_time_prob: float = field(
+        default=0.05,
+        metadata={
+            "help": "Probability of each feature vector along the time axis to be chosen as the start of the vector"
+            "span to be masked. Approximately ``mask_time_prob * sequence_length // mask_time_length`` feature"
+            "vectors will be masked along the time axis."
+        },
+    )
+    mask_time_length: int = field(
+        default=10,
+        metadata={"help": "Length of vector span to mask along the time axis."},
+    )
+    mask_feature_prob: float = field(
+        default=0.0,
+        metadata={
+            "help": "Probability of each feature vector along the feature axis to be chosen as the start of the vector"
+            "span to be masked. Approximately ``mask_feature_prob * sequence_length // mask_feature_length`` feature bins will be masked along the time axis."
+        },
+    )
+    mask_feature_length: int = field(
+        default=10,
+        metadata={"help": "Length of vector span to mask along the feature axis."},
+    )
+    layerdrop: float = field(default=0.0, metadata={"help": "The LayerDrop probability."})
+    ctc_loss_reduction: Optional[str] = field(
+        default="mean", metadata={"help": "The way the ctc loss should be reduced. Should be one of 'mean' or 'sum'."}
+    )
+
+
+@dataclass
+class DataTrainingArguments:
+    """
+    Arguments pertaining to what data we are going to input our model for training and eval.
+
+    Using `HfArgumentParser` we can turn this class
+    into argparse arguments to be able to specify them on
+    the command line.
+    """
+
+    dataset_name: str = field(
+        metadata={"help": "The configuration name of the dataset to use (via the datasets library)."}
+    )
+    dataset_config_name: str = field(
+        default=None, metadata={"help": "The configuration name of the dataset to use (via the datasets library)."}
+    )
+    train_split_name: str = field(
+        default="train+validation",
+        metadata={
+            "help": "The name of the training data set split to use (via the datasets library). Defaults to 'train'"
+        },
+    )
+    eval_split_name: str = field(
+        default="test",
+        metadata={
+            "help": "The name of the training data set split to use (via the datasets library). Defaults to 'train'"
+        },
+    )
+    audio_column_name: str = field(
+        default="audio",
+        metadata={"help": "The name of the dataset column containing the audio data. Defaults to 'audio'"},
+    )
+    text_column_name: str = field(
+        default="text",
+        metadata={"help": "The name of the dataset column containing the text data. Defaults to 'text'"},
+    )
+    overwrite_cache: bool = field(
+        default=False, metadata={"help": "Overwrite the cached preprocessed datasets or not."}
+    )
+    preprocessing_num_workers: Optional[int] = field(
+        default=None,
+        metadata={"help": "The number of processes to use for the preprocessing."},
+    )
+    max_train_samples: Optional[int] = field(
+        default=None,
+        metadata={
+            "help": "For debugging purposes or quicker training, truncate the number of training examples to this "
+            "value if set."
+        },
+    )
+    max_eval_samples: Optional[int] = field(
+        default=None,
+        metadata={
+            "help": "For debugging purposes or quicker training, truncate the number of validation examples to this "
+            "value if set."
+        },
+    )
+    chars_to_ignore: Optional[List[str]] = list_field(
+        default=None,
+        metadata={"help": "A list of characters to remove from the transcripts."},
+    )
+    eval_metrics: List[str] = list_field(
+        default=["wer"],
+        metadata={"help": "A list of metrics the model should be evaluated on. E.g. `'wer cer'`"},
+    )
+    max_duration_in_seconds: float = field(
+        default=20.0,
+        metadata={
+            "help": "Filter audio files that are longer than `max_duration_in_seconds` seconds to 'max_duration_in_seconds`"
+        },
+    )
+    min_duration_in_seconds: float = field(
+        default=0.0, metadata={"help": "Filter audio files that are shorter than `min_duration_in_seconds` seconds"}
+    )
+    preprocessing_only: bool = field(
+        default=False,
+        metadata={
+            "help": "Whether to only do data preprocessing and skip training. "
+            "This is especially useful when data preprocessing errors out in distributed training due to timeout. "
+            "In this case, one should run the preprocessing in a non-distributed setup with `preprocessing_only=True` "
+            "so that the cached datasets can consequently be loaded in distributed training"
+        },
+    )
+    use_auth_token: bool = field(
+        default=False,
+        metadata={
+            "help": "If :obj:`True`, will use the token generated when running"
+            ":obj:`transformers-cli login` as HTTP bearer authorization for remote files."
+        },
+    )
+    unk_token: str = field(
+        default="[UNK]",
+        metadata={"help": "The unk token for the tokenizer"},
+    )
+    pad_token: str = field(
+        default="[PAD]",
+        metadata={"help": "The padding token for the tokenizer"},
+    )
+    word_delimiter_token: str = field(
+        default="|",
+        metadata={"help": "The word delimiter token for the tokenizer"},
+    )
+    phoneme_language: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "The target language that should be used be"
+            " passed to the tokenizer for tokenization. Note that"
+            " this is only relevant if the model classifies the"
+            " input audio to a sequence of phoneme sequences."
+        },
+    )
+
+
+@dataclass
+class DataCollatorCTCWithPadding:
+    """
+    Data collator that will dynamically pad the inputs received.
+    Args:
+        processor (:class:`~transformers.AutoProcessor`)
+            The processor used for proccessing the data.
+        padding (:obj:`bool`, :obj:`str` or :class:`~transformers.tokenization_utils_base.PaddingStrategy`, `optional`, defaults to :obj:`True`):
+            Select a strategy to pad the returned sequences (according to the model's padding side and padding index)
+            among:
+            * :obj:`True` or :obj:`'longest'`: Pad to the longest sequence in the batch (or no padding if only a single
+              sequence if provided).
+            * :obj:`'max_length'`: Pad to a maximum length specified with the argument :obj:`max_length` or to the
+              maximum acceptable input length for the model if that argument is not provided.
+            * :obj:`False` or :obj:`'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of
+              different lengths).
+        max_length (:obj:`int`, `optional`):
+            Maximum length of the ``input_values`` of the returned list and optionally padding length (see above).
+        max_length_labels (:obj:`int`, `optional`):
+            Maximum length of the ``labels`` returned list and optionally padding length (see above).
+        pad_to_multiple_of (:obj:`int`, `optional`):
+            If set will pad the sequence to a multiple of the provided value.
+            This is especially useful to enable the use of Tensor Cores on NVIDIA hardware with compute capability >=
+            7.5 (Volta).
+    """
+
+    processor: AutoProcessor
+    padding: Union[bool, str] = "longest"
+    pad_to_multiple_of: Optional[int] = None
+    pad_to_multiple_of_labels: Optional[int] = None
+
+    def __call__(self, features: List[Dict[str, Union[List[int], torch.Tensor]]]) -> Dict[str, torch.Tensor]:
+        # split inputs and labels since they have to be of different lenghts and need
+        # different padding methods
+        input_features = [{"input_values": feature["input_values"]} for feature in features]
+        label_features = [{"input_ids": feature["labels"]} for feature in features]
+
+        batch = self.processor.pad(
+            input_features,
+            padding=self.padding,
+            pad_to_multiple_of=self.pad_to_multiple_of,
+            return_tensors="pt",
+        )
+
+        with self.processor.as_target_processor():
+            labels_batch = self.processor.pad(
+                label_features,
+                padding=self.padding,
+                pad_to_multiple_of=self.pad_to_multiple_of_labels,
+                return_tensors="pt",
+            )
+
+        # replace padding with -100 to ignore loss correctly
+        labels = labels_batch["input_ids"].masked_fill(labels_batch.attention_mask.ne(1), -100)
+
+        batch["labels"] = labels
+
+        return batch
+
+
+def create_vocabulary_from_data(
+    datasets: DatasetDict,
+    word_delimiter_token: Optional[str] = None,
+    unk_token: Optional[str] = None,
+    pad_token: Optional[str] = None,
+):
+    # Given training and test labels create vocabulary
+    def extract_all_chars(batch):
+        all_text = " ".join(batch["target_text"])
+        vocab = list(set(all_text))
+        return {"vocab": [vocab], "all_text": [all_text]}
+
+    vocabs = datasets.map(
+        extract_all_chars,
+        batched=True,
+        batch_size=-1,
+        keep_in_memory=True,
+        remove_columns=datasets["train"].column_names,
+    )
+
+    # take union of all unique characters in each dataset
+    vocab_set = functools.reduce(
+        lambda vocab_1, vocab_2: set(vocab_1["vocab"][0]) | set(vocab_2["vocab"][0]), vocabs.values()
+    )
+
+    vocab_dict = {v: k for k, v in enumerate(sorted(list(vocab_set)))}
+
+    # replace white space with delimiter token
+    if word_delimiter_token is not None:
+        vocab_dict[word_delimiter_token] = vocab_dict[" "]
+        del vocab_dict[" "]
+
+    # add unk and pad token
+    if unk_token is not None:
+        vocab_dict[unk_token] = len(vocab_dict)
+
+    if pad_token is not None:
+        vocab_dict[pad_token] = len(vocab_dict)
+
+    return vocab_dict
+
+
+def main():
+    # See all possible arguments in src/transformers/training_args.py
+    # or by passing the --help flag to this script.
+    # We now keep distinct sets of args, for a cleaner separation of concerns.
+
+    parser = HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments))
+    if len(sys.argv) == 2 and sys.argv[1].endswith(".json"):
+        # If we pass only one argument to the script and it's the path to a json file,
+        # let's parse it to get our arguments.
+        model_args, data_args, training_args = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]))
+    else:
+        model_args, data_args, training_args = parser.parse_args_into_dataclasses()
+
+    # Detecting last checkpoint.
+    last_checkpoint = None
+    if os.path.isdir(training_args.output_dir) and training_args.do_train and not training_args.overwrite_output_dir:
+        last_checkpoint = get_last_checkpoint(training_args.output_dir)
+        if last_checkpoint is None and len(os.listdir(training_args.output_dir)) > 0:
+            raise ValueError(
+                f"Output directory ({training_args.output_dir}) already exists and is not empty. "
+                "Use --overwrite_output_dir to overcome."
+            )
+        elif last_checkpoint is not None:
+            logger.info(
+                f"Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change "
+                "the `--output_dir` or add `--overwrite_output_dir` to train from scratch."
+            )
+
+    # Setup logging
+    logging.basicConfig(
+        format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
+        datefmt="%m/%d/%Y %H:%M:%S",
+        handlers=[logging.StreamHandler(sys.stdout)],
+    )
+    logger.setLevel(logging.INFO if is_main_process(training_args.local_rank) else logging.WARN)
+
+    # Log on each process the small summary:
+    logger.warning(
+        f"Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}"
+        f"distributed training: {bool(training_args.local_rank != -1)}, 16-bits training: {training_args.fp16}"
+    )
+    # Set the verbosity to info of the Transformers logger (on main process only):
+    if is_main_process(training_args.local_rank):
+        transformers.utils.logging.set_verbosity_info()
+    logger.info("Training/evaluation parameters %s", training_args)
+
+    # Set seed before initializing model.
+    set_seed(training_args.seed)
+
+    # 1. First, let's load the dataset
+    raw_datasets = DatasetDict()
+
+    if training_args.do_train:
+        raw_datasets["train"] = load_dataset(
+            data_args.dataset_name,
+            data_args.dataset_config_name,
+            split=data_args.train_split_name,
+            use_auth_token=data_args.use_auth_token,
+        )
+
+        if data_args.audio_column_name not in raw_datasets["train"].column_names:
+            raise ValueError(
+                f"--audio_column_name '{data_args.audio_column_name}' not found in dataset '{data_args.dataset_name}'. "
+                "Make sure to set `--audio_column_name` to the correct audio column - one of "
+                f"{', '.join(raw_datasets['train'].column_names)}."
+            )
+
+        if data_args.text_column_name not in raw_datasets["train"].column_names:
+            raise ValueError(
+                f"--text_column_name {data_args.text_column_name} not found in dataset '{data_args.dataset_name}'. "
+                "Make sure to set `--text_column_name` to the correct text column - one of "
+                f"{', '.join(raw_datasets['train'].column_names)}."
+            )
+
+        if data_args.max_train_samples is not None:
+            raw_datasets["train"] = raw_datasets["train"].select(range(data_args.max_train_samples))
+
+    if training_args.do_eval:
+        raw_datasets["eval"] = load_dataset(
+            data_args.dataset_name,
+            data_args.dataset_config_name,
+            split=data_args.eval_split_name,
+            use_auth_token=data_args.use_auth_token,
+        )
+
+        if data_args.max_eval_samples is not None:
+            raw_datasets["eval"] = raw_datasets["eval"].select(range(data_args.max_eval_samples))
+
+    # 2. We remove some special characters from the datasets
+    # that make training complicated and do not help in transcribing the speech
+    # E.g. characters, such as `,` and `.` do not really have an acoustic characteristic
+    # that could be easily picked up by the model
+    chars_to_ignore_regex = (
+        f'[{"".join(data_args.chars_to_ignore)}]' if data_args.chars_to_ignore is not None else None
+    )
+    text_column_name = data_args.text_column_name
+
+    def remove_special_characters(batch):
+        if chars_to_ignore_regex is not None:
+            batch["target_text"] = re.sub(chars_to_ignore_regex, "", batch[text_column_name]).lower() + " "
+        else:
+            batch["target_text"] = batch[text_column_name].lower() + " "
+        return batch
+
+    with training_args.main_process_first(desc="dataset map special characters removal"):
+        raw_datasets = raw_datasets.map(
+            remove_special_characters,
+            remove_columns=[text_column_name],
+            desc="remove special characters from datasets",
+        )
+
+    # save special tokens for tokenizer
+    word_delimiter_token = data_args.word_delimiter_token
+    unk_token = data_args.unk_token
+    pad_token = data_args.pad_token
+
+    # 3. Next, let's load the config as we might need it to create
+    # the tokenizer
+    # load config
+    config = AutoConfig.from_pretrained(
+        model_args.model_name_or_path, cache_dir=model_args.cache_dir, use_auth_token=data_args.use_auth_token
+    )
+
+    # 4. Next, if no tokenizer file is defined,
+    # we create the vocabulary of the model by extracting all unique characters from
+    # the training and evaluation datasets
+    # We need to make sure that only first rank saves vocabulary
+    # make sure all processes wait until vocab is created
+    tokenizer_name_or_path = model_args.tokenizer_name_or_path
+    tokenizer_kwargs = {}
+    if tokenizer_name_or_path is None:
+        # save vocab in training output dir
+        tokenizer_name_or_path = training_args.output_dir
+
+        vocab_file = os.path.join(tokenizer_name_or_path, "vocab.json")
+
+        with training_args.main_process_first():
+            if training_args.overwrite_output_dir and os.path.isfile(vocab_file):
+                os.remove(vocab_file)
+
+        with training_args.main_process_first(desc="dataset map vocabulary creation"):
+            if not os.path.isfile(vocab_file):
+                os.makedirs(tokenizer_name_or_path, exist_ok=True)
+                vocab_dict = create_vocabulary_from_data(
+                    raw_datasets,
+                    word_delimiter_token=word_delimiter_token,
+                    unk_token=unk_token,
+                    pad_token=pad_token,
+                )
+
+                # save vocab dict to be loaded into tokenizer
+                with open(vocab_file, "w") as file:
+                    json.dump(vocab_dict, file)
+
+        # if tokenizer has just been created
+        # it is defined by `tokenizer_class` if present in config else by `model_type`
+        tokenizer_kwargs = {
+            "config": config if config.tokenizer_class is not None else None,
+            "tokenizer_type": config.model_type if config.tokenizer_class is None else None,
+            "unk_token": unk_token,
+            "pad_token": pad_token,
+            "word_delimiter_token": word_delimiter_token,
+        }
+
+    # 5. Now we can instantiate the feature extractor, tokenizer and model
+    # Note for distributed training, the .from_pretrained methods guarantee that only
+    # one local process can concurrently download model & vocab.
+
+    # load feature_extractor and tokenizer
+    tokenizer = AutoTokenizer.from_pretrained(
+        tokenizer_name_or_path,
+        use_auth_token=data_args.use_auth_token,
+        **tokenizer_kwargs,
+    )
+    feature_extractor = AutoFeatureExtractor.from_pretrained(
+        model_args.model_name_or_path, cache_dir=model_args.cache_dir, use_auth_token=data_args.use_auth_token
+    )
+
+    # adapt config
+    config.update(
+        {
+            "feat_proj_dropout": model_args.feat_proj_dropout,
+            "attention_dropout": model_args.attention_dropout,
+            "hidden_dropout": model_args.hidden_dropout,
+            "final_dropout": model_args.final_dropout,
+            "mask_time_prob": model_args.mask_time_prob,
+            "mask_time_length": model_args.mask_time_length,
+            "mask_feature_prob": model_args.mask_feature_prob,
+            "mask_feature_length": model_args.mask_feature_length,
+            "gradient_checkpointing": training_args.gradient_checkpointing,
+            "layerdrop": model_args.layerdrop,
+            "ctc_loss_reduction": model_args.ctc_loss_reduction,
+            "pad_token_id": tokenizer.pad_token_id,
+            "vocab_size": len(tokenizer),
+            "activation_dropout": model_args.activation_dropout,
+        }
+    )
+
+    # create model
+    model = AutoModelForCTC.from_pretrained(
+        model_args.model_name_or_path,
+        cache_dir=model_args.cache_dir,
+        config=config,
+        use_auth_token=data_args.use_auth_token,
+    )
+
+    # freeze encoder
+    if model_args.freeze_feature_encoder:
+        model.freeze_feature_encoder()
+
+    # 6. Now we preprocess the datasets including loading the audio, resampling and normalization
+    # Thankfully, `datasets` takes care of automatically loading and resampling the audio,
+    # so that we just need to set the correct target sampling rate and normalize the input
+    # via the `feature_extractor`
+
+    # make sure that dataset decodes audio with correct sampling rate
+    dataset_sampling_rate = next(iter(raw_datasets.values())).features[data_args.audio_column_name].sampling_rate
+    if dataset_sampling_rate != feature_extractor.sampling_rate:
+        raw_datasets = raw_datasets.cast_column(
+            data_args.audio_column_name, datasets.features.Audio(sampling_rate=feature_extractor.sampling_rate)
+        )
+
+    # derive max & min input length for sample rate & max duration
+    max_input_length = data_args.max_duration_in_seconds * feature_extractor.sampling_rate
+    min_input_length = data_args.min_duration_in_seconds * feature_extractor.sampling_rate
+    audio_column_name = data_args.audio_column_name
+    num_workers = data_args.preprocessing_num_workers
+
+    # `phoneme_language` is only relevant if the model is fine-tuned on phoneme classification
+    phoneme_language = data_args.phoneme_language
+
+    # Preprocessing the datasets.
+    # We need to read the audio files as arrays and tokenize the targets.
+    def prepare_dataset(batch):
+        # load audio
+        sample = batch[audio_column_name]
+
+        inputs = feature_extractor(sample["array"], sampling_rate=sample["sampling_rate"])
+        batch["input_values"] = inputs.input_values[0]
+        batch["input_length"] = len(batch["input_values"])
+
+        # encode targets
+        additional_kwargs = {}
+        if phoneme_language is not None:
+            additional_kwargs["phonemizer_lang"] = phoneme_language
+
+        batch["labels"] = tokenizer(batch["target_text"], **additional_kwargs).input_ids
+        return batch
+
+    with training_args.main_process_first(desc="dataset map preprocessing"):
+        vectorized_datasets = raw_datasets.map(
+            prepare_dataset,
+            remove_columns=next(iter(raw_datasets.values())).column_names,
+            num_proc=num_workers,
+            desc="preprocess datasets",
+        )
+
+        def is_audio_in_length_range(length):
+            return length > min_input_length and length < max_input_length
+
+        # filter data that is shorter than min_input_length
+        vectorized_datasets = vectorized_datasets.filter(
+            is_audio_in_length_range,
+            num_proc=num_workers,
+            input_columns=["input_length"],
+        )
+
+    # 7. Next, we can prepare the training.
+    # Let's use word error rate (WER) as our evaluation metric,
+    # instantiate a data collator and the trainer
+
+    # Define evaluation metrics during training, *i.e.* word error rate, character error rate
+    eval_metrics = {metric: load_metric(metric) for metric in data_args.eval_metrics}
+
+    # for large datasets it is advised to run the preprocessing on a
+    # single machine first with ``args.preprocessing_only`` since there will mostly likely
+    # be a timeout when running the script in distributed mode.
+    # In a second step ``args.preprocessing_only`` can then be set to `False` to load the
+    # cached dataset
+    if data_args.preprocessing_only:
+        logger.info(f"Data preprocessing finished. Files cached at {vectorized_datasets.cache_files}")
+        return
+
+    def compute_metrics(pred):
+        pred_logits = pred.predictions
+        pred_ids = np.argmax(pred_logits, axis=-1)
+
+        pred.label_ids[pred.label_ids == -100] = tokenizer.pad_token_id
+
+        pred_str = tokenizer.batch_decode(pred_ids)
+        # we do not want to group tokens when computing the metrics
+        label_str = tokenizer.batch_decode(pred.label_ids, group_tokens=False)
+
+        metrics = {k: v.compute(predictions=pred_str, references=label_str) for k, v in eval_metrics.items()}
+
+        return metrics
+
+    # Now save everything to be able to create a single processor later
+    if is_main_process(training_args.local_rank):
+        # save feature extractor, tokenizer and config
+        feature_extractor.save_pretrained(training_args.output_dir)
+        tokenizer.save_pretrained(training_args.output_dir)
+        config.save_pretrained(training_args.output_dir)
+
+    try:
+        processor = AutoProcessor.from_pretrained(training_args.output_dir)
+    except (OSError, KeyError):
+        warnings.warn(
+            "Loading a processor from a feature extractor config that does not"
+            " include a `processor_class` attribute is deprecated and will be removed in v5. Please add the following "
+            " attribute to your `preprocessor_config.json` file to suppress this warning: "
+            " `'processor_class': 'Wav2Vec2Processor'`",
+            FutureWarning,
+        )
+        processor = Wav2Vec2Processor.from_pretrained(training_args.output_dir)
+
+    # Instantiate custom data collator
+    data_collator = DataCollatorCTCWithPadding(processor=processor)
+
+    # Initialize Trainer
+    trainer = Trainer(
+        model=model,
+        data_collator=data_collator,
+        args=training_args,
+        compute_metrics=compute_metrics,
+        train_dataset=vectorized_datasets["train"] if training_args.do_train else None,
+        eval_dataset=vectorized_datasets["eval"] if training_args.do_eval else None,
+        tokenizer=feature_extractor,
+    )
+
+    # 8. Finally, we can start training
+
+    # Training
+    if training_args.do_train:
+
+        # use last checkpoint if exist
+        if last_checkpoint is not None:
+            checkpoint = last_checkpoint
+        elif os.path.isdir(model_args.model_name_or_path):
+            checkpoint = model_args.model_name_or_path
+        else:
+            checkpoint = None
+
+        train_result = trainer.train(resume_from_checkpoint=checkpoint)
+        trainer.save_model()
+
+        metrics = train_result.metrics
+        max_train_samples = (
+            data_args.max_train_samples
+            if data_args.max_train_samples is not None
+            else len(vectorized_datasets["train"])
+        )
+        metrics["train_samples"] = min(max_train_samples, len(vectorized_datasets["train"]))
+
+        trainer.log_metrics("train", metrics)
+        trainer.save_metrics("train", metrics)
+        trainer.save_state()
+
+    # Evaluation
+    results = {}
+    if training_args.do_eval:
+        logger.info("*** Evaluate ***")
+        metrics = trainer.evaluate()
+        max_eval_samples = (
+            data_args.max_eval_samples if data_args.max_eval_samples is not None else len(vectorized_datasets["eval"])
+        )
+        metrics["eval_samples"] = min(max_eval_samples, len(vectorized_datasets["eval"]))
+
+        trainer.log_metrics("eval", metrics)
+        trainer.save_metrics("eval", metrics)
+
+    # Write model card and (optionally) push to hub
+    config_name = data_args.dataset_config_name if data_args.dataset_config_name is not None else "na"
+    kwargs = {
+        "finetuned_from": model_args.model_name_or_path,
+        "tasks": "speech-recognition",
+        "tags": ["automatic-speech-recognition", data_args.dataset_name],
+        "dataset_args": f"Config: {config_name}, Training split: {data_args.train_split_name}, Eval split: {data_args.eval_split_name}",
+        "dataset": f"{data_args.dataset_name.upper()} - {config_name.upper()}",
+    }
+    if "common_voice" in data_args.dataset_name:
+        kwargs["language"] = config_name
+
+    if training_args.push_to_hub:
+        trainer.push_to_hub(**kwargs)
+    else:
+        trainer.create_model_card(**kwargs)
+
+    return results
+
+
+if __name__ == "__main__":
+    main()

scaler.pt

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

scheduler.pt

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

special_tokens_map.json

@@ -0,0 +1 @@
+{"bos_token": "<s>", "eos_token": "</s>", "unk_token": "<unk>", "pad_token": "<pad>", "additional_special_tokens": [{"content": "<s>", "single_word": false, "lstrip": false, "rstrip": false, "normalized": true}, {"content": "</s>", "single_word": false, "lstrip": false, "rstrip": false, "normalized": true}]}

tokenizer_config.json

@@ -0,0 +1 @@
+{"unk_token": "<unk>", "bos_token": "<s>", "eos_token": "</s>", "pad_token": "<pad>", "do_lower_case": false, "word_delimiter_token": "|", "special_tokens_map_file": null, "tokenizer_file": null, "name_or_path": "/dbfs/FileStore/Iskaj/Models/X-LSR_CV_60_EP/checkpoint-26800", "tokenizer_class": "Wav2Vec2CTCTokenizer", "processor_class": "Wav2Vec2ProcessorWithLM"}

trainer_state.json

@@ -0,0 +1,3835 @@
+{
+  "best_metric": 0.4362342655658722,
+  "best_model_checkpoint": "/local_disk0/X-LSR_CV_60_EP/checkpoint-2400",
+  "epoch": 59.55555555555556,
+  "global_step": 26800,
+  "is_hyper_param_search": false,
+  "is_local_process_zero": true,
+  "is_world_process_zero": true,
+  "log_history": [
+    {
+      "epoch": 0.11,
+      "learning_rate": 2.9999999999999997e-05,
+      "loss": 11.3191,
+      "step": 50
+    },
+    {
+      "epoch": 0.22,
+      "learning_rate": 5.9999999999999995e-05,
+      "loss": 5.2444,
+      "step": 100
+    },
+    {
+      "epoch": 0.33,
+      "learning_rate": 8.999999999999999e-05,
+      "loss": 3.4938,
+      "step": 150
+    },
+    {
+      "epoch": 0.44,
+      "learning_rate": 0.00011999999999999999,
+      "loss": 3.0165,
+      "step": 200
+    },
+    {
+      "epoch": 0.56,
+      "learning_rate": 0.00015,
+      "loss": 2.9377,
+      "step": 250
+    },
+    {
+      "epoch": 0.67,
+      "learning_rate": 0.00017999999999999998,
+      "loss": 2.9175,
+      "step": 300
+    },
+    {
+      "epoch": 0.78,
+      "learning_rate": 0.00020999999999999998,
+      "loss": 2.8908,
+      "step": 350
+    },
+    {
+      "epoch": 0.89,
+      "learning_rate": 0.00023999999999999998,
+      "loss": 2.8684,
+      "step": 400
+    },
+    {
+      "epoch": 0.89,
+      "eval_loss": 2.944436550140381,
+      "eval_runtime": 232.2253,
+      "eval_samples_per_second": 24.58,
+      "eval_steps_per_second": 3.075,
+      "eval_wer": 0.9999796528781004,
+      "step": 400
+    },
+    {
+      "epoch": 1.0,
+      "learning_rate": 0.00027,
+      "loss": 2.8525,
+      "step": 450
+    },
+    {
+      "epoch": 1.11,
+      "learning_rate": 0.0003,
+      "loss": 2.6961,
+      "step": 500
+    },
+    {
+      "epoch": 1.22,
+      "learning_rate": 0.0002994339622641509,
+      "loss": 1.6145,
+      "step": 550
+    },
+    {
+      "epoch": 1.33,
+      "learning_rate": 0.00029886792452830187,
+      "loss": 1.0359,
+      "step": 600
+    },
+    {
+      "epoch": 1.44,
+      "learning_rate": 0.0002983018867924528,
+      "loss": 0.8086,
+      "step": 650
+    },
+    {
+      "epoch": 1.56,
+      "learning_rate": 0.00029773584905660376,
+      "loss": 0.7171,
+      "step": 700
+    },
+    {
+      "epoch": 1.67,
+      "learning_rate": 0.0002971698113207547,
+      "loss": 0.6152,
+      "step": 750
+    },
+    {
+      "epoch": 1.78,
+      "learning_rate": 0.00029660377358490565,
+      "loss": 0.5631,
+      "step": 800
+    },
+    {
+      "epoch": 1.78,
+      "eval_loss": 0.641059398651123,
+      "eval_runtime": 232.9944,
+      "eval_samples_per_second": 24.498,
+      "eval_steps_per_second": 3.064,
+      "eval_wer": 0.5468289010519461,
+      "step": 800
+    },
+    {
+      "epoch": 1.89,
+      "learning_rate": 0.00029603773584905657,
+      "loss": 0.521,
+      "step": 850
+    },
+    {
+      "epoch": 2.0,
+      "learning_rate": 0.00029547169811320755,
+      "loss": 0.4953,
+      "step": 900
+    },
+    {
+      "epoch": 2.11,
+      "learning_rate": 0.00029490566037735847,
+      "loss": 0.4331,
+      "step": 950
+    },
+    {
+      "epoch": 2.22,
+      "learning_rate": 0.0002943396226415094,
+      "loss": 0.396,
+      "step": 1000
+    },
+    {
+      "epoch": 2.33,
+      "learning_rate": 0.00029377358490566036,
+      "loss": 0.4066,
+      "step": 1050
+    },
+    {
+      "epoch": 2.44,
+      "learning_rate": 0.0002932075471698113,
+      "loss": 0.3839,
+      "step": 1100
+    },
+    {
+      "epoch": 2.56,
+      "learning_rate": 0.00029264150943396225,
+      "loss": 0.3705,
+      "step": 1150
+    },
+    {
+      "epoch": 2.67,
+      "learning_rate": 0.00029207547169811317,
+      "loss": 0.3707,
+      "step": 1200
+    },
+    {
+      "epoch": 2.67,
+      "eval_loss": 0.5500322580337524,
+      "eval_runtime": 232.2885,
+      "eval_samples_per_second": 24.573,
+      "eval_steps_per_second": 3.074,
+      "eval_wer": 0.4608012696604065,
+      "step": 1200
+    },
+    {
+      "epoch": 2.78,
+      "learning_rate": 0.00029150943396226414,
+      "loss": 0.3813,
+      "step": 1250
+    },
+    {
+      "epoch": 2.89,
+      "learning_rate": 0.00029094339622641506,
+      "loss": 0.3572,
+      "step": 1300
+    },
+    {
+      "epoch": 3.0,
+      "learning_rate": 0.00029037735849056604,
+      "loss": 0.3483,
+      "step": 1350
+    },
+    {
+      "epoch": 3.11,
+      "learning_rate": 0.00028981132075471696,
+      "loss": 0.2772,
+      "step": 1400
+    },
+    {
+      "epoch": 3.22,
+      "learning_rate": 0.0002892452830188679,
+      "loss": 0.2977,
+      "step": 1450
+    },
+    {
+      "epoch": 3.33,
+      "learning_rate": 0.00028867924528301885,
+      "loss": 0.2802,
+      "step": 1500
+    },
+    {
+      "epoch": 3.44,
+      "learning_rate": 0.00028811320754716977,
+      "loss": 0.2913,
+      "step": 1550
+    },
+    {
+      "epoch": 3.56,
+      "learning_rate": 0.00028754716981132074,
+      "loss": 0.2899,
+      "step": 1600
+    },
+    {
+      "epoch": 3.56,
+      "eval_loss": 0.5040135383605957,
+      "eval_runtime": 232.8201,
+      "eval_samples_per_second": 24.517,
+      "eval_steps_per_second": 3.067,
+      "eval_wer": 0.420412232689686,
+      "step": 1600
+    },
+    {
+      "epoch": 3.67,
+      "learning_rate": 0.00028698113207547166,
+      "loss": 0.2802,
+      "step": 1650
+    },
+    {
+      "epoch": 3.78,
+      "learning_rate": 0.00028641509433962264,
+      "loss": 0.2769,
+      "step": 1700
+    },
+    {
+      "epoch": 3.89,
+      "learning_rate": 0.00028584905660377356,
+      "loss": 0.2632,
+      "step": 1750
+    },
+    {
+      "epoch": 4.0,
+      "learning_rate": 0.00028528301886792453,
+      "loss": 0.2784,
+      "step": 1800
+    },
+    {
+      "epoch": 4.11,
+      "learning_rate": 0.00028471698113207545,
+      "loss": 0.2341,
+      "step": 1850
+    },
+    {
+      "epoch": 4.22,
+      "learning_rate": 0.00028415094339622637,
+      "loss": 0.2346,
+      "step": 1900
+    },
+    {
+      "epoch": 4.33,
+      "learning_rate": 0.00028358490566037734,
+      "loss": 0.2301,
+      "step": 1950
+    },
+    {
+      "epoch": 4.44,
+      "learning_rate": 0.00028301886792452826,
+      "loss": 0.2376,
+      "step": 2000
+    },
+    {
+      "epoch": 4.44,
+      "eval_loss": 0.4637417495250702,
+      "eval_runtime": 233.0278,
+      "eval_samples_per_second": 24.495,
+      "eval_steps_per_second": 3.064,
+      "eval_wer": 0.3989663662074999,
+      "step": 2000
+    },
+    {
+      "epoch": 4.56,
+      "learning_rate": 0.00028245283018867923,
+      "loss": 0.2474,
+      "step": 2050
+    },
+    {
+      "epoch": 4.67,
+      "learning_rate": 0.00028188679245283015,
+      "loss": 0.2325,
+      "step": 2100
+    },
+    {
+      "epoch": 4.78,
+      "learning_rate": 0.00028132075471698113,
+      "loss": 0.2477,
+      "step": 2150
+    },
+    {
+      "epoch": 4.89,
+      "learning_rate": 0.00028075471698113205,
+      "loss": 0.2319,
+      "step": 2200
+    },
+    {
+      "epoch": 5.0,
+      "learning_rate": 0.000280188679245283,
+      "loss": 0.2342,
+      "step": 2250
+    },
+    {
+      "epoch": 5.11,
+      "learning_rate": 0.00027962264150943394,
+      "loss": 0.2176,
+      "step": 2300
+    },
+    {
+      "epoch": 5.22,
+      "learning_rate": 0.00027905660377358486,
+      "loss": 0.2015,
+      "step": 2350
+    },
+    {
+      "epoch": 5.33,
+      "learning_rate": 0.00027849056603773583,
+      "loss": 0.2063,
+      "step": 2400
+    },
+    {
+      "epoch": 5.33,
+      "eval_loss": 0.4362342655658722,
+      "eval_runtime": 234.4496,
+      "eval_samples_per_second": 24.346,
+      "eval_steps_per_second": 3.045,
+      "eval_wer": 0.3932488249537103,
+      "step": 2400
+    },
+    {
+      "epoch": 5.44,
+      "learning_rate": 0.00027792452830188675,
+      "loss": 0.2116,
+      "step": 2450
+    },
+    {
+      "epoch": 5.56,
+      "learning_rate": 0.0002773584905660377,
+      "loss": 0.2084,
+      "step": 2500
+    },
+    {
+      "epoch": 5.67,
+      "learning_rate": 0.00027679245283018865,
+      "loss": 0.2122,
+      "step": 2550
+    },
+    {
+      "epoch": 5.78,
+      "learning_rate": 0.0002762264150943396,
+      "loss": 0.2063,
+      "step": 2600
+    },
+    {
+      "epoch": 5.89,
+      "learning_rate": 0.00027566037735849054,
+      "loss": 0.1902,
+      "step": 2650
+    },
+    {
+      "epoch": 6.0,
+      "learning_rate": 0.0002750943396226415,
+      "loss": 0.2067,
+      "step": 2700
+    },
+    {
+      "epoch": 6.11,
+      "learning_rate": 0.00027452830188679243,
+      "loss": 0.1845,
+      "step": 2750
+    },
+    {
+      "epoch": 6.22,
+      "learning_rate": 0.0002739622641509434,
+      "loss": 0.1773,
+      "step": 2800
+    },
+    {
+      "epoch": 6.22,
+      "eval_loss": 0.4410901367664337,
+      "eval_runtime": 235.6532,
+      "eval_samples_per_second": 24.222,
+      "eval_steps_per_second": 3.03,
+      "eval_wer": 0.3876737135532179,
+      "step": 2800
+    },
+    {
+      "epoch": 6.33,
+      "learning_rate": 0.0002733962264150943,
+      "loss": 0.1793,
+      "step": 2850
+    },
+    {
+      "epoch": 6.44,
+      "learning_rate": 0.00027283018867924524,
+      "loss": 0.1764,
+      "step": 2900
+    },
+    {
+      "epoch": 6.56,
+      "learning_rate": 0.0002722641509433962,
+      "loss": 0.1882,
+      "step": 2950
+    },
+    {
+      "epoch": 6.67,
+      "learning_rate": 0.00027169811320754714,
+      "loss": 0.1892,
+      "step": 3000
+    },
+    {
+      "epoch": 6.78,
+      "learning_rate": 0.0002711320754716981,
+      "loss": 0.1941,
+      "step": 3050
+    },
+    {
+      "epoch": 6.89,
+      "learning_rate": 0.00027056603773584903,
+      "loss": 0.1858,
+      "step": 3100
+    },
+    {
+      "epoch": 7.0,
+      "learning_rate": 0.00027,
+      "loss": 0.1817,
+      "step": 3150
+    },
+    {
+      "epoch": 7.11,
+      "learning_rate": 0.0002694339622641509,
+      "loss": 0.1676,
+      "step": 3200
+    },
+    {
+      "epoch": 7.11,
+      "eval_loss": 0.479378342628479,
+      "eval_runtime": 234.1851,
+      "eval_samples_per_second": 24.374,
+      "eval_steps_per_second": 3.049,
+      "eval_wer": 0.38449956253687917,
+      "step": 3200
+    },
+    {
+      "epoch": 7.22,
+      "learning_rate": 0.0002688679245283019,
+      "loss": 0.1728,
+      "step": 3250
+    },
+    {
+      "epoch": 7.33,
+      "learning_rate": 0.0002683018867924528,
+      "loss": 0.1597,
+      "step": 3300
+    },
+    {
+      "epoch": 7.44,
+      "learning_rate": 0.00026773584905660374,
+      "loss": 0.1695,
+      "step": 3350
+    },
+    {
+      "epoch": 7.56,
+      "learning_rate": 0.0002671698113207547,
+      "loss": 0.1662,
+      "step": 3400
+    },
+    {
+      "epoch": 7.67,
+      "learning_rate": 0.00026660377358490563,
+      "loss": 0.1612,
+      "step": 3450
+    },
+    {
+      "epoch": 7.78,
+      "learning_rate": 0.0002660377358490566,
+      "loss": 0.1611,
+      "step": 3500
+    },
+    {
+      "epoch": 7.89,
+      "learning_rate": 0.0002654716981132075,
+      "loss": 0.1669,
+      "step": 3550
+    },
+    {
+      "epoch": 8.0,
+      "learning_rate": 0.0002649056603773585,
+      "loss": 0.1728,
+      "step": 3600
+    },
+    {
+      "epoch": 8.0,
+      "eval_loss": 0.4429037272930145,
+      "eval_runtime": 233.3956,
+      "eval_samples_per_second": 24.456,
+      "eval_steps_per_second": 3.059,
+      "eval_wer": 0.37750015260341424,
+      "step": 3600
+    },
+    {
+      "epoch": 8.11,
+      "learning_rate": 0.0002643396226415094,
+      "loss": 0.1543,
+      "step": 3650
+    },
+    {
+      "epoch": 8.22,
+      "learning_rate": 0.0002637735849056604,
+      "loss": 0.152,
+      "step": 3700
+    },
+    {
+      "epoch": 8.33,
+      "learning_rate": 0.0002632075471698113,
+      "loss": 0.1552,
+      "step": 3750
+    },
+    {
+      "epoch": 8.44,
+      "learning_rate": 0.0002626415094339622,
+      "loss": 0.16,
+      "step": 3800
+    },
+    {
+      "epoch": 8.56,
+      "learning_rate": 0.0002620754716981132,
+      "loss": 0.1645,
+      "step": 3850
+    },
+    {
+      "epoch": 8.67,
+      "learning_rate": 0.0002615094339622641,
+      "loss": 0.158,
+      "step": 3900
+    },
+    {
+      "epoch": 8.78,
+      "learning_rate": 0.0002609433962264151,
+      "loss": 0.1654,
+      "step": 3950
+    },
+    {
+      "epoch": 8.89,
+      "learning_rate": 0.000260377358490566,
+      "loss": 0.1556,
+      "step": 4000
+    },
+    {
+      "epoch": 8.89,
+      "eval_loss": 0.4799572825431824,
+      "eval_runtime": 233.7994,
+      "eval_samples_per_second": 24.414,
+      "eval_steps_per_second": 3.054,
+      "eval_wer": 0.38354324780759763,
+      "step": 4000
+    },
+    {
+      "epoch": 9.0,
+      "learning_rate": 0.000259811320754717,
+      "loss": 0.1627,
+      "step": 4050
+    },
+    {
+      "epoch": 9.11,
+      "learning_rate": 0.0002592452830188679,
+      "loss": 0.1443,
+      "step": 4100
+    },
+    {
+      "epoch": 9.22,
+      "learning_rate": 0.0002586792452830189,
+      "loss": 0.1527,
+      "step": 4150
+    },
+    {
+      "epoch": 9.33,
+      "learning_rate": 0.0002581132075471698,
+      "loss": 0.1516,
+      "step": 4200
+    },
+    {
+      "epoch": 9.44,
+      "learning_rate": 0.0002575471698113207,
+      "loss": 0.1554,
+      "step": 4250
+    },
+    {
+      "epoch": 9.56,
+      "learning_rate": 0.0002569811320754717,
+      "loss": 0.1502,
+      "step": 4300
+    },
+    {
+      "epoch": 9.67,
+      "learning_rate": 0.0002564150943396226,
+      "loss": 0.1496,
+      "step": 4350
+    },
+    {
+      "epoch": 9.78,
+      "learning_rate": 0.0002558490566037736,
+      "loss": 0.1514,
+      "step": 4400
+    },
+    {
+      "epoch": 9.78,
+      "eval_loss": 0.46985962986946106,
+      "eval_runtime": 235.3127,
+      "eval_samples_per_second": 24.257,
+      "eval_steps_per_second": 3.034,
+      "eval_wer": 0.3755264817791523,
+      "step": 4400
+    },
+    {
+      "epoch": 9.89,
+      "learning_rate": 0.0002552830188679245,
+      "loss": 0.1501,
+      "step": 4450
+    },
+    {
+      "epoch": 10.0,
+      "learning_rate": 0.0002547169811320755,
+      "loss": 0.1464,
+      "step": 4500
+    },
+    {
+      "epoch": 10.11,
+      "learning_rate": 0.0002541509433962264,
+      "loss": 0.1354,
+      "step": 4550
+    },
+    {
+      "epoch": 10.22,
+      "learning_rate": 0.00025358490566037737,
+      "loss": 0.1315,
+      "step": 4600
+    },
+    {
+      "epoch": 10.33,
+      "learning_rate": 0.0002530188679245283,
+      "loss": 0.1365,
+      "step": 4650
+    },
+    {
+      "epoch": 10.44,
+      "learning_rate": 0.0002524528301886792,
+      "loss": 0.1399,
+      "step": 4700
+    },
+    {
+      "epoch": 10.56,
+      "learning_rate": 0.0002518867924528302,
+      "loss": 0.1351,
+      "step": 4750
+    },
+    {
+      "epoch": 10.67,
+      "learning_rate": 0.0002513207547169811,
+      "loss": 0.1405,
+      "step": 4800
+    },
+    {
+      "epoch": 10.67,
+      "eval_loss": 0.47201868891716003,
+      "eval_runtime": 234.4469,
+      "eval_samples_per_second": 24.347,
+      "eval_steps_per_second": 3.045,
+      "eval_wer": 0.3793517406962785,
+      "step": 4800
+    },
+    {
+      "epoch": 10.78,
+      "learning_rate": 0.0002507547169811321,
+      "loss": 0.1446,
+      "step": 4850
+    },
+    {
+      "epoch": 10.89,
+      "learning_rate": 0.000250188679245283,
+      "loss": 0.1402,
+      "step": 4900
+    },
+    {
+      "epoch": 11.0,
+      "learning_rate": 0.00024962264150943397,
+      "loss": 0.1417,
+      "step": 4950
+    },
+    {
+      "epoch": 11.11,
+      "learning_rate": 0.0002490566037735849,
+      "loss": 0.1326,
+      "step": 5000
+    },
+    {
+      "epoch": 11.22,
+      "learning_rate": 0.00024849056603773586,
+      "loss": 0.1409,
+      "step": 5050
+    },
+    {
+      "epoch": 11.33,
+      "learning_rate": 0.0002479245283018868,
+      "loss": 0.1279,
+      "step": 5100
+    },
+    {
+      "epoch": 11.44,
+      "learning_rate": 0.0002473584905660377,
+      "loss": 0.1333,
+      "step": 5150
+    },
+    {
+      "epoch": 11.56,
+      "learning_rate": 0.0002467924528301887,
+      "loss": 0.1317,
+      "step": 5200
+    },
+    {
+      "epoch": 11.56,
+      "eval_loss": 0.5062007904052734,
+      "eval_runtime": 233.2872,
+      "eval_samples_per_second": 24.468,
+      "eval_steps_per_second": 3.061,
+      "eval_wer": 0.3787006327954911,
+      "step": 5200
+    },
+    {
+      "epoch": 11.67,
+      "learning_rate": 0.0002462264150943396,
+      "loss": 0.1309,
+      "step": 5250
+    },
+    {
+      "epoch": 11.78,
+      "learning_rate": 0.00024566037735849057,
+      "loss": 0.1344,
+      "step": 5300
+    },
+    {
+      "epoch": 11.89,
+      "learning_rate": 0.0002450943396226415,
+      "loss": 0.1339,
+      "step": 5350
+    },
+    {
+      "epoch": 12.0,
+      "learning_rate": 0.00024452830188679246,
+      "loss": 0.1403,
+      "step": 5400
+    },
+    {
+      "epoch": 12.11,
+      "learning_rate": 0.00024396226415094338,
+      "loss": 0.1208,
+      "step": 5450
+    },
+    {
+      "epoch": 12.22,
+      "learning_rate": 0.00024339622641509433,
+      "loss": 0.1278,
+      "step": 5500
+    },
+    {
+      "epoch": 12.33,
+      "learning_rate": 0.00024283018867924527,
+      "loss": 0.1148,
+      "step": 5550
+    },
+    {
+      "epoch": 12.44,
+      "learning_rate": 0.00024226415094339622,
+      "loss": 0.1204,
+      "step": 5600
+    },
+    {
+      "epoch": 12.44,
+      "eval_loss": 0.4777355492115021,
+      "eval_runtime": 233.4682,
+      "eval_samples_per_second": 24.449,
+      "eval_steps_per_second": 3.058,
+      "eval_wer": 0.36860846033328587,
+      "step": 5600
+    },
+    {
+      "epoch": 12.56,
+      "learning_rate": 0.00024169811320754717,
+      "loss": 0.1237,
+      "step": 5650
+    },
+    {
+      "epoch": 12.67,
+      "learning_rate": 0.0002411320754716981,
+      "loss": 0.124,
+      "step": 5700
+    },
+    {
+      "epoch": 12.78,
+      "learning_rate": 0.00024056603773584906,
+      "loss": 0.1358,
+      "step": 5750
+    },
+    {
+      "epoch": 12.89,
+      "learning_rate": 0.00023999999999999998,
+      "loss": 0.1243,
+      "step": 5800
+    },
+    {
+      "epoch": 13.0,
+      "learning_rate": 0.00023943396226415093,
+      "loss": 0.1255,
+      "step": 5850
+    },
+    {
+      "epoch": 13.11,
+      "learning_rate": 0.00023886792452830187,
+      "loss": 0.1158,
+      "step": 5900
+    },
+    {
+      "epoch": 13.22,
+      "learning_rate": 0.00023830188679245282,
+      "loss": 0.1135,
+      "step": 5950
+    },
+    {
+      "epoch": 13.33,
+      "learning_rate": 0.00023773584905660377,
+      "loss": 0.12,
+      "step": 6000
+    },
+    {
+      "epoch": 13.33,
+      "eval_loss": 0.5171375870704651,
+      "eval_runtime": 233.056,
+      "eval_samples_per_second": 24.492,
+      "eval_steps_per_second": 3.064,
+      "eval_wer": 0.3718233055934238,
+      "step": 6000
+    },
+    {
+      "epoch": 13.44,
+      "learning_rate": 0.0002371698113207547,
+      "loss": 0.1218,
+      "step": 6050
+    },
+    {
+      "epoch": 13.56,
+      "learning_rate": 0.00023660377358490566,
+      "loss": 0.1244,
+      "step": 6100
+    },
+    {
+      "epoch": 13.67,
+      "learning_rate": 0.0002360377358490566,
+      "loss": 0.1238,
+      "step": 6150
+    },
+    {
+      "epoch": 13.78,
+      "learning_rate": 0.00023547169811320755,
+      "loss": 0.1188,
+      "step": 6200
+    },
+    {
+      "epoch": 13.89,
+      "learning_rate": 0.0002349056603773585,
+      "loss": 0.1167,
+      "step": 6250
+    },
+    {
+      "epoch": 14.0,
+      "learning_rate": 0.00023433962264150942,
+      "loss": 0.1212,
+      "step": 6300
+    },
+    {
+      "epoch": 14.11,
+      "learning_rate": 0.00023377358490566036,
+      "loss": 0.1209,
+      "step": 6350
+    },
+    {
+      "epoch": 14.22,
+      "learning_rate": 0.0002332075471698113,
+      "loss": 0.1176,
+      "step": 6400
+    },
+    {
+      "epoch": 14.22,
+      "eval_loss": 0.5209046602249146,
+      "eval_runtime": 232.7218,
+      "eval_samples_per_second": 24.527,
+      "eval_steps_per_second": 3.068,
+      "eval_wer": 0.37357315807679004,
+      "step": 6400
+    },
+    {
+      "epoch": 14.33,
+      "learning_rate": 0.00023264150943396226,
+      "loss": 0.1108,
+      "step": 6450
+    },
+    {
+      "epoch": 14.44,
+      "learning_rate": 0.0002320754716981132,
+      "loss": 0.1201,
+      "step": 6500
+    },
+    {
+      "epoch": 14.56,
+      "learning_rate": 0.00023150943396226415,
+      "loss": 0.1135,
+      "step": 6550
+    },
+    {
+      "epoch": 14.67,
+      "learning_rate": 0.0002309433962264151,
+      "loss": 0.111,
+      "step": 6600
+    },
+    {
+      "epoch": 14.78,
+      "learning_rate": 0.00023037735849056604,
+      "loss": 0.1169,
+      "step": 6650
+    },
+    {
+      "epoch": 14.89,
+      "learning_rate": 0.000229811320754717,
+      "loss": 0.12,
+      "step": 6700
+    },
+    {
+      "epoch": 15.0,
+      "learning_rate": 0.0002292452830188679,
+      "loss": 0.1145,
+      "step": 6750
+    },
+    {
+      "epoch": 15.11,
+      "learning_rate": 0.00022867924528301886,
+      "loss": 0.1102,
+      "step": 6800
+    },
+    {
+      "epoch": 15.11,
+      "eval_loss": 0.5242590308189392,
+      "eval_runtime": 233.3294,
+      "eval_samples_per_second": 24.463,
+      "eval_steps_per_second": 3.06,
+      "eval_wer": 0.37780535943190835,
+      "step": 6800
+    },
+    {
+      "epoch": 15.22,
+      "learning_rate": 0.0002281132075471698,
+      "loss": 0.0994,
+      "step": 6850
+    },
+    {
+      "epoch": 15.33,
+      "learning_rate": 0.00022754716981132075,
+      "loss": 0.1196,
+      "step": 6900
+    },
+    {
+      "epoch": 15.44,
+      "learning_rate": 0.0002269811320754717,
+      "loss": 0.1125,
+      "step": 6950
+    },
+    {
+      "epoch": 15.56,
+      "learning_rate": 0.00022641509433962264,
+      "loss": 0.1122,
+      "step": 7000
+    },
+    {
+      "epoch": 15.67,
+      "learning_rate": 0.0002258490566037736,
+      "loss": 0.1235,
+      "step": 7050
+    },
+    {
+      "epoch": 15.78,
+      "learning_rate": 0.00022528301886792453,
+      "loss": 0.1088,
+      "step": 7100
+    },
+    {
+      "epoch": 15.89,
+      "learning_rate": 0.00022471698113207543,
+      "loss": 0.1089,
+      "step": 7150
+    },
+    {
+      "epoch": 16.0,
+      "learning_rate": 0.00022415094339622637,
+      "loss": 0.1097,
+      "step": 7200
+    },
+    {
+      "epoch": 16.0,
+      "eval_loss": 0.4982779622077942,
+      "eval_runtime": 233.2014,
+      "eval_samples_per_second": 24.477,
+      "eval_steps_per_second": 3.062,
+      "eval_wer": 0.3620159928378131,
+      "step": 7200
+    },
+    {
+      "epoch": 16.11,
+      "learning_rate": 0.00022358490566037732,
+      "loss": 0.1023,
+      "step": 7250
+    },
+    {
+      "epoch": 16.22,
+      "learning_rate": 0.00022301886792452827,
+      "loss": 0.097,
+      "step": 7300
+    },
+    {
+      "epoch": 16.33,
+      "learning_rate": 0.0002224528301886792,
+      "loss": 0.1002,
+      "step": 7350
+    },
+    {
+      "epoch": 16.44,
+      "learning_rate": 0.00022188679245283016,
+      "loss": 0.1051,
+      "step": 7400
+    },
+    {
+      "epoch": 16.56,
+      "learning_rate": 0.0002213207547169811,
+      "loss": 0.1114,
+      "step": 7450
+    },
+    {
+      "epoch": 16.67,
+      "learning_rate": 0.00022075471698113205,
+      "loss": 0.0984,
+      "step": 7500
+    },
+    {
+      "epoch": 16.78,
+      "learning_rate": 0.00022018867924528297,
+      "loss": 0.1121,
+      "step": 7550
+    },
+    {
+      "epoch": 16.89,
+      "learning_rate": 0.00021962264150943392,
+      "loss": 0.1091,
+      "step": 7600
+    },
+    {
+      "epoch": 16.89,
+      "eval_loss": 0.4976480007171631,
+      "eval_runtime": 232.5964,
+      "eval_samples_per_second": 24.54,
+      "eval_steps_per_second": 3.07,
+      "eval_wer": 0.366166805705333,
+      "step": 7600
+    },
+    {
+      "epoch": 17.0,
+      "learning_rate": 0.00021905660377358486,
+      "loss": 0.1061,
+      "step": 7650
+    },
+    {
+      "epoch": 17.11,
+      "learning_rate": 0.0002184905660377358,
+      "loss": 0.0962,
+      "step": 7700
+    },
+    {
+      "epoch": 17.22,
+      "learning_rate": 0.00021792452830188676,
+      "loss": 0.101,
+      "step": 7750
+    },
+    {
+      "epoch": 17.33,
+      "learning_rate": 0.0002173584905660377,
+      "loss": 0.1109,
+      "step": 7800
+    },
+    {
+      "epoch": 17.44,
+      "learning_rate": 0.00021679245283018865,
+      "loss": 0.1021,
+      "step": 7850
+    },
+    {
+      "epoch": 17.56,
+      "learning_rate": 0.0002162264150943396,
+      "loss": 0.1011,
+      "step": 7900
+    },
+    {
+      "epoch": 17.67,
+      "learning_rate": 0.00021566037735849054,
+      "loss": 0.0992,
+      "step": 7950
+    },
+    {
+      "epoch": 17.78,
+      "learning_rate": 0.00021509433962264146,
+      "loss": 0.104,
+      "step": 8000
+    },
+    {
+      "epoch": 17.78,
+      "eval_loss": 0.5483397245407104,
+      "eval_runtime": 232.4366,
+      "eval_samples_per_second": 24.557,
+      "eval_steps_per_second": 3.072,
+      "eval_wer": 0.3651901438541518,
+      "step": 8000
+    },
+    {
+      "epoch": 17.89,
+      "learning_rate": 0.0002145283018867924,
+      "loss": 0.1047,
+      "step": 8050
+    },
+    {
+      "epoch": 18.0,
+      "learning_rate": 0.00021396226415094336,
+      "loss": 0.1026,
+      "step": 8100
+    },
+    {
+      "epoch": 18.11,
+      "learning_rate": 0.0002133962264150943,
+      "loss": 0.0929,
+      "step": 8150
+    },
+    {
+      "epoch": 18.22,
+      "learning_rate": 0.00021283018867924525,
+      "loss": 0.0933,
+      "step": 8200
+    },
+    {
+      "epoch": 18.33,
+      "learning_rate": 0.0002122641509433962,
+      "loss": 0.0971,
+      "step": 8250
+    },
+    {
+      "epoch": 18.44,
+      "learning_rate": 0.00021169811320754714,
+      "loss": 0.097,
+      "step": 8300
+    },
+    {
+      "epoch": 18.56,
+      "learning_rate": 0.0002111320754716981,
+      "loss": 0.097,
+      "step": 8350
+    },
+    {
+      "epoch": 18.67,
+      "learning_rate": 0.00021056603773584904,
+      "loss": 0.1014,
+      "step": 8400
+    },
+    {
+      "epoch": 18.67,
+      "eval_loss": 0.5109674334526062,
+      "eval_runtime": 233.1396,
+      "eval_samples_per_second": 24.483,
+      "eval_steps_per_second": 3.063,
+      "eval_wer": 0.3620159928378131,
+      "step": 8400
+    },
+    {
+      "epoch": 18.78,
+      "learning_rate": 0.00020999999999999998,
+      "loss": 0.0936,
+      "step": 8450
+    },
+    {
+      "epoch": 18.89,
+      "learning_rate": 0.0002094339622641509,
+      "loss": 0.0948,
+      "step": 8500
+    },
+    {
+      "epoch": 19.0,
+      "learning_rate": 0.00020886792452830185,
+      "loss": 0.0928,
+      "step": 8550
+    },
+    {
+      "epoch": 19.11,
+      "learning_rate": 0.0002083018867924528,
+      "loss": 0.0912,
+      "step": 8600
+    },
+    {
+      "epoch": 19.22,
+      "learning_rate": 0.00020773584905660374,
+      "loss": 0.0918,
+      "step": 8650
+    },
+    {
+      "epoch": 19.33,
+      "learning_rate": 0.0002071698113207547,
+      "loss": 0.0902,
+      "step": 8700
+    },
+    {
+      "epoch": 19.44,
+      "learning_rate": 0.00020660377358490563,
+      "loss": 0.0961,
+      "step": 8750
+    },
+    {
+      "epoch": 19.56,
+      "learning_rate": 0.00020603773584905658,
+      "loss": 0.0921,
+      "step": 8800
+    },
+    {
+      "epoch": 19.56,
+      "eval_loss": 0.4945477545261383,
+      "eval_runtime": 232.6384,
+      "eval_samples_per_second": 24.536,
+      "eval_steps_per_second": 3.069,
+      "eval_wer": 0.3609375953771339,
+      "step": 8800
+    },
+    {
+      "epoch": 19.67,
+      "learning_rate": 0.00020547169811320753,
+      "loss": 0.0957,
+      "step": 8850
+    },
+    {
+      "epoch": 19.78,
+      "learning_rate": 0.00020491698113207546,
+      "loss": 0.0958,
+      "step": 8900
+    },
+    {
+      "epoch": 19.89,
+      "learning_rate": 0.0002043509433962264,
+      "loss": 0.0952,
+      "step": 8950
+    },
+    {
+      "epoch": 20.0,
+      "learning_rate": 0.00020378490566037735,
+      "loss": 0.0847,
+      "step": 9000
+    },
+    {
+      "epoch": 20.11,
+      "learning_rate": 0.00020321886792452827,
+      "loss": 0.0921,
+      "step": 9050
+    },
+    {
+      "epoch": 20.22,
+      "learning_rate": 0.00020265283018867922,
+      "loss": 0.0885,
+      "step": 9100
+    },
+    {
+      "epoch": 20.33,
+      "learning_rate": 0.00020208679245283017,
+      "loss": 0.0881,
+      "step": 9150
+    },
+    {
+      "epoch": 20.44,
+      "learning_rate": 0.0002015207547169811,
+      "loss": 0.0943,
+      "step": 9200
+    },
+    {
+      "epoch": 20.44,
+      "eval_loss": 0.5395381450653076,
+      "eval_runtime": 232.8056,
+      "eval_samples_per_second": 24.518,
+      "eval_steps_per_second": 3.067,
+      "eval_wer": 0.36470181292856124,
+      "step": 9200
+    },
+    {
+      "epoch": 20.56,
+      "learning_rate": 0.00020095471698113206,
+      "loss": 0.0888,
+      "step": 9250
+    },
+    {
+      "epoch": 20.67,
+      "learning_rate": 0.000200388679245283,
+      "loss": 0.0894,
+      "step": 9300
+    },
+    {
+      "epoch": 20.78,
+      "learning_rate": 0.00019982264150943395,
+      "loss": 0.0883,
+      "step": 9350
+    },
+    {
+      "epoch": 20.89,
+      "learning_rate": 0.0001992566037735849,
+      "loss": 0.0873,
+      "step": 9400
+    },
+    {
+      "epoch": 21.0,
+      "learning_rate": 0.00019869056603773584,
+      "loss": 0.095,
+      "step": 9450
+    },
+    {
+      "epoch": 21.11,
+      "learning_rate": 0.00019812452830188676,
+      "loss": 0.087,
+      "step": 9500
+    },
+    {
+      "epoch": 21.22,
+      "learning_rate": 0.0001975584905660377,
+      "loss": 0.0795,
+      "step": 9550
+    },
+    {
+      "epoch": 21.33,
+      "learning_rate": 0.00019699245283018866,
+      "loss": 0.0877,
+      "step": 9600
+    },
+    {
+      "epoch": 21.33,
+      "eval_loss": 0.516017735004425,
+      "eval_runtime": 232.5407,
+      "eval_samples_per_second": 24.546,
+      "eval_steps_per_second": 3.07,
+      "eval_wer": 0.37127393330213443,
+      "step": 9600
+    },
+    {
+      "epoch": 21.44,
+      "learning_rate": 0.0001964264150943396,
+      "loss": 0.0902,
+      "step": 9650
+    },
+    {
+      "epoch": 21.56,
+      "learning_rate": 0.00019586037735849055,
+      "loss": 0.0898,
+      "step": 9700
+    },
+    {
+      "epoch": 21.67,
+      "learning_rate": 0.0001952943396226415,
+      "loss": 0.0934,
+      "step": 9750
+    },
+    {
+      "epoch": 21.78,
+      "learning_rate": 0.00019472830188679244,
+      "loss": 0.0845,
+      "step": 9800
+    },
+    {
+      "epoch": 21.89,
+      "learning_rate": 0.0001941622641509434,
+      "loss": 0.0916,
+      "step": 9850
+    },
+    {
+      "epoch": 22.0,
+      "learning_rate": 0.00019359622641509434,
+      "loss": 0.0878,
+      "step": 9900
+    },
+    {
+      "epoch": 22.11,
+      "learning_rate": 0.00019303018867924526,
+      "loss": 0.0864,
+      "step": 9950
+    },
+    {
+      "epoch": 22.22,
+      "learning_rate": 0.0001924641509433962,
+      "loss": 0.0768,
+      "step": 10000
+    },
+    {
+      "epoch": 22.22,
+      "eval_loss": 0.5633887052536011,
+      "eval_runtime": 233.9063,
+      "eval_samples_per_second": 24.403,
+      "eval_steps_per_second": 3.053,
+      "eval_wer": 0.36429487049056913,
+      "step": 10000
+    },
+    {
+      "epoch": 22.33,
+      "learning_rate": 0.00019189811320754715,
+      "loss": 0.0888,
+      "step": 10050
+    },
+    {
+      "epoch": 22.44,
+      "learning_rate": 0.0001913320754716981,
+      "loss": 0.0876,
+      "step": 10100
+    },
+    {
+      "epoch": 22.56,
+      "learning_rate": 0.00019076603773584904,
+      "loss": 0.0835,
+      "step": 10150
+    },
+    {
+      "epoch": 22.67,
+      "learning_rate": 0.0001902,
+      "loss": 0.0766,
+      "step": 10200
+    },
+    {
+      "epoch": 22.78,
+      "learning_rate": 0.00018963396226415093,
+      "loss": 0.0909,
+      "step": 10250
+    },
+    {
+      "epoch": 22.89,
+      "learning_rate": 0.00018906792452830188,
+      "loss": 0.08,
+      "step": 10300
+    },
+    {
+      "epoch": 23.0,
+      "learning_rate": 0.00018850188679245283,
+      "loss": 0.081,
+      "step": 10350
+    },
+    {
+      "epoch": 23.11,
+      "learning_rate": 0.00018793584905660375,
+      "loss": 0.0744,
+      "step": 10400
+    },
+    {
+      "epoch": 23.11,
+      "eval_loss": 0.5204855799674988,
+      "eval_runtime": 235.6787,
+      "eval_samples_per_second": 24.219,
+      "eval_steps_per_second": 3.03,
+      "eval_wer": 0.3642745233686695,
+      "step": 10400
+    },
+    {
+      "epoch": 23.22,
+      "learning_rate": 0.0001873698113207547,
+      "loss": 0.0817,
+      "step": 10450
+    },
+    {
+      "epoch": 23.33,
+      "learning_rate": 0.00018680377358490564,
+      "loss": 0.0791,
+      "step": 10500
+    },
+    {
+      "epoch": 23.44,
+      "learning_rate": 0.0001862377358490566,
+      "loss": 0.0779,
+      "step": 10550
+    },
+    {
+      "epoch": 23.56,
+      "learning_rate": 0.00018567169811320753,
+      "loss": 0.0818,
+      "step": 10600
+    },
+    {
+      "epoch": 23.67,
+      "learning_rate": 0.00018510566037735848,
+      "loss": 0.0801,
+      "step": 10650
+    },
+    {
+      "epoch": 23.78,
+      "learning_rate": 0.00018453962264150943,
+      "loss": 0.0843,
+      "step": 10700
+    },
+    {
+      "epoch": 23.89,
+      "learning_rate": 0.00018397358490566037,
+      "loss": 0.0832,
+      "step": 10750
+    },
+    {
+      "epoch": 24.0,
+      "learning_rate": 0.00018340754716981132,
+      "loss": 0.0852,
+      "step": 10800
+    },
+    {
+      "epoch": 24.0,
+      "eval_loss": 0.5427780151367188,
+      "eval_runtime": 234.1837,
+      "eval_samples_per_second": 24.374,
+      "eval_steps_per_second": 3.049,
+      "eval_wer": 0.36130384357132683,
+      "step": 10800
+    },
+    {
+      "epoch": 24.11,
+      "learning_rate": 0.00018284150943396224,
+      "loss": 0.0779,
+      "step": 10850
+    },
+    {
+      "epoch": 24.22,
+      "learning_rate": 0.00018227547169811319,
+      "loss": 0.0734,
+      "step": 10900
+    },
+    {
+      "epoch": 24.33,
+      "learning_rate": 0.00018170943396226413,
+      "loss": 0.0843,
+      "step": 10950
+    },
+    {
+      "epoch": 24.44,
+      "learning_rate": 0.00018114339622641508,
+      "loss": 0.0777,
+      "step": 11000
+    },
+    {
+      "epoch": 24.56,
+      "learning_rate": 0.00018057735849056602,
+      "loss": 0.0782,
+      "step": 11050
+    },
+    {
+      "epoch": 24.67,
+      "learning_rate": 0.00018001132075471697,
+      "loss": 0.0783,
+      "step": 11100
+    },
+    {
+      "epoch": 24.78,
+      "learning_rate": 0.00017944528301886792,
+      "loss": 0.076,
+      "step": 11150
+    },
+    {
+      "epoch": 24.89,
+      "learning_rate": 0.00017887924528301886,
+      "loss": 0.0732,
+      "step": 11200
+    },
+    {
+      "epoch": 24.89,
+      "eval_loss": 0.551848292350769,
+      "eval_runtime": 232.8874,
+      "eval_samples_per_second": 24.51,
+      "eval_steps_per_second": 3.066,
+      "eval_wer": 0.3628298777137974,
+      "step": 11200
+    },
+    {
+      "epoch": 25.0,
+      "learning_rate": 0.0001783245283018868,
+      "loss": 0.0861,
+      "step": 11250
+    },
+    {
+      "epoch": 25.11,
+      "learning_rate": 0.0001777698113207547,
+      "loss": 0.0812,
+      "step": 11300
+    },
+    {
+      "epoch": 25.22,
+      "learning_rate": 0.00017720377358490565,
+      "loss": 0.0765,
+      "step": 11350
+    },
+    {
+      "epoch": 25.33,
+      "learning_rate": 0.00017663773584905657,
+      "loss": 0.0775,
+      "step": 11400
+    },
+    {
+      "epoch": 25.44,
+      "learning_rate": 0.00017607169811320752,
+      "loss": 0.0762,
+      "step": 11450
+    },
+    {
+      "epoch": 25.56,
+      "learning_rate": 0.00017550566037735846,
+      "loss": 0.0782,
+      "step": 11500
+    },
+    {
+      "epoch": 25.67,
+      "learning_rate": 0.0001749396226415094,
+      "loss": 0.077,
+      "step": 11550
+    },
+    {
+      "epoch": 25.78,
+      "learning_rate": 0.00017437358490566036,
+      "loss": 0.0725,
+      "step": 11600
+    },
+    {
+      "epoch": 25.78,
+      "eval_loss": 0.5757771134376526,
+      "eval_runtime": 233.1827,
+      "eval_samples_per_second": 24.479,
+      "eval_steps_per_second": 3.062,
+      "eval_wer": 0.37282031456650455,
+      "step": 11600
+    },
+    {
+      "epoch": 25.89,
+      "learning_rate": 0.0001738075471698113,
+      "loss": 0.08,
+      "step": 11650
+    },
+    {
+      "epoch": 26.0,
+      "learning_rate": 0.00017324150943396225,
+      "loss": 0.0743,
+      "step": 11700
+    },
+    {
+      "epoch": 26.11,
+      "learning_rate": 0.0001726754716981132,
+      "loss": 0.0722,
+      "step": 11750
+    },
+    {
+      "epoch": 26.22,
+      "learning_rate": 0.00017210943396226414,
+      "loss": 0.0725,
+      "step": 11800
+    },
+    {
+      "epoch": 26.33,
+      "learning_rate": 0.00017154339622641506,
+      "loss": 0.0708,
+      "step": 11850
+    },
+    {
+      "epoch": 26.44,
+      "learning_rate": 0.000170977358490566,
+      "loss": 0.081,
+      "step": 11900
+    },
+    {
+      "epoch": 26.56,
+      "learning_rate": 0.00017041132075471695,
+      "loss": 0.0704,
+      "step": 11950
+    },
+    {
+      "epoch": 26.67,
+      "learning_rate": 0.0001698452830188679,
+      "loss": 0.0691,
+      "step": 12000
+    },
+    {
+      "epoch": 26.67,
+      "eval_loss": 0.5725019574165344,
+      "eval_runtime": 232.5631,
+      "eval_samples_per_second": 24.544,
+      "eval_steps_per_second": 3.07,
+      "eval_wer": 0.3584552465053818,
+      "step": 12000
+    },
+    {
+      "epoch": 26.78,
+      "learning_rate": 0.00016927924528301885,
+      "loss": 0.0766,
+      "step": 12050
+    },
+    {
+      "epoch": 26.89,
+      "learning_rate": 0.0001687132075471698,
+      "loss": 0.0767,
+      "step": 12100
+    },
+    {
+      "epoch": 27.0,
+      "learning_rate": 0.00016814716981132074,
+      "loss": 0.0748,
+      "step": 12150
+    },
+    {
+      "epoch": 27.11,
+      "learning_rate": 0.0001675811320754717,
+      "loss": 0.0645,
+      "step": 12200
+    },
+    {
+      "epoch": 27.22,
+      "learning_rate": 0.00016701509433962263,
+      "loss": 0.0701,
+      "step": 12250
+    },
+    {
+      "epoch": 27.33,
+      "learning_rate": 0.00016644905660377358,
+      "loss": 0.0702,
+      "step": 12300
+    },
+    {
+      "epoch": 27.44,
+      "learning_rate": 0.0001658830188679245,
+      "loss": 0.0711,
+      "step": 12350
+    },
+    {
+      "epoch": 27.56,
+      "learning_rate": 0.00016531698113207545,
+      "loss": 0.0664,
+      "step": 12400
+    },
+    {
+      "epoch": 27.56,
+      "eval_loss": 0.5794127583503723,
+      "eval_runtime": 233.0106,
+      "eval_samples_per_second": 24.497,
+      "eval_steps_per_second": 3.064,
+      "eval_wer": 0.35994058640405313,
+      "step": 12400
+    },
+    {
+      "epoch": 27.67,
+      "learning_rate": 0.0001647509433962264,
+      "loss": 0.0692,
+      "step": 12450
+    },
+    {
+      "epoch": 27.78,
+      "learning_rate": 0.00016418490566037734,
+      "loss": 0.0705,
+      "step": 12500
+    },
+    {
+      "epoch": 27.89,
+      "learning_rate": 0.00016361886792452829,
+      "loss": 0.0705,
+      "step": 12550
+    },
+    {
+      "epoch": 28.0,
+      "learning_rate": 0.00016305283018867923,
+      "loss": 0.0655,
+      "step": 12600
+    },
+    {
+      "epoch": 28.11,
+      "learning_rate": 0.00016248679245283018,
+      "loss": 0.0723,
+      "step": 12650
+    },
+    {
+      "epoch": 28.22,
+      "learning_rate": 0.00016192075471698113,
+      "loss": 0.0716,
+      "step": 12700
+    },
+    {
+      "epoch": 28.33,
+      "learning_rate": 0.00016135471698113207,
+      "loss": 0.0709,
+      "step": 12750
+    },
+    {
+      "epoch": 28.44,
+      "learning_rate": 0.000160788679245283,
+      "loss": 0.0663,
+      "step": 12800
+    },
+    {
+      "epoch": 28.44,
+      "eval_loss": 0.5777014493942261,
+      "eval_runtime": 235.2144,
+      "eval_samples_per_second": 24.267,
+      "eval_steps_per_second": 3.036,
+      "eval_wer": 0.35607463324312777,
+      "step": 12800
+    },
+    {
+      "epoch": 28.56,
+      "learning_rate": 0.00016022264150943394,
+      "loss": 0.0687,
+      "step": 12850
+    },
+    {
+      "epoch": 28.67,
+      "learning_rate": 0.00015965660377358488,
+      "loss": 0.0736,
+      "step": 12900
+    },
+    {
+      "epoch": 28.78,
+      "learning_rate": 0.00015909056603773583,
+      "loss": 0.0675,
+      "step": 12950
+    },
+    {
+      "epoch": 28.89,
+      "learning_rate": 0.00015852452830188678,
+      "loss": 0.0695,
+      "step": 13000
+    },
+    {
+      "epoch": 29.0,
+      "learning_rate": 0.00015795849056603772,
+      "loss": 0.0719,
+      "step": 13050
+    },
+    {
+      "epoch": 29.11,
+      "learning_rate": 0.00015739245283018867,
+      "loss": 0.0675,
+      "step": 13100
+    },
+    {
+      "epoch": 29.22,
+      "learning_rate": 0.00015682641509433962,
+      "loss": 0.0692,
+      "step": 13150
+    },
+    {
+      "epoch": 29.33,
+      "learning_rate": 0.00015626037735849056,
+      "loss": 0.0671,
+      "step": 13200
+    },
+    {
+      "epoch": 29.33,
+      "eval_loss": 0.573063850402832,
+      "eval_runtime": 235.4966,
+      "eval_samples_per_second": 24.238,
+      "eval_steps_per_second": 3.032,
+      "eval_wer": 0.35485380592915133,
+      "step": 13200
+    },
+    {
+      "epoch": 29.44,
+      "learning_rate": 0.00015569433962264148,
+      "loss": 0.0648,
+      "step": 13250
+    },
+    {
+      "epoch": 29.56,
+      "learning_rate": 0.00015512830188679243,
+      "loss": 0.0768,
+      "step": 13300
+    },
+    {
+      "epoch": 29.67,
+      "learning_rate": 0.00015456226415094338,
+      "loss": 0.0627,
+      "step": 13350
+    },
+    {
+      "epoch": 29.78,
+      "learning_rate": 0.00015399622641509432,
+      "loss": 0.0657,
+      "step": 13400
+    },
+    {
+      "epoch": 29.89,
+      "learning_rate": 0.00015343018867924527,
+      "loss": 0.0698,
+      "step": 13450
+    },
+    {
+      "epoch": 30.0,
+      "learning_rate": 0.00015286415094339622,
+      "loss": 0.0683,
+      "step": 13500
+    },
+    {
+      "epoch": 30.11,
+      "learning_rate": 0.00015229811320754716,
+      "loss": 0.0616,
+      "step": 13550
+    },
+    {
+      "epoch": 30.22,
+      "learning_rate": 0.0001517320754716981,
+      "loss": 0.0649,
+      "step": 13600
+    },
+    {
+      "epoch": 30.22,
+      "eval_loss": 0.5660180449485779,
+      "eval_runtime": 233.6416,
+      "eval_samples_per_second": 24.431,
+      "eval_steps_per_second": 3.056,
+      "eval_wer": 0.3600423220135512,
+      "step": 13600
+    },
+    {
+      "epoch": 30.33,
+      "learning_rate": 0.00015116603773584905,
+      "loss": 0.0674,
+      "step": 13650
+    },
+    {
+      "epoch": 30.44,
+      "learning_rate": 0.00015059999999999997,
+      "loss": 0.0645,
+      "step": 13700
+    },
+    {
+      "epoch": 30.56,
+      "learning_rate": 0.00015003396226415092,
+      "loss": 0.0643,
+      "step": 13750
+    },
+    {
+      "epoch": 30.67,
+      "learning_rate": 0.00014946792452830187,
+      "loss": 0.0631,
+      "step": 13800
+    },
+    {
+      "epoch": 30.78,
+      "learning_rate": 0.00014890188679245281,
+      "loss": 0.064,
+      "step": 13850
+    },
+    {
+      "epoch": 30.89,
+      "learning_rate": 0.00014833584905660376,
+      "loss": 0.0666,
+      "step": 13900
+    },
+    {
+      "epoch": 31.0,
+      "learning_rate": 0.0001477698113207547,
+      "loss": 0.0656,
+      "step": 13950
+    },
+    {
+      "epoch": 31.11,
+      "learning_rate": 0.00014720377358490565,
+      "loss": 0.0614,
+      "step": 14000
+    },
+    {
+      "epoch": 31.11,
+      "eval_loss": 0.5769771933555603,
+      "eval_runtime": 234.4224,
+      "eval_samples_per_second": 24.349,
+      "eval_steps_per_second": 3.046,
+      "eval_wer": 0.35595255051173014,
+      "step": 14000
+    },
+    {
+      "epoch": 31.22,
+      "learning_rate": 0.0001466377358490566,
+      "loss": 0.0609,
+      "step": 14050
+    },
+    {
+      "epoch": 31.33,
+      "learning_rate": 0.00014607169811320755,
+      "loss": 0.0615,
+      "step": 14100
+    },
+    {
+      "epoch": 31.44,
+      "learning_rate": 0.0001455056603773585,
+      "loss": 0.0595,
+      "step": 14150
+    },
+    {
+      "epoch": 31.56,
+      "learning_rate": 0.0001449396226415094,
+      "loss": 0.0535,
+      "step": 14200
+    },
+    {
+      "epoch": 31.67,
+      "learning_rate": 0.00014437358490566036,
+      "loss": 0.0662,
+      "step": 14250
+    },
+    {
+      "epoch": 31.78,
+      "learning_rate": 0.0001438075471698113,
+      "loss": 0.0636,
+      "step": 14300
+    },
+    {
+      "epoch": 31.89,
+      "learning_rate": 0.00014324150943396225,
+      "loss": 0.065,
+      "step": 14350
+    },
+    {
+      "epoch": 32.0,
+      "learning_rate": 0.0001426754716981132,
+      "loss": 0.0605,
+      "step": 14400
+    },
+    {
+      "epoch": 32.0,
+      "eval_loss": 0.5667794942855835,
+      "eval_runtime": 236.4511,
+      "eval_samples_per_second": 24.14,
+      "eval_steps_per_second": 3.02,
+      "eval_wer": 0.35633914582782267,
+      "step": 14400
+    },
+    {
+      "epoch": 32.11,
+      "learning_rate": 0.00014210943396226414,
+      "loss": 0.0576,
+      "step": 14450
+    },
+    {
+      "epoch": 32.22,
+      "learning_rate": 0.0001415433962264151,
+      "loss": 0.0576,
+      "step": 14500
+    },
+    {
+      "epoch": 32.33,
+      "learning_rate": 0.00014097735849056604,
+      "loss": 0.0567,
+      "step": 14550
+    },
+    {
+      "epoch": 32.44,
+      "learning_rate": 0.00014041132075471698,
+      "loss": 0.0638,
+      "step": 14600
+    },
+    {
+      "epoch": 32.56,
+      "learning_rate": 0.0001398452830188679,
+      "loss": 0.0563,
+      "step": 14650
+    },
+    {
+      "epoch": 32.67,
+      "learning_rate": 0.00013927924528301885,
+      "loss": 0.0606,
+      "step": 14700
+    },
+    {
+      "epoch": 32.78,
+      "learning_rate": 0.0001387132075471698,
+      "loss": 0.066,
+      "step": 14750
+    },
+    {
+      "epoch": 32.89,
+      "learning_rate": 0.00013814716981132074,
+      "loss": 0.0594,
+      "step": 14800
+    },
+    {
+      "epoch": 32.89,
+      "eval_loss": 0.5590910911560059,
+      "eval_runtime": 236.6548,
+      "eval_samples_per_second": 24.12,
+      "eval_steps_per_second": 3.017,
+      "eval_wer": 0.3464707917065131,
+      "step": 14800
+    },
+    {
+      "epoch": 33.0,
+      "learning_rate": 0.0001375811320754717,
+      "loss": 0.0567,
+      "step": 14850
+    },
+    {
+      "epoch": 33.11,
+      "learning_rate": 0.00013701509433962264,
+      "loss": 0.0593,
+      "step": 14900
+    },
+    {
+      "epoch": 33.22,
+      "learning_rate": 0.00013644905660377358,
+      "loss": 0.0503,
+      "step": 14950
+    },
+    {
+      "epoch": 33.33,
+      "learning_rate": 0.00013588301886792453,
+      "loss": 0.0548,
+      "step": 15000
+    },
+    {
+      "epoch": 33.44,
+      "learning_rate": 0.00013531698113207548,
+      "loss": 0.058,
+      "step": 15050
+    },
+    {
+      "epoch": 33.56,
+      "learning_rate": 0.0001347509433962264,
+      "loss": 0.0593,
+      "step": 15100
+    },
+    {
+      "epoch": 33.67,
+      "learning_rate": 0.00013418490566037734,
+      "loss": 0.0576,
+      "step": 15150
+    },
+    {
+      "epoch": 33.78,
+      "learning_rate": 0.0001336188679245283,
+      "loss": 0.0622,
+      "step": 15200
+    },
+    {
+      "epoch": 33.78,
+      "eval_loss": 0.6206709742546082,
+      "eval_runtime": 237.9375,
+      "eval_samples_per_second": 23.989,
+      "eval_steps_per_second": 3.001,
+      "eval_wer": 0.35127271247482045,
+      "step": 15200
+    },
+    {
+      "epoch": 33.89,
+      "learning_rate": 0.00013305283018867923,
+      "loss": 0.0554,
+      "step": 15250
+    },
+    {
+      "epoch": 34.0,
+      "learning_rate": 0.00013248679245283018,
+      "loss": 0.0536,
+      "step": 15300
+    },
+    {
+      "epoch": 34.11,
+      "learning_rate": 0.00013192075471698113,
+      "loss": 0.0585,
+      "step": 15350
+    },
+    {
+      "epoch": 34.22,
+      "learning_rate": 0.00013135471698113207,
+      "loss": 0.0604,
+      "step": 15400
+    },
+    {
+      "epoch": 34.33,
+      "learning_rate": 0.00013078867924528302,
+      "loss": 0.0586,
+      "step": 15450
+    },
+    {
+      "epoch": 34.44,
+      "learning_rate": 0.00013023396226415093,
+      "loss": 0.0648,
+      "step": 15500
+    },
+    {
+      "epoch": 34.56,
+      "learning_rate": 0.00012966792452830187,
+      "loss": 0.0534,
+      "step": 15550
+    },
+    {
+      "epoch": 34.67,
+      "learning_rate": 0.00012910188679245282,
+      "loss": 0.0597,
+      "step": 15600
+    },
+    {
+      "epoch": 34.67,
+      "eval_loss": 0.545280933380127,
+      "eval_runtime": 234.5113,
+      "eval_samples_per_second": 24.34,
+      "eval_steps_per_second": 3.045,
+      "eval_wer": 0.35078438154922986,
+      "step": 15600
+    },
+    {
+      "epoch": 34.78,
+      "learning_rate": 0.00012853584905660377,
+      "loss": 0.058,
+      "step": 15650
+    },
+    {
+      "epoch": 34.89,
+      "learning_rate": 0.0001279698113207547,
+      "loss": 0.0557,
+      "step": 15700
+    },
+    {
+      "epoch": 35.0,
+      "learning_rate": 0.00012740377358490566,
+      "loss": 0.0557,
+      "step": 15750
+    },
+    {
+      "epoch": 35.11,
+      "learning_rate": 0.0001268377358490566,
+      "loss": 0.0529,
+      "step": 15800
+    },
+    {
+      "epoch": 35.22,
+      "learning_rate": 0.00012627169811320753,
+      "loss": 0.0544,
+      "step": 15850
+    },
+    {
+      "epoch": 35.33,
+      "learning_rate": 0.00012570566037735847,
+      "loss": 0.0538,
+      "step": 15900
+    },
+    {
+      "epoch": 35.44,
+      "learning_rate": 0.00012513962264150942,
+      "loss": 0.0517,
+      "step": 15950
+    },
+    {
+      "epoch": 35.56,
+      "learning_rate": 0.00012457358490566037,
+      "loss": 0.0566,
+      "step": 16000
+    },
+    {
+      "epoch": 35.56,
+      "eval_loss": 0.6024277210235596,
+      "eval_runtime": 233.9908,
+      "eval_samples_per_second": 24.394,
+      "eval_steps_per_second": 3.051,
+      "eval_wer": 0.3531649948114839,
+      "step": 16000
+    },
+    {
+      "epoch": 35.67,
+      "learning_rate": 0.0001240075471698113,
+      "loss": 0.051,
+      "step": 16050
+    },
+    {
+      "epoch": 35.78,
+      "learning_rate": 0.00012344150943396226,
+      "loss": 0.0591,
+      "step": 16100
+    },
+    {
+      "epoch": 35.89,
+      "learning_rate": 0.0001228754716981132,
+      "loss": 0.0569,
+      "step": 16150
+    },
+    {
+      "epoch": 36.0,
+      "learning_rate": 0.00012230943396226415,
+      "loss": 0.0563,
+      "step": 16200
+    },
+    {
+      "epoch": 36.11,
+      "learning_rate": 0.00012174339622641508,
+      "loss": 0.0533,
+      "step": 16250
+    },
+    {
+      "epoch": 36.22,
+      "learning_rate": 0.00012117735849056603,
+      "loss": 0.0566,
+      "step": 16300
+    },
+    {
+      "epoch": 36.33,
+      "learning_rate": 0.00012061132075471698,
+      "loss": 0.0556,
+      "step": 16350
+    },
+    {
+      "epoch": 36.44,
+      "learning_rate": 0.00012004528301886791,
+      "loss": 0.0524,
+      "step": 16400
+    },
+    {
+      "epoch": 36.44,
+      "eval_loss": 0.6054043173789978,
+      "eval_runtime": 232.789,
+      "eval_samples_per_second": 24.52,
+      "eval_steps_per_second": 3.067,
+      "eval_wer": 0.3538161027122714,
+      "step": 16400
+    },
+    {
+      "epoch": 36.56,
+      "learning_rate": 0.00011947924528301886,
+      "loss": 0.0568,
+      "step": 16450
+    },
+    {
+      "epoch": 36.67,
+      "learning_rate": 0.0001189132075471698,
+      "loss": 0.0554,
+      "step": 16500
+    },
+    {
+      "epoch": 36.78,
+      "learning_rate": 0.00011834716981132075,
+      "loss": 0.0499,
+      "step": 16550
+    },
+    {
+      "epoch": 36.89,
+      "learning_rate": 0.0001177811320754717,
+      "loss": 0.0518,
+      "step": 16600
+    },
+    {
+      "epoch": 37.0,
+      "learning_rate": 0.00011721509433962263,
+      "loss": 0.0571,
+      "step": 16650
+    },
+    {
+      "epoch": 37.11,
+      "learning_rate": 0.00011664905660377358,
+      "loss": 0.0542,
+      "step": 16700
+    },
+    {
+      "epoch": 37.22,
+      "learning_rate": 0.00011608301886792452,
+      "loss": 0.0502,
+      "step": 16750
+    },
+    {
+      "epoch": 37.33,
+      "learning_rate": 0.00011551698113207547,
+      "loss": 0.045,
+      "step": 16800
+    },
+    {
+      "epoch": 37.33,
+      "eval_loss": 0.6067692041397095,
+      "eval_runtime": 233.7086,
+      "eval_samples_per_second": 24.424,
+      "eval_steps_per_second": 3.055,
+      "eval_wer": 0.3464097503408143,
+      "step": 16800
+    },
+    {
+      "epoch": 37.44,
+      "learning_rate": 0.0001149509433962264,
+      "loss": 0.0536,
+      "step": 16850
+    },
+    {
+      "epoch": 37.56,
+      "learning_rate": 0.00011438490566037735,
+      "loss": 0.0513,
+      "step": 16900
+    },
+    {
+      "epoch": 37.67,
+      "learning_rate": 0.0001138188679245283,
+      "loss": 0.0513,
+      "step": 16950
+    },
+    {
+      "epoch": 37.78,
+      "learning_rate": 0.00011325283018867924,
+      "loss": 0.0546,
+      "step": 17000
+    },
+    {
+      "epoch": 37.89,
+      "learning_rate": 0.00011268679245283019,
+      "loss": 0.0552,
+      "step": 17050
+    },
+    {
+      "epoch": 38.0,
+      "learning_rate": 0.00011212075471698112,
+      "loss": 0.0511,
+      "step": 17100
+    },
+    {
+      "epoch": 38.11,
+      "learning_rate": 0.00011155471698113207,
+      "loss": 0.0517,
+      "step": 17150
+    },
+    {
+      "epoch": 38.22,
+      "learning_rate": 0.00011098867924528301,
+      "loss": 0.0526,
+      "step": 17200
+    },
+    {
+      "epoch": 38.22,
+      "eval_loss": 0.5827322602272034,
+      "eval_runtime": 234.6281,
+      "eval_samples_per_second": 24.328,
+      "eval_steps_per_second": 3.043,
+      "eval_wer": 0.34946181862575537,
+      "step": 17200
+    },
+    {
+      "epoch": 38.33,
+      "learning_rate": 0.00011042264150943396,
+      "loss": 0.0452,
+      "step": 17250
+    },
+    {
+      "epoch": 38.44,
+      "learning_rate": 0.0001098566037735849,
+      "loss": 0.0471,
+      "step": 17300
+    },
+    {
+      "epoch": 38.56,
+      "learning_rate": 0.00010929056603773584,
+      "loss": 0.049,
+      "step": 17350
+    },
+    {
+      "epoch": 38.67,
+      "learning_rate": 0.00010873584905660376,
+      "loss": 0.0551,
+      "step": 17400
+    },
+    {
+      "epoch": 38.78,
+      "learning_rate": 0.0001081698113207547,
+      "loss": 0.0522,
+      "step": 17450
+    },
+    {
+      "epoch": 38.89,
+      "learning_rate": 0.00010760377358490565,
+      "loss": 0.0504,
+      "step": 17500
+    },
+    {
+      "epoch": 39.0,
+      "learning_rate": 0.0001070377358490566,
+      "loss": 0.0474,
+      "step": 17550
+    },
+    {
+      "epoch": 39.11,
+      "learning_rate": 0.00010647169811320753,
+      "loss": 0.0437,
+      "step": 17600
+    },
+    {
+      "epoch": 39.11,
+      "eval_loss": 0.6006141901016235,
+      "eval_runtime": 234.8995,
+      "eval_samples_per_second": 24.3,
+      "eval_steps_per_second": 3.04,
+      "eval_wer": 0.33963415874824504,
+      "step": 17600
+    },
+    {
+      "epoch": 39.22,
+      "learning_rate": 0.00010590566037735848,
+      "loss": 0.0444,
+      "step": 17650
+    },
+    {
+      "epoch": 39.33,
+      "learning_rate": 0.00010533962264150943,
+      "loss": 0.0496,
+      "step": 17700
+    },
+    {
+      "epoch": 39.44,
+      "learning_rate": 0.00010477358490566037,
+      "loss": 0.0514,
+      "step": 17750
+    },
+    {
+      "epoch": 39.56,
+      "learning_rate": 0.0001042075471698113,
+      "loss": 0.0506,
+      "step": 17800
+    },
+    {
+      "epoch": 39.67,
+      "learning_rate": 0.00010364150943396225,
+      "loss": 0.0494,
+      "step": 17850
+    },
+    {
+      "epoch": 39.78,
+      "learning_rate": 0.0001030754716981132,
+      "loss": 0.046,
+      "step": 17900
+    },
+    {
+      "epoch": 39.89,
+      "learning_rate": 0.00010250943396226414,
+      "loss": 0.0515,
+      "step": 17950
+    },
+    {
+      "epoch": 40.0,
+      "learning_rate": 0.00010194339622641509,
+      "loss": 0.0498,
+      "step": 18000
+    },
+    {
+      "epoch": 40.0,
+      "eval_loss": 0.546351969242096,
+      "eval_runtime": 234.7053,
+      "eval_samples_per_second": 24.32,
+      "eval_steps_per_second": 3.042,
+      "eval_wer": 0.3422996317170936,
+      "step": 18000
+    },
+    {
+      "epoch": 40.11,
+      "learning_rate": 0.00010137735849056602,
+      "loss": 0.0514,
+      "step": 18050
+    },
+    {
+      "epoch": 40.22,
+      "learning_rate": 0.00010081132075471697,
+      "loss": 0.0454,
+      "step": 18100
+    },
+    {
+      "epoch": 40.33,
+      "learning_rate": 0.00010024528301886792,
+      "loss": 0.044,
+      "step": 18150
+    },
+    {
+      "epoch": 40.44,
+      "learning_rate": 9.967924528301886e-05,
+      "loss": 0.047,
+      "step": 18200
+    },
+    {
+      "epoch": 40.56,
+      "learning_rate": 9.911320754716981e-05,
+      "loss": 0.0412,
+      "step": 18250
+    },
+    {
+      "epoch": 40.67,
+      "learning_rate": 9.854716981132074e-05,
+      "loss": 0.0484,
+      "step": 18300
+    },
+    {
+      "epoch": 40.78,
+      "learning_rate": 9.798113207547169e-05,
+      "loss": 0.0413,
+      "step": 18350
+    },
+    {
+      "epoch": 40.89,
+      "learning_rate": 9.741509433962264e-05,
+      "loss": 0.0494,
+      "step": 18400
+    },
+    {
+      "epoch": 40.89,
+      "eval_loss": 0.6018606424331665,
+      "eval_runtime": 234.1001,
+      "eval_samples_per_second": 24.383,
+      "eval_steps_per_second": 3.05,
+      "eval_wer": 0.3394713817730482,
+      "step": 18400
+    },
+    {
+      "epoch": 41.0,
+      "learning_rate": 9.684905660377358e-05,
+      "loss": 0.0462,
+      "step": 18450
+    },
+    {
+      "epoch": 41.11,
+      "learning_rate": 9.628301886792452e-05,
+      "loss": 0.0404,
+      "step": 18500
+    },
+    {
+      "epoch": 41.22,
+      "learning_rate": 9.571698113207546e-05,
+      "loss": 0.0452,
+      "step": 18550
+    },
+    {
+      "epoch": 41.33,
+      "learning_rate": 9.515094339622641e-05,
+      "loss": 0.042,
+      "step": 18600
+    },
+    {
+      "epoch": 41.44,
+      "learning_rate": 9.458490566037736e-05,
+      "loss": 0.0449,
+      "step": 18650
+    },
+    {
+      "epoch": 41.56,
+      "learning_rate": 9.40188679245283e-05,
+      "loss": 0.0431,
+      "step": 18700
+    },
+    {
+      "epoch": 41.67,
+      "learning_rate": 9.345283018867923e-05,
+      "loss": 0.0407,
+      "step": 18750
+    },
+    {
+      "epoch": 41.78,
+      "learning_rate": 9.288679245283018e-05,
+      "loss": 0.0476,
+      "step": 18800
+    },
+    {
+      "epoch": 41.78,
+      "eval_loss": 0.5934082865715027,
+      "eval_runtime": 234.8837,
+      "eval_samples_per_second": 24.301,
+      "eval_steps_per_second": 3.04,
+      "eval_wer": 0.3392068691883533,
+      "step": 18800
+    },
+    {
+      "epoch": 41.89,
+      "learning_rate": 9.232075471698113e-05,
+      "loss": 0.0475,
+      "step": 18850
+    },
+    {
+      "epoch": 42.0,
+      "learning_rate": 9.175471698113207e-05,
+      "loss": 0.0422,
+      "step": 18900
+    },
+    {
+      "epoch": 42.11,
+      "learning_rate": 9.118867924528302e-05,
+      "loss": 0.0424,
+      "step": 18950
+    },
+    {
+      "epoch": 42.22,
+      "learning_rate": 9.062264150943395e-05,
+      "loss": 0.0446,
+      "step": 19000
+    },
+    {
+      "epoch": 42.33,
+      "learning_rate": 9.00566037735849e-05,
+      "loss": 0.0435,
+      "step": 19050
+    },
+    {
+      "epoch": 42.44,
+      "learning_rate": 8.949056603773585e-05,
+      "loss": 0.0423,
+      "step": 19100
+    },
+    {
+      "epoch": 42.56,
+      "learning_rate": 8.892452830188679e-05,
+      "loss": 0.0403,
+      "step": 19150
+    },
+    {
+      "epoch": 42.67,
+      "learning_rate": 8.835849056603773e-05,
+      "loss": 0.0414,
+      "step": 19200
+    },
+    {
+      "epoch": 42.67,
+      "eval_loss": 0.6187946796417236,
+      "eval_runtime": 235.2867,
+      "eval_samples_per_second": 24.26,
+      "eval_steps_per_second": 3.035,
+      "eval_wer": 0.3374366695830875,
+      "step": 19200
+    },
+    {
+      "epoch": 42.78,
+      "learning_rate": 8.779245283018867e-05,
+      "loss": 0.0444,
+      "step": 19250
+    },
+    {
+      "epoch": 42.89,
+      "learning_rate": 8.722641509433962e-05,
+      "loss": 0.0476,
+      "step": 19300
+    },
+    {
+      "epoch": 43.0,
+      "learning_rate": 8.666037735849057e-05,
+      "loss": 0.0426,
+      "step": 19350
+    },
+    {
+      "epoch": 43.11,
+      "learning_rate": 8.609433962264151e-05,
+      "loss": 0.04,
+      "step": 19400
+    },
+    {
+      "epoch": 43.22,
+      "learning_rate": 8.552830188679245e-05,
+      "loss": 0.0452,
+      "step": 19450
+    },
+    {
+      "epoch": 43.33,
+      "learning_rate": 8.496226415094339e-05,
+      "loss": 0.0396,
+      "step": 19500
+    },
+    {
+      "epoch": 43.44,
+      "learning_rate": 8.439622641509434e-05,
+      "loss": 0.0404,
+      "step": 19550
+    },
+    {
+      "epoch": 43.56,
+      "learning_rate": 8.383018867924528e-05,
+      "loss": 0.0382,
+      "step": 19600
+    },
+    {
+      "epoch": 43.56,
+      "eval_loss": 0.6085843443870544,
+      "eval_runtime": 233.4151,
+      "eval_samples_per_second": 24.454,
+      "eval_steps_per_second": 3.059,
+      "eval_wer": 0.33273648442427817,
+      "step": 19600
+    },
+    {
+      "epoch": 43.67,
+      "learning_rate": 8.326415094339622e-05,
+      "loss": 0.0408,
+      "step": 19650
+    },
+    {
+      "epoch": 43.78,
+      "learning_rate": 8.269811320754716e-05,
+      "loss": 0.0443,
+      "step": 19700
+    },
+    {
+      "epoch": 43.89,
+      "learning_rate": 8.213207547169811e-05,
+      "loss": 0.0464,
+      "step": 19750
+    },
+    {
+      "epoch": 44.0,
+      "learning_rate": 8.156603773584906e-05,
+      "loss": 0.0383,
+      "step": 19800
+    },
+    {
+      "epoch": 44.11,
+      "learning_rate": 8.1e-05,
+      "loss": 0.0447,
+      "step": 19850
+    },
+    {
+      "epoch": 44.22,
+      "learning_rate": 8.043396226415094e-05,
+      "loss": 0.0419,
+      "step": 19900
+    },
+    {
+      "epoch": 44.33,
+      "learning_rate": 7.986792452830188e-05,
+      "loss": 0.0389,
+      "step": 19950
+    },
+    {
+      "epoch": 44.44,
+      "learning_rate": 7.930188679245283e-05,
+      "loss": 0.0403,
+      "step": 20000
+    },
+    {
+      "epoch": 44.44,
+      "eval_loss": 0.6319227814674377,
+      "eval_runtime": 233.7986,
+      "eval_samples_per_second": 24.414,
+      "eval_steps_per_second": 3.054,
+      "eval_wer": 0.3353002217836287,
+      "step": 20000
+    },
+    {
+      "epoch": 44.56,
+      "learning_rate": 7.873584905660378e-05,
+      "loss": 0.0397,
+      "step": 20050
+    },
+    {
+      "epoch": 44.67,
+      "learning_rate": 7.816981132075472e-05,
+      "loss": 0.0406,
+      "step": 20100
+    },
+    {
+      "epoch": 44.78,
+      "learning_rate": 7.760377358490566e-05,
+      "loss": 0.039,
+      "step": 20150
+    },
+    {
+      "epoch": 44.89,
+      "learning_rate": 7.70377358490566e-05,
+      "loss": 0.0388,
+      "step": 20200
+    },
+    {
+      "epoch": 45.0,
+      "learning_rate": 7.647169811320755e-05,
+      "loss": 0.0391,
+      "step": 20250
+    },
+    {
+      "epoch": 45.11,
+      "learning_rate": 7.59056603773585e-05,
+      "loss": 0.0343,
+      "step": 20300
+    },
+    {
+      "epoch": 45.22,
+      "learning_rate": 7.533962264150943e-05,
+      "loss": 0.0381,
+      "step": 20350
+    },
+    {
+      "epoch": 45.33,
+      "learning_rate": 7.477358490566037e-05,
+      "loss": 0.0391,
+      "step": 20400
+    },
+    {
+      "epoch": 45.33,
+      "eval_loss": 0.6092292666435242,
+      "eval_runtime": 234.709,
+      "eval_samples_per_second": 24.319,
+      "eval_steps_per_second": 3.042,
+      "eval_wer": 0.337253545485991,
+      "step": 20400
+    },
+    {
+      "epoch": 45.44,
+      "learning_rate": 7.420754716981131e-05,
+      "loss": 0.0404,
+      "step": 20450
+    },
+    {
+      "epoch": 45.56,
+      "learning_rate": 7.364150943396225e-05,
+      "loss": 0.0441,
+      "step": 20500
+    },
+    {
+      "epoch": 45.67,
+      "learning_rate": 7.30754716981132e-05,
+      "loss": 0.0374,
+      "step": 20550
+    },
+    {
+      "epoch": 45.78,
+      "learning_rate": 7.250943396226415e-05,
+      "loss": 0.0379,
+      "step": 20600
+    },
+    {
+      "epoch": 45.89,
+      "learning_rate": 7.19433962264151e-05,
+      "loss": 0.04,
+      "step": 20650
+    },
+    {
+      "epoch": 46.0,
+      "learning_rate": 7.137735849056603e-05,
+      "loss": 0.041,
+      "step": 20700
+    },
+    {
+      "epoch": 46.11,
+      "learning_rate": 7.081132075471697e-05,
+      "loss": 0.0367,
+      "step": 20750
+    },
+    {
+      "epoch": 46.22,
+      "learning_rate": 7.024528301886792e-05,
+      "loss": 0.0364,
+      "step": 20800
+    },
+    {
+      "epoch": 46.22,
+      "eval_loss": 0.6104596257209778,
+      "eval_runtime": 238.3111,
+      "eval_samples_per_second": 23.952,
+      "eval_steps_per_second": 2.996,
+      "eval_wer": 0.33383522900685697,
+      "step": 20800
+    },
+    {
+      "epoch": 46.33,
+      "learning_rate": 6.967924528301887e-05,
+      "loss": 0.0379,
+      "step": 20850
+    },
+    {
+      "epoch": 46.44,
+      "learning_rate": 6.91132075471698e-05,
+      "loss": 0.0392,
+      "step": 20900
+    },
+    {
+      "epoch": 46.56,
+      "learning_rate": 6.854716981132075e-05,
+      "loss": 0.0402,
+      "step": 20950
+    },
+    {
+      "epoch": 46.67,
+      "learning_rate": 6.798113207547169e-05,
+      "loss": 0.042,
+      "step": 21000
+    },
+    {
+      "epoch": 46.78,
+      "learning_rate": 6.741509433962264e-05,
+      "loss": 0.0366,
+      "step": 21050
+    },
+    {
+      "epoch": 46.89,
+      "learning_rate": 6.684905660377359e-05,
+      "loss": 0.0377,
+      "step": 21100
+    },
+    {
+      "epoch": 47.0,
+      "learning_rate": 6.628301886792452e-05,
+      "loss": 0.0345,
+      "step": 21150
+    },
+    {
+      "epoch": 47.11,
+      "learning_rate": 6.571698113207546e-05,
+      "loss": 0.0408,
+      "step": 21200
+    },
+    {
+      "epoch": 47.11,
+      "eval_loss": 0.6161568760871887,
+      "eval_runtime": 235.8491,
+      "eval_samples_per_second": 24.202,
+      "eval_steps_per_second": 3.027,
+      "eval_wer": 0.3335910635440617,
+      "step": 21200
+    },
+    {
+      "epoch": 47.22,
+      "learning_rate": 6.515094339622641e-05,
+      "loss": 0.0377,
+      "step": 21250
+    },
+    {
+      "epoch": 47.33,
+      "learning_rate": 6.459622641509433e-05,
+      "loss": 0.0387,
+      "step": 21300
+    },
+    {
+      "epoch": 47.44,
+      "learning_rate": 6.403018867924528e-05,
+      "loss": 0.0349,
+      "step": 21350
+    },
+    {
+      "epoch": 47.56,
+      "learning_rate": 6.346415094339622e-05,
+      "loss": 0.0398,
+      "step": 21400
+    },
+    {
+      "epoch": 47.67,
+      "learning_rate": 6.289811320754717e-05,
+      "loss": 0.036,
+      "step": 21450
+    },
+    {
+      "epoch": 47.78,
+      "learning_rate": 6.233207547169812e-05,
+      "loss": 0.0359,
+      "step": 21500
+    },
+    {
+      "epoch": 47.89,
+      "learning_rate": 6.176603773584905e-05,
+      "loss": 0.0363,
+      "step": 21550
+    },
+    {
+      "epoch": 48.0,
+      "learning_rate": 6.12e-05,
+      "loss": 0.0347,
+      "step": 21600
+    },
+    {
+      "epoch": 48.0,
+      "eval_loss": 0.5747588276863098,
+      "eval_runtime": 234.422,
+      "eval_samples_per_second": 24.349,
+      "eval_steps_per_second": 3.046,
+      "eval_wer": 0.32937920931084297,
+      "step": 21600
+    },
+    {
+      "epoch": 48.11,
+      "learning_rate": 6.0633962264150937e-05,
+      "loss": 0.0357,
+      "step": 21650
+    },
+    {
+      "epoch": 48.22,
+      "learning_rate": 6.0067924528301876e-05,
+      "loss": 0.036,
+      "step": 21700
+    },
+    {
+      "epoch": 48.33,
+      "learning_rate": 5.950188679245282e-05,
+      "loss": 0.0362,
+      "step": 21750
+    },
+    {
+      "epoch": 48.44,
+      "learning_rate": 5.893584905660376e-05,
+      "loss": 0.0313,
+      "step": 21800
+    },
+    {
+      "epoch": 48.56,
+      "learning_rate": 5.836981132075471e-05,
+      "loss": 0.0365,
+      "step": 21850
+    },
+    {
+      "epoch": 48.67,
+      "learning_rate": 5.780377358490565e-05,
+      "loss": 0.0326,
+      "step": 21900
+    },
+    {
+      "epoch": 48.78,
+      "learning_rate": 5.7237735849056595e-05,
+      "loss": 0.0339,
+      "step": 21950
+    },
+    {
+      "epoch": 48.89,
+      "learning_rate": 5.667169811320754e-05,
+      "loss": 0.0372,
+      "step": 22000
+    },
+    {
+      "epoch": 48.89,
+      "eval_loss": 0.5893652439117432,
+      "eval_runtime": 233.9923,
+      "eval_samples_per_second": 24.394,
+      "eval_steps_per_second": 3.051,
+      "eval_wer": 0.3295826805298391,
+      "step": 22000
+    },
+    {
+      "epoch": 49.0,
+      "learning_rate": 5.610566037735848e-05,
+      "loss": 0.0346,
+      "step": 22050
+    },
+    {
+      "epoch": 49.11,
+      "learning_rate": 5.553962264150943e-05,
+      "loss": 0.0356,
+      "step": 22100
+    },
+    {
+      "epoch": 49.22,
+      "learning_rate": 5.497358490566037e-05,
+      "loss": 0.0371,
+      "step": 22150
+    },
+    {
+      "epoch": 49.33,
+      "learning_rate": 5.4407547169811314e-05,
+      "loss": 0.0342,
+      "step": 22200
+    },
+    {
+      "epoch": 49.44,
+      "learning_rate": 5.3841509433962254e-05,
+      "loss": 0.0323,
+      "step": 22250
+    },
+    {
+      "epoch": 49.56,
+      "learning_rate": 5.32754716981132e-05,
+      "loss": 0.0326,
+      "step": 22300
+    },
+    {
+      "epoch": 49.67,
+      "learning_rate": 5.270943396226415e-05,
+      "loss": 0.0349,
+      "step": 22350
+    },
+    {
+      "epoch": 49.78,
+      "learning_rate": 5.214339622641509e-05,
+      "loss": 0.0378,
+      "step": 22400
+    },
+    {
+      "epoch": 49.78,
+      "eval_loss": 0.6031844019889832,
+      "eval_runtime": 234.1475,
+      "eval_samples_per_second": 24.378,
+      "eval_steps_per_second": 3.049,
+      "eval_wer": 0.33098663194091194,
+      "step": 22400
+    },
+    {
+      "epoch": 49.89,
+      "learning_rate": 5.157735849056603e-05,
+      "loss": 0.03,
+      "step": 22450
+    },
+    {
+      "epoch": 50.0,
+      "learning_rate": 5.101132075471697e-05,
+      "loss": 0.0345,
+      "step": 22500
+    },
+    {
+      "epoch": 50.11,
+      "learning_rate": 5.044528301886792e-05,
+      "loss": 0.0358,
+      "step": 22550
+    },
+    {
+      "epoch": 50.22,
+      "learning_rate": 4.987924528301886e-05,
+      "loss": 0.0345,
+      "step": 22600
+    },
+    {
+      "epoch": 50.33,
+      "learning_rate": 4.9313207547169806e-05,
+      "loss": 0.035,
+      "step": 22650
+    },
+    {
+      "epoch": 50.44,
+      "learning_rate": 4.874716981132075e-05,
+      "loss": 0.0331,
+      "step": 22700
+    },
+    {
+      "epoch": 50.56,
+      "learning_rate": 4.818113207547169e-05,
+      "loss": 0.0339,
+      "step": 22750
+    },
+    {
+      "epoch": 50.67,
+      "learning_rate": 4.761509433962264e-05,
+      "loss": 0.0371,
+      "step": 22800
+    },
+    {
+      "epoch": 50.67,
+      "eval_loss": 0.5830812454223633,
+      "eval_runtime": 238.3507,
+      "eval_samples_per_second": 23.948,
+      "eval_steps_per_second": 2.996,
+      "eval_wer": 0.3274665798522799,
+      "step": 22800
+    },
+    {
+      "epoch": 50.78,
+      "learning_rate": 4.704905660377358e-05,
+      "loss": 0.0345,
+      "step": 22850
+    },
+    {
+      "epoch": 50.89,
+      "learning_rate": 4.6483018867924525e-05,
+      "loss": 0.0325,
+      "step": 22900
+    },
+    {
+      "epoch": 51.0,
+      "learning_rate": 4.5916981132075465e-05,
+      "loss": 0.0387,
+      "step": 22950
+    },
+    {
+      "epoch": 51.11,
+      "learning_rate": 4.535094339622641e-05,
+      "loss": 0.0367,
+      "step": 23000
+    },
+    {
+      "epoch": 51.22,
+      "learning_rate": 4.478490566037736e-05,
+      "loss": 0.0317,
+      "step": 23050
+    },
+    {
+      "epoch": 51.33,
+      "learning_rate": 4.42188679245283e-05,
+      "loss": 0.0349,
+      "step": 23100
+    },
+    {
+      "epoch": 51.44,
+      "learning_rate": 4.3652830188679244e-05,
+      "loss": 0.0322,
+      "step": 23150
+    },
+    {
+      "epoch": 51.56,
+      "learning_rate": 4.3086792452830184e-05,
+      "loss": 0.0323,
+      "step": 23200
+    },
+    {
+      "epoch": 51.56,
+      "eval_loss": 0.5856512784957886,
+      "eval_runtime": 235.7185,
+      "eval_samples_per_second": 24.215,
+      "eval_steps_per_second": 3.029,
+      "eval_wer": 0.3265713064886972,
+      "step": 23200
+    },
+    {
+      "epoch": 51.67,
+      "learning_rate": 4.252075471698113e-05,
+      "loss": 0.0329,
+      "step": 23250
+    },
+    {
+      "epoch": 51.78,
+      "learning_rate": 4.195471698113207e-05,
+      "loss": 0.0348,
+      "step": 23300
+    },
+    {
+      "epoch": 51.89,
+      "learning_rate": 4.1388679245283016e-05,
+      "loss": 0.0324,
+      "step": 23350
+    },
+    {
+      "epoch": 52.0,
+      "learning_rate": 4.0822641509433956e-05,
+      "loss": 0.0311,
+      "step": 23400
+    },
+    {
+      "epoch": 52.11,
+      "learning_rate": 4.02566037735849e-05,
+      "loss": 0.031,
+      "step": 23450
+    },
+    {
+      "epoch": 52.22,
+      "learning_rate": 3.969056603773585e-05,
+      "loss": 0.0329,
+      "step": 23500
+    },
+    {
+      "epoch": 52.33,
+      "learning_rate": 3.912452830188679e-05,
+      "loss": 0.031,
+      "step": 23550
+    },
+    {
+      "epoch": 52.44,
+      "learning_rate": 3.8558490566037735e-05,
+      "loss": 0.0313,
+      "step": 23600
+    },
+    {
+      "epoch": 52.44,
+      "eval_loss": 0.591876745223999,
+      "eval_runtime": 234.2309,
+      "eval_samples_per_second": 24.369,
+      "eval_steps_per_second": 3.048,
+      "eval_wer": 0.3222170224021812,
+      "step": 23600
+    },
+    {
+      "epoch": 52.56,
+      "learning_rate": 3.7992452830188675e-05,
+      "loss": 0.0326,
+      "step": 23650
+    },
+    {
+      "epoch": 52.67,
+      "learning_rate": 3.742641509433962e-05,
+      "loss": 0.0277,
+      "step": 23700
+    },
+    {
+      "epoch": 52.78,
+      "learning_rate": 3.686037735849056e-05,
+      "loss": 0.0316,
+      "step": 23750
+    },
+    {
+      "epoch": 52.89,
+      "learning_rate": 3.629433962264151e-05,
+      "loss": 0.0309,
+      "step": 23800
+    },
+    {
+      "epoch": 53.0,
+      "learning_rate": 3.5728301886792454e-05,
+      "loss": 0.032,
+      "step": 23850
+    },
+    {
+      "epoch": 53.11,
+      "learning_rate": 3.5162264150943394e-05,
+      "loss": 0.0289,
+      "step": 23900
+    },
+    {
+      "epoch": 53.22,
+      "learning_rate": 3.459622641509434e-05,
+      "loss": 0.0284,
+      "step": 23950
+    },
+    {
+      "epoch": 53.33,
+      "learning_rate": 3.403018867924528e-05,
+      "loss": 0.0309,
+      "step": 24000
+    },
+    {
+      "epoch": 53.33,
+      "eval_loss": 0.5990718007087708,
+      "eval_runtime": 234.3903,
+      "eval_samples_per_second": 24.353,
+      "eval_steps_per_second": 3.046,
+      "eval_wer": 0.32537082629662034,
+      "step": 24000
+    },
+    {
+      "epoch": 53.44,
+      "learning_rate": 3.346415094339622e-05,
+      "loss": 0.0284,
+      "step": 24050
+    },
+    {
+      "epoch": 53.56,
+      "learning_rate": 3.289811320754717e-05,
+      "loss": 0.0299,
+      "step": 24100
+    },
+    {
+      "epoch": 53.67,
+      "learning_rate": 3.2332075471698106e-05,
+      "loss": 0.0315,
+      "step": 24150
+    },
+    {
+      "epoch": 53.78,
+      "learning_rate": 3.176603773584905e-05,
+      "loss": 0.0323,
+      "step": 24200
+    },
+    {
+      "epoch": 53.89,
+      "learning_rate": 3.119999999999999e-05,
+      "loss": 0.0319,
+      "step": 24250
+    },
+    {
+      "epoch": 54.0,
+      "learning_rate": 3.063396226415094e-05,
+      "loss": 0.0301,
+      "step": 24300
+    },
+    {
+      "epoch": 54.11,
+      "learning_rate": 3.0067924528301882e-05,
+      "loss": 0.0297,
+      "step": 24350
+    },
+    {
+      "epoch": 54.22,
+      "learning_rate": 2.9501886792452825e-05,
+      "loss": 0.0322,
+      "step": 24400
+    },
+    {
+      "epoch": 54.22,
+      "eval_loss": 0.6152312755584717,
+      "eval_runtime": 234.7575,
+      "eval_samples_per_second": 24.314,
+      "eval_steps_per_second": 3.041,
+      "eval_wer": 0.3252894378090219,
+      "step": 24400
+    },
+    {
+      "epoch": 54.33,
+      "learning_rate": 2.893584905660377e-05,
+      "loss": 0.0283,
+      "step": 24450
+    },
+    {
+      "epoch": 54.44,
+      "learning_rate": 2.8369811320754715e-05,
+      "loss": 0.0322,
+      "step": 24500
+    },
+    {
+      "epoch": 54.56,
+      "learning_rate": 2.7803773584905658e-05,
+      "loss": 0.0297,
+      "step": 24550
+    },
+    {
+      "epoch": 54.67,
+      "learning_rate": 2.72377358490566e-05,
+      "loss": 0.0291,
+      "step": 24600
+    },
+    {
+      "epoch": 54.78,
+      "learning_rate": 2.6671698113207544e-05,
+      "loss": 0.0323,
+      "step": 24650
+    },
+    {
+      "epoch": 54.89,
+      "learning_rate": 2.6105660377358488e-05,
+      "loss": 0.0305,
+      "step": 24700
+    },
+    {
+      "epoch": 55.0,
+      "learning_rate": 2.553962264150943e-05,
+      "loss": 0.0268,
+      "step": 24750
+    },
+    {
+      "epoch": 55.11,
+      "learning_rate": 2.4973584905660374e-05,
+      "loss": 0.0304,
+      "step": 24800
+    },
+    {
+      "epoch": 55.11,
+      "eval_loss": 0.603844404220581,
+      "eval_runtime": 234.1113,
+      "eval_samples_per_second": 24.382,
+      "eval_steps_per_second": 3.05,
+      "eval_wer": 0.3228681303029686,
+      "step": 24800
+    },
+    {
+      "epoch": 55.22,
+      "learning_rate": 2.440754716981132e-05,
+      "loss": 0.0276,
+      "step": 24850
+    },
+    {
+      "epoch": 55.33,
+      "learning_rate": 2.3841509433962263e-05,
+      "loss": 0.0266,
+      "step": 24900
+    },
+    {
+      "epoch": 55.44,
+      "learning_rate": 2.3275471698113207e-05,
+      "loss": 0.0292,
+      "step": 24950
+    },
+    {
+      "epoch": 55.56,
+      "learning_rate": 2.270943396226415e-05,
+      "loss": 0.0316,
+      "step": 25000
+    },
+    {
+      "epoch": 55.67,
+      "learning_rate": 2.2143396226415093e-05,
+      "loss": 0.0288,
+      "step": 25050
+    },
+    {
+      "epoch": 55.78,
+      "learning_rate": 2.1577358490566036e-05,
+      "loss": 0.0293,
+      "step": 25100
+    },
+    {
+      "epoch": 55.89,
+      "learning_rate": 2.101132075471698e-05,
+      "loss": 0.0302,
+      "step": 25150
+    },
+    {
+      "epoch": 56.0,
+      "learning_rate": 2.0456603773584902e-05,
+      "loss": 0.0288,
+      "step": 25200
+    },
+    {
+      "epoch": 56.0,
+      "eval_loss": 0.5989021062850952,
+      "eval_runtime": 235.0378,
+      "eval_samples_per_second": 24.285,
+      "eval_steps_per_second": 3.038,
+      "eval_wer": 0.32227806376788004,
+      "step": 25200
+    },
+    {
+      "epoch": 56.11,
+      "learning_rate": 1.9890566037735846e-05,
+      "loss": 0.0309,
+      "step": 25250
+    },
+    {
+      "epoch": 56.22,
+      "learning_rate": 1.9324528301886792e-05,
+      "loss": 0.0277,
+      "step": 25300
+    },
+    {
+      "epoch": 56.33,
+      "learning_rate": 1.8758490566037735e-05,
+      "loss": 0.031,
+      "step": 25350
+    },
+    {
+      "epoch": 56.44,
+      "learning_rate": 1.819245283018868e-05,
+      "loss": 0.0276,
+      "step": 25400
+    },
+    {
+      "epoch": 56.56,
+      "learning_rate": 1.762641509433962e-05,
+      "loss": 0.0273,
+      "step": 25450
+    },
+    {
+      "epoch": 56.67,
+      "learning_rate": 1.7060377358490565e-05,
+      "loss": 0.028,
+      "step": 25500
+    },
+    {
+      "epoch": 56.78,
+      "learning_rate": 1.6494339622641508e-05,
+      "loss": 0.0287,
+      "step": 25550
+    },
+    {
+      "epoch": 56.89,
+      "learning_rate": 1.592830188679245e-05,
+      "loss": 0.0307,
+      "step": 25600
+    },
+    {
+      "epoch": 56.89,
+      "eval_loss": 0.5922682285308838,
+      "eval_runtime": 236.4109,
+      "eval_samples_per_second": 24.144,
+      "eval_steps_per_second": 3.02,
+      "eval_wer": 0.32016196309032086,
+      "step": 25600
+    },
+    {
+      "epoch": 57.0,
+      "learning_rate": 1.5362264150943397e-05,
+      "loss": 0.027,
+      "step": 25650
+    },
+    {
+      "epoch": 57.11,
+      "learning_rate": 1.4796226415094337e-05,
+      "loss": 0.0277,
+      "step": 25700
+    },
+    {
+      "epoch": 57.22,
+      "learning_rate": 1.423018867924528e-05,
+      "loss": 0.0265,
+      "step": 25750
+    },
+    {
+      "epoch": 57.33,
+      "learning_rate": 1.3664150943396225e-05,
+      "loss": 0.0266,
+      "step": 25800
+    },
+    {
+      "epoch": 57.44,
+      "learning_rate": 1.3098113207547168e-05,
+      "loss": 0.0277,
+      "step": 25850
+    },
+    {
+      "epoch": 57.56,
+      "learning_rate": 1.2532075471698111e-05,
+      "loss": 0.0246,
+      "step": 25900
+    },
+    {
+      "epoch": 57.67,
+      "learning_rate": 1.1966037735849054e-05,
+      "loss": 0.0278,
+      "step": 25950
+    },
+    {
+      "epoch": 57.78,
+      "learning_rate": 1.14e-05,
+      "loss": 0.0258,
+      "step": 26000
+    },
+    {
+      "epoch": 57.78,
+      "eval_loss": 0.6004139184951782,
+      "eval_runtime": 234.8842,
+      "eval_samples_per_second": 24.301,
+      "eval_steps_per_second": 3.04,
+      "eval_wer": 0.31922599548293895,
+      "step": 26000
+    },
+    {
+      "epoch": 57.89,
+      "learning_rate": 1.0833962264150942e-05,
+      "loss": 0.0252,
+      "step": 26050
+    },
+    {
+      "epoch": 58.0,
+      "learning_rate": 1.0267924528301886e-05,
+      "loss": 0.027,
+      "step": 26100
+    },
+    {
+      "epoch": 58.11,
+      "learning_rate": 9.701886792452829e-06,
+      "loss": 0.0277,
+      "step": 26150
+    },
+    {
+      "epoch": 58.22,
+      "learning_rate": 9.135849056603773e-06,
+      "loss": 0.0237,
+      "step": 26200
+    },
+    {
+      "epoch": 58.33,
+      "learning_rate": 8.569811320754717e-06,
+      "loss": 0.0232,
+      "step": 26250
+    },
+    {
+      "epoch": 58.44,
+      "learning_rate": 8.00377358490566e-06,
+      "loss": 0.028,
+      "step": 26300
+    },
+    {
+      "epoch": 58.56,
+      "learning_rate": 7.437735849056603e-06,
+      "loss": 0.0293,
+      "step": 26350
+    },
+    {
+      "epoch": 58.67,
+      "learning_rate": 6.871698113207546e-06,
+      "loss": 0.0261,
+      "step": 26400
+    },
+    {
+      "epoch": 58.67,
+      "eval_loss": 0.5958569049835205,
+      "eval_runtime": 234.8641,
+      "eval_samples_per_second": 24.303,
+      "eval_steps_per_second": 3.04,
+      "eval_wer": 0.3189004415325452,
+      "step": 26400
+    },
+    {
+      "epoch": 58.78,
+      "learning_rate": 6.30566037735849e-06,
+      "loss": 0.0293,
+      "step": 26450
+    },
+    {
+      "epoch": 58.89,
+      "learning_rate": 5.739622641509433e-06,
+      "loss": 0.0278,
+      "step": 26500
+    },
+    {
+      "epoch": 59.0,
+      "learning_rate": 5.173584905660377e-06,
+      "loss": 0.0262,
+      "step": 26550
+    },
+    {
+      "epoch": 59.11,
+      "learning_rate": 4.60754716981132e-06,
+      "loss": 0.025,
+      "step": 26600
+    },
+    {
+      "epoch": 59.22,
+      "learning_rate": 4.041509433962263e-06,
+      "loss": 0.0286,
+      "step": 26650
+    },
+    {
+      "epoch": 59.33,
+      "learning_rate": 3.4754716981132073e-06,
+      "loss": 0.0295,
+      "step": 26700
+    },
+    {
+      "epoch": 59.44,
+      "learning_rate": 2.909433962264151e-06,
+      "loss": 0.0249,
+      "step": 26750
+    },
+    {
+      "epoch": 59.56,
+      "learning_rate": 2.343396226415094e-06,
+      "loss": 0.0277,
+      "step": 26800
+    },
+    {
+      "epoch": 59.56,
+      "eval_loss": 0.593723475933075,
+      "eval_runtime": 234.2801,
+      "eval_samples_per_second": 24.364,
+      "eval_steps_per_second": 3.048,
+      "eval_wer": 0.318188292266059,
+      "step": 26800
+    }
+  ],
+  "max_steps": 27000,
+  "num_train_epochs": 60,
+  "total_flos": 1.1861566534187504e+20,
+  "trial_name": null,
+  "trial_params": null
+}

training_args.bin

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

vocab.json

@@ -0,0 +1 @@
+{"e": 0, "n": 1, "a": 2, "i": 3, "t": 4, "o": 5, "d": 6, "r": 7, " ": 8, "l": 9, "s": 10, "h": 11, "g": 12, "m": 13, "k": 14, "v": 15, "j": 16, "w": 17, "z": 18, "u": 19, "b": 20, "c": 21, "p": 22, "f": 23, "y": 24, "é": 25, "'": 26, "x": 27, "ë": 28, "q": 29, "-": 30, "ê": 31, "à": 32, "ä": 33, "è": 34, "ï": 35, "â": 36, "û": 37, "ö": 38, "ô": 39, "ü": 40, "î": 41, "ç": 42, "æ": 43, "ù": 44, "œ": 45, "<unk>": 46, "<pad>": 47}