End of training

.ipynb_checkpoints/custom-checkpoint.py

@@ -0,0 +1,76 @@
+from transformers import Wav2Vec2CTCTokenizer
+
+class Wav2Vec2WordpieceTokenizer(Wav2Vec2CTCTokenizer):
+    def __init__(
+        self,
+        vocab_file,
+        bos_token="<s>",
+        eos_token="</s>",
+        unk_token="<unk>",
+        pad_token="<pad>",
+        word_delimiter_token="|",
+        do_lower_case=False,
+        **kwargs
+    ):
+        super().__init__(
+            vocab_file=vocab_file,
+            unk_token=unk_token,
+            bos_token=bos_token,
+            eos_token=eos_token,
+            pad_token=pad_token,
+            do_lower_case=do_lower_case,
+            word_delimiter_token=word_delimiter_token,
+            **kwargs,
+        )
+
+        self._create_trie(self.all_special_tokens_extended)
+        
+    def _tokenize(self, text, **kwargs):
+        """
+        Converts a string in a sequence of tokens (string), using the tokenizer.
+        """
+        special_cases = set(['gia', 'qui', 'quy', 'que', 'qua'])
+        output_tokens = []
+        for token_idx, token in enumerate(text.split()):
+            if token in special_cases:
+                sub_tokens = [token[:2], token[2:]]
+            else:
+                end = len(token)
+                sub_tokens = []
+                while end > 0:
+                    start = 0
+                    cur_substr = None
+                    while start < end:
+                        substr = token[start:end]
+                        if substr in self.encoder:
+                            cur_substr = substr
+                            break
+                        start += 1
+                    if cur_substr is None:
+                        sub_tokens.insert(0, self.unk_token)
+                        end = start - 1
+                    else:
+                        sub_tokens.insert(0, cur_substr)
+                        end = start
+            
+            if token_idx > 0:
+                output_tokens.append(self.word_delimiter_token)
+            output_tokens.extend(sub_tokens)
+        return output_tokens
+    
+    def decode_ids(
+        self, 
+        token_ids, 
+        skip_special_tokens = False, 
+        clean_up_tokenization_spaces = True,
+        group_tokens: bool = True,
+        spaces_between_special_tokens: bool = False,
+    ) -> str:
+        # For compatible with speechbrain interfaces
+        return self.decode(
+            token_ids,
+            skip_special_tokens=skip_special_tokens,
+            clean_up_tokenization_spaces=clean_up_tokenization_spaces,
+            group_tokens=group_tokens,
+            spaces_between_special_tokens=spaces_between_special_tokens
+        )

.ipynb_checkpoints/eval-checkpoint.py

@@ -0,0 +1,210 @@
+#!/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
+from transformers import Wav2Vec2CTCTokenizer
+
+class Wav2Vec2WordpieceTokenizer(Wav2Vec2CTCTokenizer):
+    def __init__(
+        self,
+        vocab_file,
+        bos_token="<s>",
+        eos_token="</s>",
+        unk_token="<unk>",
+        pad_token="<pad>",
+        word_delimiter_token="|",
+        do_lower_case=False,
+        **kwargs
+    ):
+        super().__init__(
+            vocab_file=vocab_file,
+            unk_token=unk_token,
+            bos_token=bos_token,
+            eos_token=eos_token,
+            pad_token=pad_token,
+            do_lower_case=do_lower_case,
+            word_delimiter_token=word_delimiter_token,
+            **kwargs,
+        )
+
+        self._create_trie(self.all_special_tokens_extended)
+        
+    def _tokenize(self, text, **kwargs):
+        """
+        Converts a string in a sequence of tokens (string), using the tokenizer.
+        """
+        special_cases = set(['gia', 'qui', 'quy', 'que', 'qua'])
+        output_tokens = []
+        for token_idx, token in enumerate(text.split()):
+            if token in special_cases:
+                sub_tokens = [token[:2], token[2:]]
+            else:
+                end = len(token)
+                sub_tokens = []
+                while end > 0:
+                    start = 0
+                    cur_substr = None
+                    while start < end:
+                        substr = token[start:end]
+                        if substr in self.encoder:
+                            cur_substr = substr
+                            break
+                        start += 1
+                    if cur_substr is None:
+                        sub_tokens.insert(0, self.unk_token)
+                        end = start - 1
+                    else:
+                        sub_tokens.insert(0, cur_substr)
+                        end = start
+            
+            if token_idx > 0:
+                output_tokens.append(self.word_delimiter_token)
+            output_tokens.extend(sub_tokens)
+        return output_tokens
+    
+    def decode_ids(
+        self, 
+        token_ids, 
+        skip_special_tokens = False, 
+        clean_up_tokenization_spaces = True,
+        group_tokens: bool = True,
+        spaces_between_special_tokens: bool = False,
+    ) -> str:
+        # For compatible with speechbrain interfaces
+        return self.decode(
+            token_ids,
+            skip_special_tokens=skip_special_tokens,
+            clean_up_tokenization_spaces=clean_up_tokenization_spaces,
+            group_tokens=group_tokens,
+            spaces_between_special_tokens=spaces_between_special_tokens
+        )
+        
+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
+
+    # load tokenizer
+    tokenizer = Wav2Vec2WordpieceTokenizer(
+        vocab_file = args.model_id + 'vocab.json',
+    )
+
+    # resample audio
+    dataset = dataset.cast_column("audio", Audio(sampling_rate=sampling_rate))
+
+    # load eval pipeline
+    asr = pipeline(
+      "automatic-speech-recognition", 
+      model=args.model_id,
+      tokenizer = tokenizer
+      )
+    # 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)

all_results.json

@@ -1,14 +1,14 @@
 {
     "epoch": 50.0,
     "eval_loss": 4.169058322906494,
-    "eval_runtime": 34.4023,
+    "eval_runtime": 34.3912,
     "eval_samples": 761,
-    "eval_samples_per_second": 22.121,
-    "eval_steps_per_second": 1.395,
+    "eval_samples_per_second": 22.128,
+    "eval_steps_per_second": 1.396,
     "eval_wer": 0.4132525828286427,
-    "train_loss": 0.4784129307122878,
-    "train_runtime": 111036.8702,
+    "train_loss": 0.0,
+    "train_runtime": 69.3888,
     "train_samples": 25915,
-    "train_samples_per_second": 11.67,
-    "train_steps_per_second": 0.365
+    "train_samples_per_second": 3734.751,
+    "train_steps_per_second": 116.733
 }

custom.py

@@ -0,0 +1,76 @@
+from transformers import Wav2Vec2CTCTokenizer
+
+class Wav2Vec2WordpieceTokenizer(Wav2Vec2CTCTokenizer):
+    def __init__(
+        self,
+        vocab_file,
+        bos_token="<s>",
+        eos_token="</s>",
+        unk_token="<unk>",
+        pad_token="<pad>",
+        word_delimiter_token="|",
+        do_lower_case=False,
+        **kwargs
+    ):
+        super().__init__(
+            vocab_file=vocab_file,
+            unk_token=unk_token,
+            bos_token=bos_token,
+            eos_token=eos_token,
+            pad_token=pad_token,
+            do_lower_case=do_lower_case,
+            word_delimiter_token=word_delimiter_token,
+            **kwargs,
+        )
+
+        self._create_trie(self.all_special_tokens_extended)
+        
+    def _tokenize(self, text, **kwargs):
+        """
+        Converts a string in a sequence of tokens (string), using the tokenizer.
+        """
+        special_cases = set(['gia', 'qui', 'quy', 'que', 'qua'])
+        output_tokens = []
+        for token_idx, token in enumerate(text.split()):
+            if token in special_cases:
+                sub_tokens = [token[:2], token[2:]]
+            else:
+                end = len(token)
+                sub_tokens = []
+                while end > 0:
+                    start = 0
+                    cur_substr = None
+                    while start < end:
+                        substr = token[start:end]
+                        if substr in self.encoder:
+                            cur_substr = substr
+                            break
+                        start += 1
+                    if cur_substr is None:
+                        sub_tokens.insert(0, self.unk_token)
+                        end = start - 1
+                    else:
+                        sub_tokens.insert(0, cur_substr)
+                        end = start
+            
+            if token_idx > 0:
+                output_tokens.append(self.word_delimiter_token)
+            output_tokens.extend(sub_tokens)
+        return output_tokens
+    
+    def decode_ids(
+        self, 
+        token_ids, 
+        skip_special_tokens = False, 
+        clean_up_tokenization_spaces = True,
+        group_tokens: bool = True,
+        spaces_between_special_tokens: bool = False,
+    ) -> str:
+        # For compatible with speechbrain interfaces
+        return self.decode(
+            token_ids,
+            skip_special_tokens=skip_special_tokens,
+            clean_up_tokenization_spaces=clean_up_tokenization_spaces,
+            group_tokens=group_tokens,
+            spaces_between_special_tokens=spaces_between_special_tokens
+        )

eval.py

@@ -0,0 +1,210 @@
+#!/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
+from transformers import Wav2Vec2CTCTokenizer
+
+class Wav2Vec2WordpieceTokenizer(Wav2Vec2CTCTokenizer):
+    def __init__(
+        self,
+        vocab_file,
+        bos_token="<s>",
+        eos_token="</s>",
+        unk_token="<unk>",
+        pad_token="<pad>",
+        word_delimiter_token="|",
+        do_lower_case=False,
+        **kwargs
+    ):
+        super().__init__(
+            vocab_file=vocab_file,
+            unk_token=unk_token,
+            bos_token=bos_token,
+            eos_token=eos_token,
+            pad_token=pad_token,
+            do_lower_case=do_lower_case,
+            word_delimiter_token=word_delimiter_token,
+            **kwargs,
+        )
+
+        self._create_trie(self.all_special_tokens_extended)
+        
+    def _tokenize(self, text, **kwargs):
+        """
+        Converts a string in a sequence of tokens (string), using the tokenizer.
+        """
+        special_cases = set(['gia', 'qui', 'quy', 'que', 'qua'])
+        output_tokens = []
+        for token_idx, token in enumerate(text.split()):
+            if token in special_cases:
+                sub_tokens = [token[:2], token[2:]]
+            else:
+                end = len(token)
+                sub_tokens = []
+                while end > 0:
+                    start = 0
+                    cur_substr = None
+                    while start < end:
+                        substr = token[start:end]
+                        if substr in self.encoder:
+                            cur_substr = substr
+                            break
+                        start += 1
+                    if cur_substr is None:
+                        sub_tokens.insert(0, self.unk_token)
+                        end = start - 1
+                    else:
+                        sub_tokens.insert(0, cur_substr)
+                        end = start
+            
+            if token_idx > 0:
+                output_tokens.append(self.word_delimiter_token)
+            output_tokens.extend(sub_tokens)
+        return output_tokens
+    
+    def decode_ids(
+        self, 
+        token_ids, 
+        skip_special_tokens = False, 
+        clean_up_tokenization_spaces = True,
+        group_tokens: bool = True,
+        spaces_between_special_tokens: bool = False,
+    ) -> str:
+        # For compatible with speechbrain interfaces
+        return self.decode(
+            token_ids,
+            skip_special_tokens=skip_special_tokens,
+            clean_up_tokenization_spaces=clean_up_tokenization_spaces,
+            group_tokens=group_tokens,
+            spaces_between_special_tokens=spaces_between_special_tokens
+        )
+        
+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
+
+    # load tokenizer
+    tokenizer = Wav2Vec2WordpieceTokenizer(
+        vocab_file = args.model_id + 'vocab.json',
+    )
+
+    # resample audio
+    dataset = dataset.cast_column("audio", Audio(sampling_rate=sampling_rate))
+
+    # load eval pipeline
+    asr = pipeline(
+      "automatic-speech-recognition", 
+      model=args.model_id,
+      tokenizer = tokenizer
+      )
+    # 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)

eval_results.json

@@ -1,9 +1,9 @@
 {
     "epoch": 50.0,
     "eval_loss": 4.169058322906494,
-    "eval_runtime": 34.4023,
+    "eval_runtime": 34.3912,
     "eval_samples": 761,
-    "eval_samples_per_second": 22.121,
-    "eval_steps_per_second": 1.395,
+    "eval_samples_per_second": 22.128,
+    "eval_steps_per_second": 1.396,
     "eval_wer": 0.4132525828286427
 }

log_mozilla-foundation_common_voice_7_0_vi_test_predictions.txt

@@ -0,0 +1,20 @@
+0
+nông mấy người giữ thụ độc này n
+1
+thoặc là có thể lái nhiệng khu mái manh
+2
+n không sồng không săn n
+3
+buồn thế n
+4
+dứt lời chinh vội bỏ ra ngoài quên lấy cải tiền
+5
+chịt nghẹ
+6
+ở bên trong chinh tự hỏn
+7
+nhưng đáng tiếc là thảo không hề suất
+8
+nó bắt hồn anh chàng ấy định biến anh ta thành một cặp đôi
+9
+mấy người cứ tin thầy cúng rồi mất mạng lại chác nhau

log_mozilla-foundation_common_voice_7_0_vi_test_targets.txt

@@ -0,0 +1,20 @@
+0
+ở cái nơi rừng thiêng nước độc này
+1
+hoặc là có thể là nhờ kuman
+2
+không không không sao đâu
+3
+buồn thế chứ
+4
+dứt lời trinh vội bỏ ra ngoài quên lấy cả tiền
+5
+kịch nghệ
+6
+ở bên trong trinh tự hỏi
+7
+nhưng đáng tiếc là thảo không hề xuất
+8
+nó bắt hồn anh chàng ấy định biến anh ta thành một cặp đôi
+9
+mấy người cứ tin thầy cúng rồi mất mạng lại trách nhau

log_vivos_vi_test_predictions.txt

@@ -0,0 +1,20 @@
+0
+ửa vòng trái đất hơn bảy năm
+1
+ốn chiếc trong đái phèn la
+2
+ố những thay lật khồng mằn
+3
+ông nhạc nó lên
+4
+ế nhưng khi giá phôi thép thế giới cao dần
+5
+ơn gọi tài địa phương là trắc thối
+6
+oanh nghiệp tính dụng lao động nước ngoài
+7
+ức khắc ập về kéo mọi người thứ trở lại thời hoang sơ
+8
+ới đây nhất là các tiểu vương quốc á rập thống nhất
+9
+ần nữa mãi mới gặp được tuyên

log_vivos_vi_test_targets.txt

@@ -0,0 +1,20 @@
+0
+nửa vòng trái đất hơn bảy năm
+1
+bốn chiếc trống đại phèng la
+2
+của những thế lực hùng mạnh
+3
+ông nhặt nó lên
+4
+thế nhưng khi giá phôi thép thế giới cao dần
+5
+tên gọi tại địa phương là trắc thối
+6
+doanh nghiệp tuyển dụng lao động nước ngoài
+7
+tức khắc ập về kéo mọi người thứ trở lại thời hoang sơ
+8
+mới đây nhất là các tiểu vương quốc ả rập thống nhất
+9
+lần lữa mãi mới gặp được tuyên

runs/Jan29_00-37-33_job-fa775f5b-8438-4c3d-95fa-ed70ddaee577/1643416720.7954614/events.out.tfevents.1643416720.job-fa775f5b-8438-4c3d-95fa-ed70ddaee577.1784910.1

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

runs/Jan29_00-37-33_job-fa775f5b-8438-4c3d-95fa-ed70ddaee577/events.out.tfevents.1643416720.job-fa775f5b-8438-4c3d-95fa-ed70ddaee577.1784910.0

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

runs/Jan29_00-45-45_job-fa775f5b-8438-4c3d-95fa-ed70ddaee577/1643417179.7920382/events.out.tfevents.1643417179.job-fa775f5b-8438-4c3d-95fa-ed70ddaee577.1788197.1

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

runs/Jan29_00-45-45_job-fa775f5b-8438-4c3d-95fa-ed70ddaee577/events.out.tfevents.1643417179.job-fa775f5b-8438-4c3d-95fa-ed70ddaee577.1788197.0

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

runs/Jan29_00-45-45_job-fa775f5b-8438-4c3d-95fa-ed70ddaee577/events.out.tfevents.1643417291.job-fa775f5b-8438-4c3d-95fa-ed70ddaee577.1788197.2

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

train_results.json

@@ -1,8 +1,8 @@
 {
     "epoch": 50.0,
-    "train_loss": 0.4784129307122878,
-    "train_runtime": 111036.8702,
+    "train_loss": 0.0,
+    "train_runtime": 69.3888,
     "train_samples": 25915,
-    "train_samples_per_second": 11.67,
-    "train_steps_per_second": 0.365
+    "train_samples_per_second": 3734.751,
+    "train_steps_per_second": 116.733
 }

trainer_state.json

@@ -416,14 +416,14 @@
       "epoch": 50.0,
       "step": 40500,
       "total_flos": 5.1003805267852526e+20,
-      "train_loss": 0.4784129307122878,
-      "train_runtime": 111036.8702,
-      "train_samples_per_second": 11.67,
-      "train_steps_per_second": 0.365
+      "train_loss": 0.0,
+      "train_runtime": 69.3888,
+      "train_samples_per_second": 3734.751,
+      "train_steps_per_second": 116.733
     }
   ],
-  "max_steps": 40500,
-  "num_train_epochs": 50,
+  "max_steps": 8100,
+  "num_train_epochs": 10,
   "total_flos": 5.1003805267852526e+20,
   "trial_name": null,
   "trial_params": null

training_args.bin

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ab041f077ae5bb0a89c45ded8a582a7fa3e06d0bfffc97967b7a16a322ffafa7
+oid sha256:9f7b935061dd3476a8cedb212f63c7b7aff005629bf2fdf5f3d75ed71568b22d
 size 3055