Upload folder using huggingface_hub

.gitattributes

@@ -57,3 +57,45 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/CV_1.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/CV_10.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/CV_11.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/CV_2.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/CV_3.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/CV_4.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/CV_5.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/CV_6.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/CV_7.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/CV_8.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/CV_9.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_1.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_10.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_11.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_12.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_13.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_14.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_15.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_16.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_17.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_18.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_19.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_2.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_20.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_3.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_4.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_5.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_6.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_7.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_8.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_9.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/VL_12.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/VL_13.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/VL_15.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/VL_16.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/VL_2.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/VL_8.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/VP_2.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/manifest/samromur.tsv filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/mHuBERT-147/mhubert147_faiss.index filter=lfs diff=lfs merge=lfs -text
+ACE_checkpoints_3.5B/umt5-base/tokenizer.json filter=lfs diff=lfs merge=lfs -text

ACE_checkpoints_3.5B/.gitattributes

@@ -0,0 +1,36 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+umt5-base/tokenizer.json filter=lfs diff=lfs merge=lfs -text

ACE_checkpoints_3.5B/MERT-v1-330M/.gitattributes

@@ -0,0 +1,34 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

ACE_checkpoints_3.5B/MERT-v1-330M/MERT-v1-330M_fairseq.pt

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

ACE_checkpoints_3.5B/MERT-v1-330M/README.md

@@ -0,0 +1,124 @@
+---
+license: cc-by-nc-4.0
+inference: false
+tags:
+- music
+pipeline_tag: audio-classification
+---
+
+# Introduction to our series work
+
+The development log of our Music Audio Pre-training (m-a-p) model family:
+- 02/06/2023: [arxiv pre-print](https://arxiv.org/abs/2306.00107) and training [codes](https://github.com/yizhilll/MERT) released.
+- 17/03/2023: we release two advanced music understanding models, [MERT-v1-95M](https://huggingface.co/m-a-p/MERT-v1-95M) and [MERT-v1-330M](https://huggingface.co/m-a-p/MERT-v1-330M) , trained with new paradigm and dataset. They outperform the previous models and can better generalize to more tasks.
+- 14/03/2023: we retrained the MERT-v0 model with open-source-only music dataset [MERT-v0-public](https://huggingface.co/m-a-p/MERT-v0-public)
+- 29/12/2022: a music understanding model [MERT-v0](https://huggingface.co/m-a-p/MERT-v0) trained with **MLM** paradigm, which performs better at downstream tasks.
+- 29/10/2022: a pre-trained MIR model [music2vec](https://huggingface.co/m-a-p/music2vec-v1) trained with **BYOL** paradigm.
+
+
+
+Here is a table for quick model pick-up:
+
+| Name                                                         | Pre-train Paradigm | Training Data (hour) | Pre-train Context   (second) | Model Size | Transformer Layer-Dimension | Feature Rate | Sample Rate | Release Date |
+| ------------------------------------------------------------ | ------------------ | -------------------- | ---------------------------- | ---------- | --------------------------- | ------------ | ----------- | ------------ |
+| [MERT-v1-330M](https://huggingface.co/m-a-p/MERT-v1-330M)    | MLM                | 160K                 | 5                            | 330M       | 24-1024                     | 75 Hz        | 24K Hz      | 17/03/2023   |
+| [MERT-v1-95M](https://huggingface.co/m-a-p/MERT-v1-95M)      | MLM                | 20K                  | 5                            | 95M        | 12-768                      | 75 Hz        | 24K Hz      | 17/03/2023   |
+| [MERT-v0-public](https://huggingface.co/m-a-p/MERT-v0-public) | MLM                | 900                  | 5                            | 95M        | 12-768                      | 50 Hz        | 16K Hz      | 14/03/2023   |
+| [MERT-v0](https://huggingface.co/m-a-p/MERT-v0)              | MLM                | 1000                 | 5                            | 95 M       | 12-768                      | 50 Hz        | 16K Hz      | 29/12/2022   |
+| [music2vec-v1](https://huggingface.co/m-a-p/music2vec-v1)    | BYOL               | 1000                 | 30                           | 95 M       | 12-768                      | 50 Hz        | 16K Hz      | 30/10/2022   |
+
+## Explanation
+
+The m-a-p models share the similar model architecture and the most distinguished difference is the paradigm in used pre-training. Other than that, there are several nuance technical configuration needs to know before using:
+
+- **Model Size**: the number of parameters that would be loaded to memory. Please select the appropriate size fitting your hardware.
+- **Transformer Layer-Dimension**: The number of transformer layers and the corresponding feature dimensions can be outputted from our model. This is marked out because features extracted by **different layers could have various performance depending on tasks**.
+- **Feature Rate**: Given a 1-second audio input, the number of features output by the model.
+- **Sample Rate**: The frequency of audio that the model is trained with.
+
+
+
+# Introduction to MERT-v1
+
+Compared to MERT-v0, we introduce multiple new things in the MERT-v1 pre-training:
+
+- Change the pseudo labels to 8 codebooks from [encodec](https://github.com/facebookresearch/encodec), which potentially has higher quality and empower our model to support music generation.
+- MLM prediction with in-batch noise mixture.
+- Train with higher audio frequency (24K Hz).
+- Train with more audio data (up to 160 thousands of hours).
+- More available model sizes 95M and 330M.
+
+
+
+More details will be written in our coming-soon paper.
+
+
+
+# Model Usage
+
+```python
+# from transformers import Wav2Vec2Processor
+from transformers import Wav2Vec2FeatureExtractor
+from transformers import AutoModel
+import torch
+from torch import nn
+import torchaudio.transforms as T
+from datasets import load_dataset
+
+# loading our model weights
+model = AutoModel.from_pretrained("m-a-p/MERT-v1-330M", trust_remote_code=True)
+# loading the corresponding preprocessor config
+processor = Wav2Vec2FeatureExtractor.from_pretrained("m-a-p/MERT-v1-330M",trust_remote_code=True)
+
+# load demo audio and set processor
+dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
+dataset = dataset.sort("id")
+sampling_rate = dataset.features["audio"].sampling_rate
+
+resample_rate = processor.sampling_rate
+# make sure the sample_rate aligned
+if resample_rate != sampling_rate:
+    print(f'setting rate from {sampling_rate} to {resample_rate}')
+    resampler = T.Resample(sampling_rate, resample_rate)
+else:
+    resampler = None
+
+# audio file is decoded on the fly
+if resampler is None:
+	input_audio = dataset[0]["audio"]["array"]
+else:
+  input_audio = resampler(torch.from_numpy(dataset[0]["audio"]["array"]))
+  
+inputs = processor(input_audio, sampling_rate=resample_rate, return_tensors="pt")
+with torch.no_grad():
+    outputs = model(**inputs, output_hidden_states=True)
+
+# take a look at the output shape, there are 25 layers of representation
+# each layer performs differently in different downstream tasks, you should choose empirically
+all_layer_hidden_states = torch.stack(outputs.hidden_states).squeeze()
+print(all_layer_hidden_states.shape) # [25 layer, Time steps, 1024 feature_dim]
+
+# for utterance level classification tasks, you can simply reduce the representation in time
+time_reduced_hidden_states = all_layer_hidden_states.mean(-2)
+print(time_reduced_hidden_states.shape) # [25, 1024]
+
+# you can even use a learnable weighted average representation
+aggregator = nn.Conv1d(in_channels=25, out_channels=1, kernel_size=1)
+weighted_avg_hidden_states = aggregator(time_reduced_hidden_states.unsqueeze(0)).squeeze()
+print(weighted_avg_hidden_states.shape) # [1024]
+```
+
+
+
+# Citation
+
+```shell
+@misc{li2023mert,
+      title={MERT: Acoustic Music Understanding Model with Large-Scale Self-supervised Training}, 
+      author={Yizhi Li and Ruibin Yuan and Ge Zhang and Yinghao Ma and Xingran Chen and Hanzhi Yin and Chenghua Lin and Anton Ragni and Emmanouil Benetos and Norbert Gyenge and Roger Dannenberg and Ruibo Liu and Wenhu Chen and Gus Xia and Yemin Shi and Wenhao Huang and Yike Guo and Jie Fu},
+      year={2023},
+      eprint={2306.00107},
+      archivePrefix={arXiv},
+      primaryClass={cs.SD}
+}
+```

ACE_checkpoints_3.5B/MERT-v1-330M/config.json

@@ -0,0 +1,92 @@
+{
+  "_name_or_path": "m-a-p/MERT-v1-330M",
+  "activation_dropout": 0.0,
+  "apply_spec_augment": true,
+  "architectures": [
+    "MERTModel"
+  ],
+  "attention_dropout": 0.0,
+  "attention_relax": 32.0,
+  "auto_map": {
+    "AutoConfig": "configuration_MERT.MERTConfig",
+    "AutoModel": "modeling_MERT.MERTModel"
+  },
+  "bos_token_id": 1,
+  "classifier_proj_size": 256,
+  "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,
+  "deepnorm": false,
+  "do_stable_layer_norm": true,
+  "eos_token_id": 2,
+  "feat_extract_activation": "gelu",
+  "feat_extract_dropout": 0.0,
+  "feat_extract_norm": "group",
+  "feat_proj_dropout": 0.0,
+  "feat_proj_layer_norm": true,
+  "feature_extractor_cqt": false,
+  "feature_extractor_cqt_bins": 336,
+  "final_dropout": 0.0,
+  "gradient_checkpointing": false,
+  "hidden_act": "gelu",
+  "hidden_dropout": 0.0,
+  "hidden_size": 1024,
+  "initializer_range": 0.02,
+  "intermediate_size": 4096,
+  "layer_norm_eps": 1e-05,
+  "layerdrop": 0.0,
+  "mask_channel_length": 10,
+  "mask_channel_min_space": 1,
+  "mask_channel_other": 0.0,
+  "mask_channel_prob": 0.0,
+  "mask_channel_selection": "static",
+  "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_min_space": 1,
+  "mask_time_other": 0.0,
+  "mask_time_prob": 0.075,
+  "mask_time_selection": "static",
+  "model_type": "mert_model",
+  "num_attention_heads": 16,
+  "num_conv_pos_embedding_groups": 16,
+  "num_conv_pos_embeddings": 128,
+  "num_feat_extract_layers": 7,
+  "num_hidden_layers": 24,
+  "pad_token_id": 0,
+  "sample_rate": 24000,
+  "tokenizer_class": "Wav2Vec2CTCTokenizer",
+  "torch_dtype": "float32",
+  "transformers_version": "4.27.1",
+  "use_weighted_layer_sum": false,
+  "vocab_size": 32
+}

ACE_checkpoints_3.5B/MERT-v1-330M/configuration_MERT.py

@@ -0,0 +1,141 @@
+"""
+MERT model configuration
+"""
+
+import functools
+import operator
+
+# from ...configuration_utils import PretrainedConfig
+# from ...utils import logging
+from transformers.configuration_utils import PretrainedConfig
+from transformers.utils import logging
+
+logger = logging.get_logger(__name__)
+
+# TODO: use this MAP while uploading to Huggingface
+# HUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP = {
+#     "facebook/hubert-base-ls960": "https://huggingface.co/facebook/hubert-base-ls960/resolve/main/config.json",
+#     # See all Hubert models at https://huggingface.co/models?filter=hubert
+# }
+
+
+class MERTConfig(PretrainedConfig):
+    r"""
+    """
+    model_type = "mert_model"
+
+    def __init__(
+        self,
+        vocab_size=32,
+        hidden_size=768,
+        num_hidden_layers=12,
+        num_attention_heads=12,
+        intermediate_size=3072,
+        hidden_act="gelu",
+        hidden_dropout=0.1,
+        activation_dropout=0.1,
+        attention_dropout=0.1,
+        feat_proj_layer_norm=True,
+        feat_proj_dropout=0.0,
+        final_dropout=0.1,
+        layerdrop=0.1,
+        initializer_range=0.02,
+        layer_norm_eps=1e-5,
+        feat_extract_norm="group",
+        feat_extract_activation="gelu",
+        conv_dim=(512, 512, 512, 512, 512, 512, 512),
+        conv_stride=(5, 2, 2, 2, 2, 2, 2),
+        conv_kernel=(10, 3, 3, 3, 3, 2, 2),
+        conv_bias=False,
+        num_conv_pos_embeddings=128,
+        num_conv_pos_embedding_groups=16,
+        do_stable_layer_norm=False,
+        apply_spec_augment=True,
+        mask_time_prob=0.05,
+        mask_time_length=10,
+        mask_time_min_masks=2,
+        mask_feature_prob=0.0,
+        mask_feature_length=10,
+        mask_feature_min_masks=0,
+        ctc_loss_reduction="sum",
+        ctc_zero_infinity=False,
+        use_weighted_layer_sum=False,
+        classifier_proj_size=256,
+        pad_token_id=0,
+        bos_token_id=1,
+        eos_token_id=2,
+        feature_extractor_cqt=False,
+        feature_extractor_cqt_bins=336,
+        deepnorm=False,
+        attention_relax=-1.0,
+        **kwargs
+    ):
+        super().__init__(**kwargs, pad_token_id=pad_token_id, bos_token_id=bos_token_id, eos_token_id=eos_token_id)
+        self.hidden_size = hidden_size
+        self.feat_extract_norm = feat_extract_norm
+        self.feat_extract_activation = feat_extract_activation
+        self.conv_dim = list(conv_dim)
+        self.conv_stride = list(conv_stride)
+        self.conv_kernel = list(conv_kernel)
+        self.conv_bias = conv_bias
+        self.num_conv_pos_embeddings = num_conv_pos_embeddings
+        self.num_conv_pos_embedding_groups = num_conv_pos_embedding_groups
+        self.num_feat_extract_layers = len(self.conv_dim)
+        self.num_hidden_layers = num_hidden_layers
+        self.intermediate_size = intermediate_size
+        self.hidden_act = hidden_act
+        self.num_attention_heads = num_attention_heads
+        self.hidden_dropout = hidden_dropout
+        self.attention_dropout = attention_dropout
+        self.activation_dropout = activation_dropout
+        self.feat_proj_layer_norm = feat_proj_layer_norm
+        self.feat_proj_dropout = feat_proj_dropout
+        self.final_dropout = final_dropout
+        self.layerdrop = layerdrop
+        self.layer_norm_eps = layer_norm_eps
+        self.initializer_range = initializer_range
+        self.vocab_size = vocab_size
+        self.do_stable_layer_norm = do_stable_layer_norm
+        self.use_weighted_layer_sum = use_weighted_layer_sum
+        self.classifier_proj_size = classifier_proj_size
+
+        if (
+            (len(self.conv_stride) != self.num_feat_extract_layers)
+            or (len(self.conv_kernel) != self.num_feat_extract_layers)
+            or (len(self.conv_dim) != self.num_feat_extract_layers)
+        ):
+            raise ValueError(
+                "Configuration for convolutional layers is incorrect. It is required that `len(config.conv_dim)` =="
+                " `len(config.conv_stride)` == `len(config.conv_kernel)`, but is `len(config.conv_dim) ="
+                f" {len(self.conv_dim)}`, `len(config.conv_stride) = {len(self.conv_stride)}`,"
+                f" `len(config.conv_kernel) = {len(self.conv_kernel)}`."
+            )
+
+        # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
+        self.apply_spec_augment = apply_spec_augment
+        self.mask_time_prob = mask_time_prob
+        self.mask_time_length = mask_time_length
+        self.mask_time_min_masks = mask_time_min_masks
+        self.mask_feature_prob = mask_feature_prob
+        self.mask_feature_length = mask_feature_length
+        self.mask_feature_min_masks = mask_feature_min_masks
+
+        # ctc loss
+        self.ctc_loss_reduction = ctc_loss_reduction
+        self.ctc_zero_infinity = ctc_zero_infinity
+
+        # cqt feature extractor
+        self.feature_extractor_cqt = feature_extractor_cqt
+        self.feature_extractor_cqt_bins = feature_extractor_cqt_bins
+
+        # deepnorm: up-scale weighted residual conection + down-scale initial value transformer encoder
+        self.deepnorm = deepnorm
+
+        self.attention_relax = attention_relax
+
+        # fix bug with hf > 4.42
+        self.conv_pos_batch_norm = False
+
+    @property
+    def inputs_to_logits_ratio(self):
+        return functools.reduce(operator.mul, self.conv_stride, 1)

ACE_checkpoints_3.5B/MERT-v1-330M/modeling_MERT.py

@@ -0,0 +1,409 @@
+"""
+MERT model definition.
+We largely adapt codes from:
+1. https://github.com/huggingface/transformers/blob/main/src/transformers/models/hubert/modeling_hubert.py
+2. https://github.com/facebookresearch/fairseq/blob/main/fairseq/models/wav2vec/wav2vec2.py
+"""
+
+from typing import Optional, Tuple, Union
+from transformers.modeling_outputs import BaseModelOutput
+import torch
+from torch import nn
+
+from transformers.models.hubert.modeling_hubert import (
+    HubertFeatureEncoder,
+    HubertModel,
+    HubertEncoderStableLayerNorm,
+    HubertEncoder,
+    HubertEncoderLayer,
+    HubertPositionalConvEmbedding,
+    HubertAttention,
+    HubertFeedForward,
+)
+
+try:
+    from nnAudio import features as nnAudioFeatures
+    NNAUDIO_INSTALLED=True
+except:
+    print("WARNING: feature_extractor_cqt requires the libray 'nnAudio'")
+    NNAUDIO_INSTALLED=False
+
+from .configuration_MERT import MERTConfig
+
+class MERTFeatureProjection(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.feat_proj_layer_norm = config.feat_proj_layer_norm
+        self.feature_extractor_cqt = config.feature_extractor_cqt
+
+        if self.feature_extractor_cqt:
+            # v3 concat features
+            self.feature_dimension = config.conv_dim[-1] + config.feature_extractor_cqt_bins
+            print(f"feature dimention: {self.feature_dimension}")
+        else:
+            self.feature_dimension = config.conv_dim[-1]
+        if self.feat_proj_layer_norm:
+            self.layer_norm = nn.LayerNorm(self.feature_dimension, eps=config.layer_norm_eps)
+        self.projection = nn.Linear(self.feature_dimension, config.hidden_size)
+        self.dropout = nn.Dropout(config.feat_proj_dropout)
+
+    def forward(self, hidden_states):
+        # non-projected hidden states are needed for quantization
+        if self.feat_proj_layer_norm:
+            hidden_states = self.layer_norm(hidden_states)
+        hidden_states = self.projection(hidden_states)
+        hidden_states = self.dropout(hidden_states)
+        return hidden_states
+
+class MERTModel(HubertModel):
+    # overwrite config class
+    config_class = MERTConfig
+    base_model_prefix = "mert_model"
+    def __init__(
+        self,
+        config: MERTConfig,
+    ) -> None:
+        """ 
+        initialize the with the grandparent method HubertPreTrainedModel.__init__()
+        and modify the HuBERTModel.__init__()
+        """
+        super(HubertModel, self).__init__(config)
+
+        self.config = config
+
+        self.feature_extractor = HubertFeatureEncoder(config)
+        self.feature_projection = MERTFeatureProjection(config) # replace Feature Projection for introcuing new feature
+
+        if self.config.feature_extractor_cqt:
+            assert NNAUDIO_INSTALLED, "ERROR: feature_extractor_cqt requires the libray 'nnAudio', try after `pip install nnAudio` "
+            print('initializing cqt extractor for MERT')            
+            self.feature_extractor_cqt = nnAudioFeatures.cqt.CQT(sr=self.config.sample_rate, hop_length=self.config.sample_rate//50, fmin=32.7, 
+                    fmax=None, n_bins=self.config.feature_extractor_cqt_bins, bins_per_octave=self.config.feature_extractor_cqt_bins//7, 
+                    filter_scale=1, norm=1, window='hann', center=True, 
+                    pad_mode='constant', trainable=False, 
+                    output_format='Magnitude', verbose=True)
+
+        if config.mask_time_prob > 0.0 or config.mask_feature_prob > 0.0:
+            self.masked_spec_embed = nn.Parameter(torch.FloatTensor(config.hidden_size).uniform_())
+
+        
+        if config.do_stable_layer_norm:
+            assert not config.deepnorm, "must use post-layer_norm with deepnorm"
+            self.encoder = HubertEncoderStableLayerNorm(config)
+        else:
+            if config.deepnorm:
+                self.encoder = HubertEncoder_extend(config)
+            else:
+                self.encoder = HubertEncoder(config)
+
+        # Initialize weights and apply final processing
+        self.post_init()
+    
+    def forward(self, input_values: Optional[torch.Tensor], attention_mask: Optional[torch.Tensor] = None, mask_time_indices: Optional[torch.FloatTensor] = None, output_attentions: Optional[bool] = None, output_hidden_states: Optional[bool] = None, return_dict: Optional[bool] = None) -> Union[Tuple, BaseModelOutput]:
+        
+        # return super().forward(input_values, attention_mask, mask_time_indices, output_attentions, output_hidden_states, return_dict)
+        
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        output_hidden_states = (
+            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        )
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        extract_features = self.feature_extractor(input_values)
+        extract_features = extract_features.transpose(1, 2)
+
+        # add additional cqt features for transformer input
+        if self.config.feature_extractor_cqt:
+            features_cqt = self.feature_extractor_cqt(input_values).transpose(1, 2)
+            features_cqt = features_cqt[:,:extract_features.shape[1],:] # align shape
+            # # v2
+            # features_cqt = self.post_cqt_feature_proj(features_cqt)
+            # extract_features = self.feature_projection.layer_norm(extract_features) + self.feature_projection.layer_norm(features_cqt) #v2
+            # v3
+            extract_features = torch.cat([extract_features,features_cqt], 2)
+
+        if attention_mask is not None:
+            # compute reduced attention_mask corresponding to feature vectors
+            attention_mask = self._get_feature_vector_attention_mask(extract_features.shape[1], attention_mask)
+
+        hidden_states = self.feature_projection(extract_features)
+        hidden_states = self._mask_hidden_states(hidden_states, mask_time_indices=mask_time_indices)
+
+        encoder_outputs = self.encoder(
+            hidden_states,
+            attention_mask=attention_mask,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+
+        hidden_states = encoder_outputs[0] # take last_hidden from encoder output
+
+        if not return_dict:
+            return (hidden_states,) + encoder_outputs[1:]
+
+        return BaseModelOutput(
+            last_hidden_state=hidden_states,
+            hidden_states=encoder_outputs.hidden_states,
+            attentions=encoder_outputs.attentions,
+        )
+
+
+class HubertEncoder_extend(HubertEncoder):
+    def __init__(self, config):
+        # super().__init__()
+        # call nn module initialization
+        nn.Module.__init__(self)
+        # super(HubertEncoder_extend, self).__init__()
+
+        self.config = config
+        self.pos_conv_embed = HubertPositionalConvEmbedding(config)
+        self.layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.dropout = nn.Dropout(config.hidden_dropout)
+
+        
+        self.layers = nn.ModuleList([HubertEncoderLayerExtend(config) for _ in range(config.num_hidden_layers)])
+
+        self.gradient_checkpointing = False
+
+        if config.deepnorm:
+            import math
+            init_scale = math.pow(8.0 * config.num_hidden_layers, 0.25)
+            for name, p in self.named_parameters():
+                if (
+                    "feed_forward.intermediate_dense" in name
+                    or "feed_forward.output_dense" in name
+                    or "out_proj" in name
+                    or "v_proj" in name
+                ):
+                    p.data.div_(init_scale)
+
+class HubertEncoderLayerExtend(HubertEncoderLayer):
+    def __init__(self, config):
+        nn.Module.__init__(self)
+        # super(HubertEncoderLayerExtend, self).__init__()
+        if config.attention_relax > 0 :
+            self.attention = HubertAttention_extend(
+                embed_dim=config.hidden_size,
+                num_heads=config.num_attention_heads,
+                dropout=config.attention_dropout,
+                is_decoder=False,
+                attention_relax=config.attention_relax,
+            )
+        else:    
+            self.attention = HubertAttention(
+                embed_dim=config.hidden_size,
+                num_heads=config.num_attention_heads,
+                dropout=config.attention_dropout,
+                is_decoder=False,
+            )
+        self.dropout = nn.Dropout(config.hidden_dropout)
+        self.layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.feed_forward = HubertFeedForward(config)
+        self.final_layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+
+        if config.deepnorm:
+            import math
+            self.residual_alpha = math.pow(2.0 * config.num_hidden_layers, 0.25)
+        else:
+            self.residual_alpha = 1.0
+    
+    def residual_connection(self, x, residual):
+        '''
+        residual: input before f()
+        x: output of f(residual)
+        '''
+        return residual * self.residual_alpha + x
+
+    def forward(self, hidden_states, attention_mask=None, output_attentions=False):
+        attn_residual = hidden_states
+        hidden_states, attn_weights, _ = self.attention(
+            hidden_states, attention_mask=attention_mask, output_attentions=output_attentions
+        )
+        hidden_states = self.dropout(hidden_states)
+
+        # hidden_states = attn_residual + hidden_states
+        hidden_states = self.residual_connection(hidden_states, attn_residual)
+
+        hidden_states = self.layer_norm(hidden_states)
+
+        # hidden_states = hidden_states + self.feed_forward(hidden_states)
+        ffn_residual = hidden_states
+        hidden_states = self.feed_forward(hidden_states)
+        hidden_states = self.residual_connection(hidden_states, ffn_residual)
+
+        hidden_states = self.final_layer_norm(hidden_states)
+
+        outputs = (hidden_states,)
+
+        if output_attentions:
+            outputs += (attn_weights,)
+
+        return outputs
+
+
+class HubertAttention_extend(nn.Module):
+    def __init__(
+        self,
+        embed_dim: int,
+        num_heads: int,
+        dropout: float = 0.0,
+        is_decoder: bool = False,
+        bias: bool = True,
+        attention_relax: float = -1.0,
+    ):
+        super().__init__()
+        # nn.Module.__init__(self)
+        self.embed_dim = embed_dim
+        self.num_heads = num_heads
+        self.dropout = dropout
+        self.head_dim = embed_dim // num_heads
+
+        if (self.head_dim * num_heads) != self.embed_dim:
+            raise ValueError(
+                f"embed_dim must be divisible by num_heads (got `embed_dim`: {self.embed_dim}"
+                f" and `num_heads`: {num_heads})."
+            )
+        self.scaling = self.head_dim**-0.5
+        self.is_decoder = is_decoder
+
+        self.k_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+        self.v_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+        self.q_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+        self.out_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+
+        if attention_relax > 0:
+            self.attention_relax = attention_relax
+
+    def _shape(self, tensor: torch.Tensor, seq_len: int, bsz: int):
+        return tensor.view(bsz, seq_len, self.num_heads, self.head_dim).transpose(1, 2).contiguous()
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        key_value_states: Optional[torch.Tensor] = None,
+        past_key_value: Optional[Tuple[torch.Tensor]] = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        layer_head_mask: Optional[torch.Tensor] = None,
+        output_attentions: bool = False,
+    ) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[Tuple[torch.Tensor]]]:
+        """Input shape: Batch x Time x Channel"""
+
+        # if key_value_states are provided this layer is used as a cross-attention layer
+        # for the decoder
+        is_cross_attention = key_value_states is not None
+
+        bsz, tgt_len, _ = hidden_states.size()
+
+        # get query proj
+        query_states = self.q_proj(hidden_states) * self.scaling
+        # get key, value proj
+        # `past_key_value[0].shape[2] == key_value_states.shape[1]`
+        # is checking that the `sequence_length` of the `past_key_value` is the same as
+        # the provided `key_value_states` to support prefix tuning
+        if (
+            is_cross_attention
+            and past_key_value is not None
+            and past_key_value[0].shape[2] == key_value_states.shape[1]
+        ):
+            # reuse k,v, cross_attentions
+            key_states = past_key_value[0]
+            value_states = past_key_value[1]
+        elif is_cross_attention:
+            # cross_attentions
+            key_states = self._shape(self.k_proj(key_value_states), -1, bsz)
+            value_states = self._shape(self.v_proj(key_value_states), -1, bsz)
+        elif past_key_value is not None:
+            # reuse k, v, self_attention
+            key_states = self._shape(self.k_proj(hidden_states), -1, bsz)
+            value_states = self._shape(self.v_proj(hidden_states), -1, bsz)
+            key_states = torch.cat([past_key_value[0], key_states], dim=2)
+            value_states = torch.cat([past_key_value[1], value_states], dim=2)
+        else:
+            # self_attention
+            key_states = self._shape(self.k_proj(hidden_states), -1, bsz)
+            value_states = self._shape(self.v_proj(hidden_states), -1, bsz)
+
+        if self.is_decoder:
+            # if cross_attention save Tuple(torch.Tensor, torch.Tensor) of all cross attention key/value_states.
+            # Further calls to cross_attention layer can then reuse all cross-attention
+            # key/value_states (first "if" case)
+            # if uni-directional self-attention (decoder) save Tuple(torch.Tensor, torch.Tensor) of
+            # all previous decoder key/value_states. Further calls to uni-directional self-attention
+            # can concat previous decoder key/value_states to current projected key/value_states (third "elif" case)
+            # if encoder bi-directional self-attention `past_key_value` is always `None`
+            past_key_value = (key_states, value_states)
+
+        proj_shape = (bsz * self.num_heads, -1, self.head_dim)
+        query_states = self._shape(query_states, tgt_len, bsz).view(*proj_shape)
+        key_states = key_states.view(*proj_shape)
+        value_states = value_states.view(*proj_shape)
+
+        src_len = key_states.size(1)
+        attn_weights = torch.bmm(query_states, key_states.transpose(1, 2))
+
+        if attn_weights.size() != (bsz * self.num_heads, tgt_len, src_len):
+            raise ValueError(
+                f"Attention weights should be of size {(bsz * self.num_heads, tgt_len, src_len)}, but is"
+                f" {attn_weights.size()}"
+            )
+
+        if attention_mask is not None:
+            if attention_mask.size() != (bsz, 1, tgt_len, src_len):
+                raise ValueError(
+                    f"Attention mask should be of size {(bsz, 1, tgt_len, src_len)}, but is {attention_mask.size()}"
+                )
+            attn_weights = attn_weights.view(bsz, self.num_heads, tgt_len, src_len) + attention_mask
+            attn_weights = attn_weights.view(bsz * self.num_heads, tgt_len, src_len)
+
+        if self.attention_relax > 0:
+            # => (bsz, self.num_heads, tgt_len, src_len)
+            # attn_weights_relax = attn_weights.view(bsz, self.num_heads, tgt_len, src_len)/self.attention_relax
+            # => (bsz*self.num_heads, tgt_len, src_len)
+            attn_weights_relax = attn_weights / self.attention_relax
+
+            # => (bsz* self.num_heads, tgt_len, 1)
+            attn_max_relax = torch.max(attn_weights_relax, dim=-1, keepdim=False).unsqueeze(2)
+            attn_weights = (attn_weights_relax - attn_max_relax) * self.attention_relax
+
+        attn_weights = nn.functional.softmax(attn_weights, dim=-1)
+
+        if layer_head_mask is not None:
+            if layer_head_mask.size() != (self.num_heads,):
+                raise ValueError(
+                    f"Head mask for a single layer should be of size {(self.num_heads,)}, but is"
+                    f" {layer_head_mask.size()}"
+                )
+            attn_weights = layer_head_mask.view(1, -1, 1, 1) * attn_weights.view(bsz, self.num_heads, tgt_len, src_len)
+            attn_weights = attn_weights.view(bsz * self.num_heads, tgt_len, src_len)
+
+        if output_attentions:
+            # this operation is a bit awkward, but it's required to
+            # make sure that attn_weights keeps its gradient.
+            # In order to do so, attn_weights have to be reshaped
+            # twice and have to be reused in the following
+            attn_weights_reshaped = attn_weights.view(bsz, self.num_heads, tgt_len, src_len)
+            attn_weights = attn_weights_reshaped.view(bsz * self.num_heads, tgt_len, src_len)
+        else:
+            attn_weights_reshaped = None
+
+        attn_probs = nn.functional.dropout(attn_weights, p=self.dropout, training=self.training)
+
+        attn_output = torch.bmm(attn_probs, value_states)
+
+        if attn_output.size() != (bsz * self.num_heads, tgt_len, self.head_dim):
+            raise ValueError(
+                f"`attn_output` should be of size {(bsz, self.num_heads, tgt_len, self.head_dim)}, but is"
+                f" {attn_output.size()}"
+            )
+
+        attn_output = attn_output.view(bsz, self.num_heads, tgt_len, self.head_dim)
+        attn_output = attn_output.transpose(1, 2)
+
+        # Use the `embed_dim` from the config (stored in the class) rather than `hidden_state` because `attn_output` can be
+        # partitioned aross GPUs when using tensor-parallelism.
+        attn_output = attn_output.reshape(bsz, tgt_len, self.embed_dim)
+
+        attn_output = self.out_proj(attn_output)
+
+        return attn_output, attn_weights_reshaped, past_key_value

ACE_checkpoints_3.5B/MERT-v1-330M/preprocessor_config.json

@@ -0,0 +1,9 @@
+{
+  "do_normalize": false,
+  "feature_extractor_type": "Wav2Vec2FeatureExtractor",
+  "feature_size": 1,
+  "padding_side": "right",
+  "padding_value": 0,
+  "return_attention_mask": true,
+  "sampling_rate": 24000
+}

ACE_checkpoints_3.5B/MERT-v1-330M/pytorch_model.bin

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

ACE_checkpoints_3.5B/README.md

@@ -0,0 +1,122 @@
+---
+license: apache-2.0
+tags:
+- music
+- text2music
+- acestep
+pipeline_tag: text-to-audio
+language:
+- en
+- zh
+- de
+- fr
+- es
+- it
+- pt
+- pl
+- tr
+- ru
+- cs
+- nl
+- ar
+- ja
+- hu
+- ko
+- hi
+---
+
+# ACE-Step: A Step Towards Music Generation Foundation Model
+
+![ACE-Step Framework](https://github.com/ACE-Step/ACE-Step/raw/main/assets/ACE-Step_framework.png)
+
+## Model Description
+
+ACE-Step is a novel open-source foundation model for music generation that overcomes key limitations of existing approaches through a holistic architectural design. It integrates diffusion-based generation with Sana's Deep Compression AutoEncoder (DCAE) and a lightweight linear transformer, achieving state-of-the-art performance in generation speed, musical coherence, and controllability.
+
+**Key Features:**
+- 15× faster than LLM-based baselines (20s for 4-minute music on A100)
+- Superior musical coherence across melody, harmony, and rhythm
+- full-song generation, duration control and accepts natural language descriptions
+
+## Uses
+
+### Direct Use
+ACE-Step can be used for:
+- Generating original music from text descriptions
+- Music remixing and style transfer
+- edit song lyrics
+
+### Downstream Use
+The model serves as a foundation for:
+- Voice cloning applications
+- Specialized music generation (rap, jazz, etc.)
+- Music production tools
+- Creative AI assistants
+
+### Out-of-Scope Use
+The model should not be used for:
+- Generating copyrighted content without permission
+- Creating harmful or offensive content
+- Misrepresenting AI-generated music as human-created
+
+## How to Get Started
+
+see: https://github.com/ace-step/ACE-Step
+
+## Hardware Performance
+
+| Device        | 27 Steps | 60 Steps |
+|---------------|----------|----------|
+| NVIDIA A100   | 27.27x   | 12.27x   |
+| RTX 4090      | 34.48x   | 15.63x   |
+| RTX 3090      | 12.76x   | 6.48x    |
+| M2 Max        | 2.27x    | 1.03x    |
+
+*RTF (Real-Time Factor) shown - higher values indicate faster generation*
+
+
+## Limitations
+
+- Performance varies by language (top 10 languages perform best)
+- Longer generations (>5 minutes) may lose structural coherence
+- Rare instruments may not render perfectly
+- Output Inconsistency: Highly sensitive to random seeds and input duration, leading to varied "gacha-style" results.
+- Style-specific Weaknesses: Underperforms on certain genres (e.g. Chinese rap/zh_rap) Limited style adherence and musicality ceiling
+- Continuity Artifacts: Unnatural transitions in repainting/extend operations
+- Vocal Quality: Coarse vocal synthesis lacking nuance
+- Control Granularity: Needs finer-grained musical parameter control
+
+## Ethical Considerations
+
+Users should:
+- Verify originality of generated works
+- Disclose AI involvement
+- Respect cultural elements and copyrights
+- Avoid harmful content generation
+
+
+## Model Details
+
+**Developed by:** ACE Studio and StepFun  
+**Model type:** Diffusion-based music generation with transformer conditioning  
+**License:** Apache 2.0  
+**Resources:**  
+- [Project Page](https://ace-step.github.io/)
+- [Demo Space](https://huggingface.co/spaces/ACE-Step/ACE-Step)
+- [GitHub Repository](https://github.com/ACE-Step/ACE-Step)
+
+
+## Citation
+
+```bibtex
+@misc{gong2025acestep,
+  title={ACE-Step: A Step Towards Music Generation Foundation Model},
+  author={Junmin Gong, Wenxiao Zhao, Sen Wang, Shengyuan Xu, Jing Guo}, 
+  howpublished={\url{https://github.com/ace-step/ACE-Step}},
+  year={2025},
+  note={GitHub repository}
+}
+```
+
+## Acknowledgements
+This project is co-led by ACE Studio and StepFun.

ACE_checkpoints_3.5B/config.json

@@ -0,0 +1,35 @@
+{
+  "_class_name": "ACEStepTransformer2DModel",
+  "_diffusers_version": "0.32.2",
+  "attention_head_dim": 128,
+  "in_channels": 8,
+  "inner_dim": 2560,
+  "lyric_encoder_vocab_size": 6693,
+  "lyric_hidden_size": 1024,
+  "max_height": 16,
+  "max_position": 32768,
+  "max_width": 32768,
+  "mlp_ratio": 2.5,
+  "num_attention_heads": 20,
+  "num_layers": 24,
+  "out_channels": 8,
+  "patch_size": [
+    16,
+    1
+  ],
+  "rope_theta": 1000000.0,
+  "speaker_embedding_dim": 512,
+  "ssl_encoder_depths": [
+    8,
+    8
+  ],
+  "ssl_latent_dims": [
+    1024,
+    768
+  ],
+  "ssl_names": [
+    "mert",
+    "m-hubert"
+  ],
+  "text_embedding_dim": 768
+}

ACE_checkpoints_3.5B/mHuBERT-147/.gitattributes

@@ -0,0 +1,76 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+mhubert147_faiss.index filter=lfs diff=lfs merge=lfs -text
+manifest/CV_1.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/CV_10.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/CV_2.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/CV_3.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/CV_4.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/CV_5.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/CV_6.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/CV_7.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/CV_8.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/CV_9.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/CV_11.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/MLS_1.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/MLS_2.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/MLS_3.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/MLS_4.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/MLS_5.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/MLS.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/MLS_10.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/MLS_11.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/MLS_12.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/MLS_13.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/MLS_14.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/MLS_15.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/MLS_16.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/MLS_17.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/MLS_18.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/MLS_19.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/MLS_20.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/MLS_6.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/MLS_7.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/MLS_8.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/MLS_9.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/samromur.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/VL_12.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/VL_2.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/VL_8.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/VL_13.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/VL_15.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/VL_16.tsv filter=lfs diff=lfs merge=lfs -text
+manifest/VP_2.tsv filter=lfs diff=lfs merge=lfs -text

ACE_checkpoints_3.5B/mHuBERT-147/README.md

@@ -0,0 +1,217 @@
+---
+license: cc-by-nc-sa-4.0
+language:
+- ab
+- af
+- am
+- ar
+- as
+- az
+- ba
+- be
+- bn
+- bo
+- bs
+- br
+- bg
+- ca
+- cs
+- cv
+- cy
+- da
+- de
+- dv
+- el
+- en
+- eo
+- et
+- eu
+- ee
+- fo
+- fa
+- tl
+- fi
+- fr
+- fy
+- ga
+- gl
+- gv
+- gn
+- gu
+- ht
+- ha
+- he
+- hi
+- hr
+- hu
+- hy
+- ig
+- ia
+- id
+- is
+- it
+- jv
+- ja
+- kn
+- ka
+- kk
+- km
+- rw
+- ky
+- ku
+- ko
+- lo
+- la
+- lv
+- ln
+- lt
+- lb
+- lg
+- ml
+- mr
+- mk
+- mg
+- mt
+- mn
+- mi
+- ms
+- my
+- ne
+- nl
+- nn
+- no
+- oc
+- or
+- pa
+- pl
+- pt
+- ps
+- ro
+- ru
+- sa
+- si
+- sl
+- sk
+- sn
+- sd
+- so
+- st
+- es
+- sq
+- sc
+- sr
+- su
+- sw
+- sv
+- ta
+- tt
+- te
+- tg
+- th
+- tn
+- tk
+- tr
+- tw
+- ug
+- uk
+- ur
+- uz
+- vi
+- xh
+- yi
+- yo
+- zh
+---
+**This repository contains the best mHuBERT-147 pre-trained model.**
+
+**MODEL DETAILS:** 3rd iteration, K=1000, HuBERT base architecture (95M parameters), 147 languages.
+
+# mHuBERT-147 models
+
+mHuBERT-147 are compact and competitive multilingual HuBERT models trained on 90K hours of open-license data in 147 languages. 
+Different from *traditional* HuBERTs, mHuBERT-147 models are trained using faiss IVF discrete speech units. 
+Training employs a two-level language, data source up-sampling during training. See more information in [our paper](https://arxiv.org/pdf/2406.06371).
+
+
+# Table of Contents:
+
+1. [Summary](https://huggingface.co/utter-project/mHuBERT-147#mhubert-147-models)
+2. [Training Data and Code](https://huggingface.co/utter-project/mHuBERT-147#training)
+3. [ML-SUPERB Scores](https://huggingface.co/utter-project/mHuBERT-147#ml-superb-scores)
+4. [Languages and Datasets](https://huggingface.co/utter-project/mHuBERT-147#languages-and-datasets)
+5. [Intermediate Checkpoints](https://huggingface.co/utter-project/mHuBERT-147#intermediate-checkpoints)
+6. [Citing and Funding Information](https://huggingface.co/utter-project/mHuBERT-147#citing-and-funding-information)
+   
+
+**This repository contains:**
+* Fairseq checkpoint (original);
+* HuggingFace checkpoint (conversion using transformers library);
+* Faiss index for continuous pre-training (OPQ16_64,IVF1000_HNSW32,PQ16x4fsr).
+
+**Related Models:**
+* [2nd Iteration mHuBERT-147](https://huggingface.co/utter-project/mHuBERT-147-base-2nd-iter)
+* [1st Iteration mHuBERT-147](https://huggingface.co/utter-project/mHuBERT-147-base-1st-iter)
+* [CommonVoice Prototype (12 languages)](https://huggingface.co/utter-project/hutter-12-3rd-base)
+
+# Training
+
+* **[Manifest list available here.](https://huggingface.co/utter-project/mHuBERT-147-base-3rd-iter/tree/main/manifest)** Please note that since training, there were CommonVoice removal requests. This means that some of the listed files are no longer available.
+
+* **[Fairseq fork](https://github.com/utter-project/fairseq)** contains the scripts for training with multilingual batching with two-level up-sampling.
+
+* **[Scripts for pre-processing/faiss clustering available here.](https://github.com/utter-project/mHuBERT-147-scripts)** 
+
+# ML-SUPERB Scores
+
+mHubert-147 reaches second and first position in the 10min and 1h leaderboards respectively. We achieve new SOTA scores for three LID tasks.
+See more information in [our paper](https://arxiv.org/pdf/2406.06371).
+
+![image/png](https://cdn-uploads.huggingface.co/production/uploads/62262e19d36494a6f743a28d/chXjExnWc3rhhtdsyiU-W.png)
+
+# Languages and Datasets
+
+**Datasets:** For ASR/ST/TTS datasets, only train set is used.
+* [Aishell](https://www.openslr.org/33/) and [AISHELL-3](https://www.openslr.org/93/)
+* [BibleTTS](https://www.openslr.org/129/)
+* [ClovaCall](https://github.com/clovaai/ClovaCall)
+* [CommonVoice v11](https://commonvoice.mozilla.org/en/datasets)
+* Google TTS data: [Javanese](https://www.openslr.org/41/), [Khmer](https://www.openslr.org/42/), [Nepali](https://www.openslr.org/43/), [Sundanese](https://www.openslr.org/44/), [South African Languages](https://www.openslr.org/32/), [Bengali Languages](https://www.openslr.org/37/)  
+* IISc-MILE: [Tamil](https://www.openslr.org/127/), [Kannada](https://www.openslr.org/126/)
+* [Japanese Versatile Speech](https://sites.google.com/site/shinnosuketakamichi/research-topics/jvs_corpus) 
+* [Kokoro](https://github.com/kaiidams/Kokoro-Speech-Dataset)
+* [Kosp2e](https://github.com/warnikchow/kosp2e)
+* Media Speech: [Turkish Only](https://www.openslr.org/108/)
+* [Multilingual LibriSpeech](https://www.openslr.org/94/)
+* [Samrómur](https://www.openslr.org/128/)
+* [THCHS-30](https://www.openslr.org/18/) and [THUYG-20](https://www.openslr.org/22/)
+* [VoxLingua107](https://bark.phon.ioc.ee/voxlingua107/)
+* [VoxPopuli](https://github.com/facebookresearch/voxpopuli/)
+
+**Languages present not indexed by Huggingface:** Asturian (ast), Basaa (bas), Cebuano (ceb), Central Kurdish/Sorani (ckb), Hakha Chin (cnh), Hawaiian (haw), Upper Sorbian (hsb) Kabyle (kab), Moksha (mdf), Meadow Mari (mhr), Hill Mari (mrj), Erzya (myv), Taiwanese Hokkien (nan-tw), Sursilvan (rm-sursilv), Vallader (rm-vallader), Sakha (sah), Santali (sat), Scots (sco), Saraiki (skr), Tigre (tig), Tok Pisin (tpi), Akwapen Twi (tw-akuapem), Asante Twi (tw-asante), Votic (vot), Waray (war), Cantonese (yue).
+
+# Intermediate Checkpoints
+
+For allowing research in training dynamics, the intermediate checkpoints for the three iterations are made available under the **CC-BY-NC-SA-4.0** license via a protected link.
+
+* **Downloading page:** https://download.europe.naverlabs.com/mhubert147/
+* **User:** user
+* **Password:** license mentioned above in bold
+
+
+# Citing and Funding Information
+
+```
+@inproceedings{boito2024mhubert,
+author={Boito, Marcely Zanon and Iyer, Vivek and Lagos, Nikolaos and Besacier, Laurent and Calapodescu, Ioan},
+title={{mHuBERT-147: A Compact Multilingual HuBERT Model}},
+year=2024,
+booktitle={Interspeech 2024},
+
+```
+
+<img src="https://cdn-uploads.huggingface.co/production/uploads/62262e19d36494a6f743a28d/HbzC1C-uHe25ewTy2wyoK.png" width=7% height=7%> 
+This is an output of the European Project UTTER (Unified Transcription and Translation for Extended Reality) funded by European Union’s Horizon Europe Research and Innovation programme under grant agreement number 101070631.
+
+For more information please visit https://he-utter.eu/
+
+NAVER LABS Europe: https://europe.naverlabs.com/

ACE_checkpoints_3.5B/mHuBERT-147/checkpoint_best.pt

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

ACE_checkpoints_3.5B/mHuBERT-147/config.json

@@ -0,0 +1,76 @@
+{
+  "_name_or_path": "mmHuBERT-3rd-faiss-0.7d-0.9l-1000k-850gb-2M-best",
+  "activation_dropout": 0.1,
+  "apply_spec_augment": true,
+  "architectures": [
+    "HubertModel"
+  ],
+  "attention_dropout": 0.1,
+  "bos_token_id": 1,
+  "classifier_proj_size": 256,
+  "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,
+  "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_proj_layer_norm": true,
+  "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_min_masks": 0,
+  "mask_feature_prob": 0.0,
+  "mask_time_length": 10,
+  "mask_time_min_masks": 2,
+  "mask_time_prob": 0.05,
+  "model_type": "hubert",
+  "num_attention_heads": 12,
+  "num_conv_pos_embedding_groups": 16,
+  "num_conv_pos_embeddings": 128,
+  "num_feat_extract_layers": 7,
+  "num_hidden_layers": 12,
+  "pad_token_id": 0,
+  "tokenizer_class": "Wav2Vec2CTCTokenizer",
+  "torch_dtype": "float32",
+  "transformers_version": "4.30.1",
+  "use_weighted_layer_sum": false,
+  "vocab_size": 32
+}

ACE_checkpoints_3.5B/mHuBERT-147/manifest/CV_1.tsv

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

ACE_checkpoints_3.5B/mHuBERT-147/manifest/CV_10.tsv

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

ACE_checkpoints_3.5B/mHuBERT-147/manifest/CV_11.tsv

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

ACE_checkpoints_3.5B/mHuBERT-147/manifest/CV_2.tsv

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

ACE_checkpoints_3.5B/mHuBERT-147/manifest/CV_3.tsv

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

ACE_checkpoints_3.5B/mHuBERT-147/manifest/CV_4.tsv

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

ACE_checkpoints_3.5B/mHuBERT-147/manifest/CV_5.tsv

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

ACE_checkpoints_3.5B/mHuBERT-147/manifest/CV_6.tsv

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

ACE_checkpoints_3.5B/mHuBERT-147/manifest/CV_7.tsv

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

ACE_checkpoints_3.5B/mHuBERT-147/manifest/CV_8.tsv

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

ACE_checkpoints_3.5B/mHuBERT-147/manifest/CV_9.tsv

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

ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS.tsv

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

ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_1.tsv

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

ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_10.tsv

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

ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_11.tsv

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

ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_12.tsv

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

ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_13.tsv

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

ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_14.tsv

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

ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_15.tsv

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

ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_16.tsv

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

ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_17.tsv

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

ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_18.tsv

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

ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_19.tsv

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

ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_2.tsv

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

ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_20.tsv

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

ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_3.tsv

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

ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_4.tsv

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

ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_5.tsv

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

ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_6.tsv

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

ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_7.tsv

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

ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_8.tsv

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

ACE_checkpoints_3.5B/mHuBERT-147/manifest/MLS_9.tsv

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