add init code train

.gitignore

@@ -0,0 +1,258 @@
+
+# Created by https://www.toptal.com/developers/gitignore/api/pycharm,python
+# Edit at https://www.toptal.com/developers/gitignore?templates=pycharm,python
+
+### PyCharm ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# AWS User-specific
+.idea/**/aws.xml
+
+# Generated files
+.idea/**/contentModel.xml
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/artifacts
+# .idea/compiler.xml
+# .idea/jarRepositories.xml
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+# *.iml
+# *.ipr
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+
+# Android studio 3.1+ serialized cache file
+.idea/caches/build_file_checksums.ser
+
+### PyCharm Patch ###
+# Comment Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-215987721
+
+# *.iml
+# modules.xml
+# .idea/misc.xml
+# *.ipr
+
+# Sonarlint plugin
+# https://plugins.jetbrains.com/plugin/7973-sonarlint
+.idea/**/sonarlint/
+
+# SonarQube Plugin
+# https://plugins.jetbrains.com/plugin/7238-sonarqube-community-plugin
+.idea/**/sonarIssues.xml
+
+# Markdown Navigator plugin
+# https://plugins.jetbrains.com/plugin/7896-markdown-navigator-enhanced
+.idea/**/markdown-navigator.xml
+.idea/**/markdown-navigator-enh.xml
+.idea/**/markdown-navigator/
+
+# Cache file creation bug
+# See https://youtrack.jetbrains.com/issue/JBR-2257
+.idea/$CACHE_FILE$
+
+# CodeStream plugin
+# https://plugins.jetbrains.com/plugin/12206-codestream
+.idea/codestream.xml
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# End of https://www.toptal.com/developers/gitignore/api/pycharm,python
+
+
+data-bin/
+
+.DS_Store
+
+.idea/

data_handler.py

@@ -0,0 +1,68 @@
+import torch
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Union
+from transformers import Wav2Vec2Processor
+
+
+@dataclass
+class DataCollatorCTCWithPadding:
+    """
+    Data collator that will dynamically pad the inputs received.
+    Args:
+        processor (:class:`~transformers.Wav2Vec2Processor`)
+            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: Wav2Vec2Processor
+    padding: Union[bool, str] = True
+    max_length: Optional[int] = None
+    max_length_labels: Optional[int] = None
+    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,
+            max_length=self.max_length,
+            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,
+                max_length=self.max_length_labels,
+                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

main.py

@@ -0,0 +1,180 @@
+from transformers import Wav2Vec2ForCTC, Wav2Vec2Processor, Wav2Vec2CTCTokenizer, Wav2Vec2FeatureExtractor
+from datasets import load_from_disk
+from data_handler import DataCollatorCTCWithPadding
+from transformers import TrainingArguments
+from transformers import Trainer, logging
+from metric_utils import compute_metrics_fn
+from transformers.trainer_utils import get_last_checkpoint
+import json, random
+import os, glob
+
+logging.set_verbosity_info()
+
+
+def load_pretrained_model(checkpoint_path=None):
+    if checkpoint_path is None:
+        pre_trained_path = './model-bin/pretrained/base'
+        tokenizer = Wav2Vec2CTCTokenizer("./model-bin/finetune/vocab.json",
+                                         unk_token="<unk>",
+                                         pad_token="<pad>",
+                                         word_delimiter_token="|")
+
+        feature_extractor = Wav2Vec2FeatureExtractor.from_pretrained(pre_trained_path)
+        processor = Wav2Vec2Processor(feature_extractor=feature_extractor, tokenizer=tokenizer)
+
+        model = Wav2Vec2ForCTC.from_pretrained(
+            pre_trained_path,
+            gradient_checkpointing=True,
+            ctc_loss_reduction="mean",
+            pad_token_id=processor.tokenizer.pad_token_id,
+        )
+        model.freeze_feature_extractor()
+    else:
+        tokenizer = Wav2Vec2CTCTokenizer.from_pretrained(checkpoint_path)
+
+        feature_extractor = Wav2Vec2FeatureExtractor.from_pretrained(checkpoint_path)
+        processor = Wav2Vec2Processor(feature_extractor=feature_extractor, tokenizer=tokenizer)
+
+        model = Wav2Vec2ForCTC.from_pretrained(
+            checkpoint_path,
+            gradient_checkpointing=True,
+            ctc_loss_reduction="mean",
+            pad_token_id=processor.tokenizer.pad_token_id,
+        )
+        # model.freeze_feature_extractor()
+
+    model_total_params = sum(p.numel() for p in model.parameters())
+    model_total_params_trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    print(model)
+    print("model_total_params: {}\nmodel_total_params_trainable: {}".format(model_total_params,
+                                                                            model_total_params_trainable))
+    return model, processor
+
+
+def prepare_dataset(batch, processor):
+    # check that all files have the correct sampling rate
+    assert (
+            len(set(batch["sampling_rate"])) == 1
+    ), f"Make sure all inputs have the same sampling rate of {processor.feature_extractor.sampling_rate}."
+
+    batch["input_values"] = processor(batch["speech"], sampling_rate=batch["sampling_rate"][0]).input_values
+
+    with processor.as_target_processor():
+        batch["labels"] = processor(batch["target_text"]).input_ids
+    return batch
+
+
+def load_prepared_dataset(path, processor, cache_file_name):
+    dataset = load_from_disk(path)
+    processed_dataset = dataset.map(prepare_dataset,
+                                    remove_columns=dataset.column_names,
+                                    batch_size=8,
+                                    num_proc=8,
+                                    batched=True,
+                                    fn_kwargs={"processor": processor},
+                                    cache_file_name=cache_file_name)
+    return processed_dataset
+
+
+# def get_train_dataset():
+#     for i in range()
+
+if __name__ == "__main__":
+
+    checkpoint_path = "./model-bin/finetune/base/"
+    train_dataset_root_folder = './data-bin/train_dataset'
+    test_dataset_root_folder = './data-bin/test_dataset'
+    cache_processing_dataset_folder = './data-bin/cache/'
+    if not os.path.exists(cache_processing_dataset_folder):
+        os.makedirs(cache_processing_dataset_folder)
+    num_train_shards = len(glob.glob(os.path.join(train_dataset_root_folder, 'shard_*')))
+    num_test_shards = len(glob.glob(os.path.join(test_dataset_root_folder, 'shard_*')))
+    num_epochs = 20
+
+    training_args = TrainingArguments(
+        output_dir=checkpoint_path,
+        # fp16=True,
+        group_by_length=True,
+        per_device_train_batch_size=2,
+        per_device_eval_batch_size=2,
+        gradient_accumulation_steps=1,
+        num_train_epochs=1,  # each epoch per shard data
+        logging_steps=1,
+        learning_rate=1e-4,
+        weight_decay=0.005,
+        warmup_steps=5000,
+        save_total_limit=2,
+        ignore_data_skip=True,
+        logging_dir=os.path.join(checkpoint_path, 'log'),
+        metric_for_best_model='wer',
+        save_strategy="epoch",
+        evaluation_strategy="epoch",
+        # save_steps=5,
+        # eval_steps=5,
+    )
+
+    # PretrainedConfig.from_json_file(os.path.join(resume_from_checkpoint, CONFIG_NAME))
+    last_checkpoint_path = None
+    last_epoch_idx = 0
+    if os.path.exists(checkpoint_path):
+        last_checkpoint_path = get_last_checkpoint(checkpoint_path)
+        if last_checkpoint_path is not None:
+            with open(os.path.join(last_checkpoint_path, "trainer_state.json"), 'r', encoding='utf-8') as file:
+                trainer_state = json.load(file)
+                last_epoch_idx = int(trainer_state['epoch'])
+
+    w2v_ctc_model, w2v_ctc_processor = load_pretrained_model()
+    data_collator = DataCollatorCTCWithPadding(processor=w2v_ctc_processor, padding=True)
+
+    for epoch_idx in range(last_epoch_idx, num_epochs):
+        # loop over training shards
+        train_dataset_shard_idx = epoch_idx % num_train_shards
+        # Get test shard depend on train shard id
+        test_dataset_shard_idx = round(train_dataset_shard_idx / (num_train_shards / num_test_shards))
+        num_test_sub_shard = 1000  # Split test shard into subset. Default is 8
+        idx_sub_shard = train_dataset_shard_idx % num_test_sub_shard  # loop over test shard subset
+
+        # load train shard
+        train_dataset = load_prepared_dataset(os.path.join(train_dataset_root_folder,
+                                                           'shard_{}'.format(train_dataset_shard_idx)),
+                                              w2v_ctc_processor,
+                                              cache_file_name=os.path.join(cache_processing_dataset_folder,
+                                                                           'cache-train-shard-{}.arrow'.format(
+                                                                               train_dataset_shard_idx))
+                                              ).shard(1000, 0)  # Remove shard split when train
+        # load test shard subset
+        test_dataset = load_prepared_dataset(os.path.join(test_dataset_root_folder,
+                                                          'shard_{}'.format(test_dataset_shard_idx)),
+                                             w2v_ctc_processor,
+                                             cache_file_name=os.path.join(cache_processing_dataset_folder,
+                                                                          'cache-test-shard-{}.arrow'.format(
+                                                                              test_dataset_shard_idx))
+                                             ).shard(num_test_sub_shard, idx_sub_shard)
+
+        # Init trainer
+        trainer = Trainer(
+            model=w2v_ctc_model,
+            data_collator=data_collator,
+            args=training_args,
+            compute_metrics=compute_metrics_fn(w2v_ctc_processor),
+            train_dataset=train_dataset,
+            eval_dataset=test_dataset,
+            tokenizer=w2v_ctc_processor.feature_extractor
+        )
+        # Manual add num_train_epochs because each epoch loop over a shard
+        training_args.num_train_epochs = epoch_idx + 1
+
+        logging.get_logger().info('Train shard idx: {}'.format(train_dataset_shard_idx))
+        logging.get_logger().info('Valid shard idx: {} sub_shard: {}'.format(test_dataset_shard_idx, idx_sub_shard))
+
+        if last_checkpoint_path is not None:
+            # start train from a checkpoint if exist
+            trainer.train(resume_from_checkpoint=True)
+        else:
+            # train from pre-trained wav2vec2 checkpoint
+            trainer.train()
+        last_checkpoint_path = get_last_checkpoint(checkpoint_path)
+
+        # Clear cache file to free disk
+        # test_dataset.cleanup_cache_files()
+        # train_dataset.cleanup_cache_files()

metric_utils.py

@@ -0,0 +1,25 @@
+import numpy as np
+from datasets import load_metric
+
+wer_metric = load_metric("./model-bin/metrics/wer")
+
+
+# print(wer_metric)
+
+
+def compute_metrics_fn(processor):
+    def compute(pred):
+        pred_logits = pred.predictions
+        pred_ids = np.argmax(pred_logits, axis=-1)
+
+        pred.label_ids[pred.label_ids == -100] = processor.tokenizer.pad_token_id
+
+        pred_str = processor.batch_decode(pred_ids)
+        # we do not want to group tokens when computing the metrics
+        label_str = processor.batch_decode(pred.label_ids, group_tokens=False)
+
+        wer = wer_metric.compute(predictions=pred_str, references=label_str)
+
+        return {"wer": wer}
+
+    return compute

model-bin/metrics/wer/wer.py

@@ -0,0 +1,105 @@
+# coding=utf-8
+# Copyright 2021 The HuggingFace Datasets Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""" Word Error Ratio (WER) metric. """
+
+from jiwer import compute_measures
+
+import datasets
+
+_CITATION = """\
+@inproceedings{inproceedings,
+    author = {Morris, Andrew and Maier, Viktoria and Green, Phil},
+    year = {2004},
+    month = {01},
+    pages = {},
+    title = {From WER and RIL to MER and WIL: improved evaluation measures for connected speech recognition.}
+}
+"""
+
+_DESCRIPTION = """\
+Word error rate (WER) is a common metric of the performance of an automatic speech recognition system.
+
+The general difficulty of measuring performance lies in the fact that the recognized word sequence can have a different length from the reference word sequence (supposedly the correct one). The WER is derived from the Levenshtein distance, working at the word level instead of the phoneme level. The WER is a valuable tool for comparing different systems as well as for evaluating improvements within one system. This kind of measurement, however, provides no details on the nature of translation errors and further work is therefore required to identify the main source(s) of error and to focus any research effort.
+
+This problem is solved by first aligning the recognized word sequence with the reference (spoken) word sequence using dynamic string alignment. Examination of this issue is seen through a theory called the power law that states the correlation between perplexity and word error rate.
+
+Word error rate can then be computed as:
+
+WER = (S + D + I) / N = (S + D + I) / (S + D + C)
+
+where
+
+S is the number of substitutions,
+D is the number of deletions,
+I is the number of insertions,
+C is the number of correct words,
+N is the number of words in the reference (N=S+D+C).
+
+WER's output is always a number between 0 and 1. This value indicates the percentage of words that were incorrectly predicted. The lower the value, the better the
+performance of the ASR system with a WER of 0 being a perfect score.
+"""
+
+_KWARGS_DESCRIPTION = """
+Compute WER score of transcribed segments against references.
+
+Args:
+    references: List of references for each speech input.
+    predictions: List of transcriptions to score.
+    concatenate_texts (bool, default=False): Whether to concatenate all input texts or compute WER iteratively.
+
+Returns:
+    (float): the word error rate
+
+Examples:
+
+    >>> predictions = ["this is the prediction", "there is an other sample"]
+    >>> references = ["this is the reference", "there is another one"]
+    >>> wer = datasets.load_metric("wer")
+    >>> wer_score = wer.compute(predictions=predictions, references=references)
+    >>> print(wer_score)
+    0.5
+"""
+
+
+@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION)
+class WER(datasets.Metric):
+    def _info(self):
+        return datasets.MetricInfo(
+            description=_DESCRIPTION,
+            citation=_CITATION,
+            inputs_description=_KWARGS_DESCRIPTION,
+            features=datasets.Features(
+                {
+                    "predictions": datasets.Value("string", id="sequence"),
+                    "references": datasets.Value("string", id="sequence"),
+                }
+            ),
+            codebase_urls=["https://github.com/jitsi/jiwer/"],
+            reference_urls=[
+                "https://en.wikipedia.org/wiki/Word_error_rate",
+            ],
+        )
+
+    def _compute(self, predictions=None, references=None, concatenate_texts=False):
+        if concatenate_texts:
+            return compute_measures(references, predictions)["wer"]
+        else:
+            incorrect = 0
+            total = 0
+            for prediction, reference in zip(predictions, references):
+                measures = compute_measures(reference, prediction)
+                incorrect += measures["substitutions"] + measures["deletions"] + measures["insertions"]
+                total += measures["substitutions"] + measures["deletions"] + measures["hits"]
+            return incorrect / total

model-bin/pretrained/base/config.json

@@ -0,0 +1,78 @@
+{
+  "_name_or_path": "nguyenvulebinh/wav2vec2_vi",
+  "activation_dropout": 0.1,
+  "apply_spec_augment": true,
+  "architectures": [
+    "Wav2Vec2ForPreTraining"
+  ],
+  "attention_dropout": 0.1,
+  "bos_token_id": 1,
+  "codevector_dim": 256,
+  "contrastive_logits_temperature": 0.1,
+  "conv_bias": false,
+  "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": "sum",
+  "ctc_zero_infinity": false,
+  "diversity_loss_weight": 0.1,
+  "do_stable_layer_norm": false,
+  "eos_token_id": 2,
+  "feat_extract_activation": "gelu",
+  "feat_extract_dropout": 0.0,
+  "feat_extract_norm": "group",
+  "feat_proj_dropout": 0.1,
+  "feat_quantizer_dropout": 0.0,
+  "final_dropout": 0.1,
+  "gradient_checkpointing": false,
+  "hidden_act": "gelu",
+  "hidden_dropout": 0.1,
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 768,
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "layer_norm_eps": 1e-05,
+  "layerdrop": 0.1,
+  "mask_feature_length": 10,
+  "mask_feature_prob": 0.0,
+  "mask_time_length": 10,
+  "mask_time_prob": 0.05,
+  "model_type": "wav2vec2",
+  "num_attention_heads": 12,
+  "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": 12,
+  "num_negatives": 100,
+  "pad_token_id": 0,
+  "proj_codevector_dim": 256,
+  "torch_dtype": "float32",
+  "transformers_version": "4.9.1",
+  "vocab_size": 110
+}

model-bin/pretrained/base/preprocessor_config.json

@@ -0,0 +1,8 @@
+{
+  "do_normalize": true,
+  "feature_size": 1,
+  "padding_side": "right",
+  "padding_value": 0.0,
+  "return_attention_mask": false,
+  "sampling_rate": 16000
+}

model-bin/pretrained/base/pytorch_model.bin

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

requirments.txt

@@ -0,0 +1,6 @@
+soundfile
+transformers==4.9.2
+torch==1.9.0
+datasets==1.11.0
+jiwer
+tensorboard