Add files using upload-large-folder tool

config/config.py

@@ -0,0 +1,272 @@
+"""config.py"""
+import numpy as np
+# yapf: disable
+"""
+audio_cfg:
+- Used by 'ymt3' to create a spectrogram layer.
+- Input shape of model is determined by audio_cfg.
+- 'train.py' arguments can override these defaults.
+"""
+audio_cfg = {
+    # Overwrittable by args in train.py
+    "codec": "melspec",  # {melspec, spec} melspec for MT3, spec for PerceiverTF
+    "hop_length": 128,  # {128, 300} 128 for MT3, 300 for PerceiverTF
+    # Shared audio parameters
+    "audio_backend": "torchaudio",  # {torchaudio, nnAudio}
+    "sample_rate": 16000,
+    "input_frames": 32767, # number of input frames (~=2.048 s), determining in-/output shape of front layers. 
+    "n_fft": 2048,
+    "n_mels": 512,  # only for melspec
+    "f_min": 50.0,
+    "f_max": 8000.0,
+} # TODO: currently dataloader is not updated by "input_frames"
+
+"""
+model_cfg:
+- Encoder type dictates use of T5_CFG or PERCEIVER_TF_CFG.
+- 'train.py' arguments can override these defaults.
+"""
+model_cfg = {
+    "encoder_type": "t5",  # {"t5", "perceiver-tf", "conformer"}
+    "decoder_type": "t5", # {"t5", "multi-t5"}
+    "pre_encoder_type": "default",  # {None, "default", "conv", "conv1d", "conv2d_avpt"} by default, t5:None, perceiver:conv.
+    "pre_encoder_type_default": {"t5": None, "perceiver-tf": "conv", "conformer": None},
+    "pre_decoder_type": "default", # {None, 'linear', 'conv1', 'mlp', 'group_linear'} see model/projection_layer.py
+    "pre_decoder_type_default": { # [enc_type][dec_type]
+        "t5": {"t5": None,},
+        "perceiver-tf": {"t5": "linear", "multi-t5": "mc_shared_linear"},
+        "conformer": {"t5": None,},
+    },
+    "conv_out_channels": 128, # number of filters for 'conv' pre_encoder. Otherwise ignored.
+    "t5_basename": "google/t5-v1_1-small",
+    "pretrained": False, # bool, if True, load pretrained weights from t5_basename. Mismatched layers are ignored.
+    "use_task_conditional_encoder": True, # True by default, but default task is None. So not activated by default. 
+    "use_task_conditional_decoder": True, # True by default, but default task is None. So not activated by default.  
+    "d_feat": "auto", # Input audio feature dimension for encoder. Automatically inferred by audio_cfg and existence of pre_encoders.
+    "tie_word_embeddings": True, # If True, weights of embed_tokens and lm_head are tied for stabilizing gradients. 
+    "vocab_size": "auto", # int or "auto", automatically inferred by task manager.
+    "num_max_positions": "auto", # int or "auto". Length of positional encoding. Automatically inferred by "feat_length", "event_length" and task_manager.max_task_token_length.
+    # 'vocab_size', 'tie_word_embeddings' and 'num_max_positions' are auto-copied to encoder and decoder configs in the below.
+    "encoder": {
+        "t5": {
+            "d_model": 512, # Hidden size of T5 encoder. 
+            "num_heads": 6,
+            "num_layers": 8,
+            "dropout_rate": 0.05,
+            "position_encoding_type": "sinusoidal", # {'sinusoidal', 'trainable'}.
+            "ff_widening_factor": 2, # wideening factor for MLP/MoE layers. Default is 2 in T5.
+            "ff_layer_type": "t5_gmlp", # {'t5_gmlp', 'moe', 'mlp', 'gmlp'}. 'moe' for mixture of experts, 'mlp' for standard transformer dense layer, 'gmlp' for simple gated MLP.
+        },
+        "perceiver-tf": {
+            "num_latents": 24, # number of latents in Perceiver. 24 in perceiver-tf paper.
+            "d_latent": 128, # latent dimension of Perceiver. 128 in perceiver-tf paper.
+            "d_model": "q", # int or "q" or "kv". Inner-dim of sca and local/temporal self-att.
+                # "q" follows "latent_dim". "kv" follows  "d_feat". Best practice is to inc-/decrease 'd_latent', instead of 'd_model'.
+            "num_blocks": 3, # number of Perceiver-TF blocks in encoder. L in the paper.
+            "num_local_transformers_per_block": 2, # N in the paper.
+            "num_temporal_transformers_per_block": 2,  # M in the paper.
+            "sca_use_query_residual": False,
+            "dropout_rate": 0.1,
+            "position_encoding_type": "trainable", # {'trainable', 'rotary', 'alibi', 'alibit', None, 'tkd','td', 'tk', 'kdt'}. alibit is alibi with trainable slopes.
+            "attention_to_channel": True, # Whether to use channel attention in sca.
+            "layer_norm_type": "layer_norm", # {'layer_norm', 'rms_norm'}
+            "ff_layer_type": "mlp", # {'moe', 'mlp', gmlp}. 'moe' for mixture of experts, 'mlp' for standard transformer dense layer, 'gmlp' for simple gated MLP.
+            "ff_widening_factor": 1, # wideening factor for MLP/MoE layers. Default is 1.
+            "moe_num_experts": 4, # number of experts in MoE layer. Default is 4. Disabled if ff_layer_type is not 'moe'.
+            "moe_topk": 2, # top-k routing in MoE layer. Default is 2. Disabled if ff_layer_type is not 'moe'.
+            "hidden_act": 'gelu', # activation function in MLP/MoE layer. Default is 'gelu'. {'gelu', 'silu', 'relu'}
+            "rotary_type_sca": "pixel", # {'l'|'lang', 'p'|'pixel'}. Default is 'pixel'.
+            "rotary_type_latent": "pixel", # {'l'|'lang', 'p'|'pixel'}. Default is 'pixel'.
+            "rotary_type_temporal": "lang", # {'l'|'lang', 'p'|'pixel'}. Default is 'lang'.
+            "rotary_apply_to_keys": False, # Whether to apply rotary to keys. Default is False.
+            "rotary_partial_pe": False, # Whether to use partial positional encoding. Default is False.
+        },
+        "conformer": {
+            "d_model": 512, # Hidden size of T5 encoder. 
+            "intermediate_size": 512, # or 2048. size of the intermediate feed forward layer in each T5Block
+            "num_heads": 8,
+            "num_layers": 8,
+            "dropout_rate": 0.1,
+            "layerdrop": 0.1, # see https://arxiv.org/abs/1909.11556
+            "position_encoding_type": "rotary", # {'rotary', 'relative'}. 
+            "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, 3, 3),
+            "conv_depthwise_kernel_size": 31,
+        },
+
+    },
+    "decoder": {
+        "t5": {
+            "d_model": 512, # Hidden size of T5 encoder. If encoder has lower dim, it is projected to this dim for enc-dec cross att.
+            "num_heads": 6,
+            "num_layers": 8,
+            "dropout_rate": 0.05,
+            "position_encoding_type": "sinusoidal", # {'sinusoidal', 'trainable'}.
+            "ff_widening_factor": 2, # wideening factor for MLP/MoE layers. Default is 2 in T5.
+            "ff_layer_type": "t5_gmlp", # {'t5_gmlp', 'moe', 'mlp', 'gmlp'}. 'moe' for mixture of experts, 'mlp' for standard transformer dense layer, 'gmlp' for simple gated MLP.
+        },
+        "multi-t5": {
+            "d_model": 512, # Hidden size of T5 encoder. Recommended: {256 or 512}
+            "num_heads": 6,
+            "num_layers": 8,
+            "dropout_rate": 0.05,
+            "position_encoding_type": "sinusoidal", # {'sinusoidal', 'trainable'}.
+            "ff_widening_factor": 2, # wideening factor for MLP/MoE layers. Default is 2 in T5.
+            "ff_layer_type": "t5_gmlp", # {'t5_gmlp', 'moe', 'mlp', 'gmlp'}. 'moe' for mixture of experts, 'mlp' for standard transformer dense layer, 'gmlp' for simple gated MLP.
+            "num_channels": 13,
+        },
+    },
+    "feat_length": "auto", # Input audio feature length for encoder. Automatically inferred by audio_cfg.
+        # mt3: 256 time steps
+    "event_length": 1024,  # max length of event tokens excluding task tokens <-- 128 for multi-t5
+    "init_factor": 1.0, # initialization factor for embedding layers
+}
+
+# yapf: enable
+shared_cfg = {
+    "PATH": {
+        "data_home": "../../data", # path to the data directory. If using relative path, it is relative to /src directory.
+    },
+    "BSZ": { # global batch size is local_bsz * n_GPUs in DDP mode
+        "train_sub": 12, #20, # sub-batch size is per CPU worker
+        "train_local": 24, #40, # local batch size is per GPU in DDP mode
+        "validation": 64, # validation batch size is per GPU in DDP mode
+        "test": 64,
+    },
+    "AUGMENTATION": {
+        "train_random_amp_range": [0.8, 1.1], # min and max amplitude scaling factor
+        "train_stem_iaug_prob": 0.7, # probability of stem activation in intra-stem augmentation
+        "train_stem_xaug_policy": {
+            "max_k": 3,
+            "tau": 0.3,
+            "alpha": 1.0,
+            "max_subunit_stems": 12, # the number of subunit stems to be reduced to this number of stems
+            "p_include_singing": None,  # NOT IMPLEMENTED; probability of including singing for cross augmented examples. if None, use base probaility.
+            "no_instr_overlap": True,
+            "no_drum_overlap": True,
+            "uhat_intra_stem_augment": True,
+        },
+        "train_pitch_shift_range": [-2, 2], # [min, max] in semitones. None or [0, 0] for no pitch shift.
+    },
+    "DATAIO": { # do not set `shuffle` here. 
+        "num_workers": 4, # num_worker is per GPU in DDP mode
+        "prefetch_factor": 2, #2,
+        "pin_memory": True,
+        "persistent_workers": False,
+    },
+    "CHECKPOINT": {
+        "save_top_k": 4, # max top k checkpoints to save
+        "monitor": 'validation/macro_onset_f',
+        "mode": 'max',
+        # "every_n_epochs": 20, # only working when check_val_every_n_epoch is 0
+        "save_last": True, # save last model
+        "filename": "{epoch}-{step}",
+    },
+    "TRAINER": { # do not coverwrite args in this section
+        "limit_train_batches": 1.0, # How much of training dataset to check (float = fraction, int = num_batches)
+        "limit_val_batches": 1.0,
+        "limit_test_batches": 1.0,
+        "gradient_clip_val": 1.0, # {0 or None} means don't clip.
+        "accumulate_grad_batches": 1, #1, # Accumulates grads every k batches. If set to 1, no effect.
+        "check_val_every_n_epoch": 1, #5, 1 for very large dataset such as EGMD
+        "num_sanity_val_steps": 0,
+    },
+    "WANDB": {
+        "save_dir": "../logs",
+        "cache_dir": "../logs/.wandb_cache",
+        "resume": "allow",
+        "anonymous": "allow", # {never, allow, must}
+        "mode": "online", # {online, offline, disabled}
+    },
+    "LR_SCHEDULE": {
+        # "scheduler_type": "cosine", # {legacy, cosine, constant}
+        "warmup_steps": 1000, # only for cosine scheduler, legacy scheduler follows T5's legacy schedule
+        "total_steps": 100000, # argparser of train.py can overwrite this
+        "final_cosine": 1e-5, # only for cosine scheduler
+    },
+    "TOKENIZER": {
+        "max_shift_steps": "auto", # max number of shift steps in the model. (int) or "auto". If "auto", it is set by audio_cfg["input_frames"] and shift_steps_ms. 206 with default setup.
+        "shift_step_ms": 10, # shift step in ms
+    },
+}
+
+T5_BASE_CFG = {
+    "google/t5-v1_1-small": {
+        "architectures": ["T5ForConditionalGeneration"],
+        "d_ff":
+            1024,  # size of the intermediate feed forward layer in each T5Block. Can be overwrten by ff_widening_factor in model_cfg.
+        "d_kv": 64,  # d_kv has to be equal to d_model // num_heads.
+        # "d_model": 512,  # encoder hiddnen size, defined by model_cfg
+        "decoder_start_token_id": 0,
+        "dense_act_fn": "gelu_new",
+        # "dropout_rate": 0.05,  # can be overwritten by args in ymt3
+        "eos_token_id": 1,
+        "feed_forward_proj": "gated-gelu",
+        "initializer_factor": 1.0,
+        "is_encoder_decoder": True,
+        "is_gated_act": True,
+        "layer_norm_epsilon": 1e-06,
+        "model_type": "t5",
+        # "num_decoder_layers": 8, # defined by model_cfg
+        # "num_heads": 6,  # defined by model_cfg
+        # "num_layers": 8,  # defined by model_cfg
+        "output_past": True,
+        "pad_token_id": 0,
+        "relative_attention_num_buckets": 32,
+        # "tie_word_embeddings": True,
+        "use_cache": True,
+        # "vocab_size": 1391 # vocab_size is automatically set by the task manager...
+    },
+    "google/t5-efficient-small": {
+        "architectures": ["T5ForConditionalGeneration"],
+        "d_ff": 2048,
+        "d_kv": 64,
+        "d_model": 512,
+        "decoder_start_token_id": 0,
+        "dropout_rate": 0.1,
+        "eos_token_id": 1,
+        "feed_forward_proj": "relu",
+        "initializer_factor": 1.0,
+        "is_encoder_decoder": True,
+        "layer_norm_epsilon": 1e-06,
+        "model_type": "t5",
+        "num_decoder_layers": 6,
+        "num_heads": 8,
+        "num_layers": 6,
+        "pad_token_id": 0,
+        "relative_attention_num_buckets": 32,
+        "torch_dtype": "float32",
+        "transformers_version": "4.17.0.dev0",
+        "use_cache": True,
+    },
+}
+
+# yapf: enable
+DEEPSPEED_CFG = {
+    "zero_allow_untested_optimizer": True,
+    "optimizer": {
+        "type": "adam",
+        "params": {
+            "lr": 1e-4,
+            "betas": [0.998, 0.999],
+            "eps": 1e-3,
+            "weight_decay": 0.001,
+            "adam_w_mode": True,
+        }
+    },
+    "scheduler": {
+        "type": "WarmupLR",
+        "params": {
+            "last_batch_iteration": -1,
+            "warmup_min_lr": 0,
+            "warmup_max_lr": 3e-5,
+            "warmup_num_steps": 100,
+        },
+    },
+    "zero_optimization": {
+        "stage": 0,  #0,1,2,3
+        # "offload_optimizer":
+        #     False,  # Enable Offloading optimizer state/calculation to the host CPU
+    },
+}

config/data_presets.py

@@ -0,0 +1,811 @@
+""" data.py:
+Data presets for training and evaluation.
+
+Single Presets:
+    musicnet_mt3
+    musicnet_em
+    musicnet_thickstun
+    slakh
+    guitarset
+    ...
+
+Multi Presets:
+    all_mmegs
+    ...
+
+"""
+from config.vocabulary import *
+from config.vocabulary import drum_vocab_presets, program_vocab_presets
+from utils.utils import deduplicate_splits, merge_splits, merge_vocab
+
+data_preset_single_cfg = {
+    "musicnet_mt3": {
+            "eval_vocab": [MUSICNET_INSTR_CLASS],
+            "dataset_name": "musicnet",
+            "train_split": "train_mt3",
+            "validation_split": "validation_mt3_acoustic",
+            "test_split": "test_mt3_acoustic",
+            "has_stem": False,
+    },
+    "musicnet_mt3_synth_only": { # sanity-check
+            "eval_vocab": [MUSICNET_INSTR_CLASS],
+            "dataset_name": "musicnet",
+            "train_split": "train_mt3_synth",
+            "validation_split": "validation_mt3_synth",
+            "test_split": "test_mt3_acoustic",
+            "has_stem": False,
+    },
+    "musicnet_mt3_em": {
+            "eval_vocab": [MUSICNET_INSTR_CLASS],
+            "dataset_name": "musicnet",
+            "train_split": "train_mt3_em",
+            "validation_split": "validation_mt3_em",
+            "test_split": "test_mt3_em",
+            "has_stem": False,
+    },
+    "musicnet_thickstun": { # exp4
+            "eval_vocab": [MUSICNET_INSTR_CLASS],
+            "dataset_name": "musicnet",
+            "train_split": "train_thickstun",
+            "validation_split": "test_thickstun",
+            "test_split": "test_thickstun",
+            "has_stem": False,
+    },
+    "musicnet_thickstun_em": { # NOTE: this is not the use of external 'synth' in the paper, but the use of 'synth' within the dataset
+            "eval_vocab": [MUSICNET_INSTR_CLASS],
+            "dataset_name": "musicnet",
+            "train_split": "train_thickstun_em",
+            "validation_split": "test_thickstun_em",
+            "test_split": "test_thickstun_em",
+            "has_stem": False,
+    },
+    "musicnet_thickstun_ext": { # exp4
+            "eval_vocab": [MUSICNET_INSTR_CLASS],
+            "dataset_name": "musicnet",
+            "train_split": "train_thickstun",
+            "validation_split": "test_thickstun_ext",
+            "test_split": "test_thickstun_ext",
+            "has_stem": False,
+    },
+    "musicnet_thickstun_ext_em": { # NOTE: this is not the use of external 'synth' in the paper, but the use of 'synth' within the dataset
+            "eval_vocab": [MUSICNET_INSTR_CLASS],
+            "dataset_name": "musicnet",
+            "train_split": "train_thickstun_em",
+            "validation_split": "test_thickstun_ext_em",
+            "test_split": "test_thickstun_ext_em",
+            "has_stem": False,
+    },
+    "maps_default": {
+            "eval_vocab": [PIANO_SOLO_CLASS],
+            "dataset_name": "maps",
+            "train_split": "train",
+            "validation_split": "test",
+            "test_split": "test",
+            "has_stem": False,
+    },
+    "maps_all": {
+            "eval_vocab": [None],
+            "dataset_name": "maps",
+            "train_split": "all",
+            "validation_split": None,
+            "test_split": None,
+            "has_stem": False,
+    },
+    "maestro": {
+            "eval_vocab": [PIANO_SOLO_CLASS],
+            "dataset_name": "maestro",
+            "train_split": "train",
+            "validation_split": "validation",
+            "test_split": "test",
+            "has_stem": False,
+    },
+    "maestro_final": {
+            "eval_vocab": [PIANO_SOLO_CLASS],
+            "dataset_name": "maestro",
+            "train_split": merge_splits(["train", "validation"], dataset_name="maestro"),
+            "validation_split": "test",
+            "test_split": "test",
+            "has_stem": False,
+    },
+    "guitarset": { # 4 random players for train, 1 for valid, and 1 for test
+            "eval_vocab": [GUITAR_SOLO_CLASS],
+            "dataset_name": "guitarset",
+            "train_split": "train",
+            "validation_split": "validation",
+            "test_split": "test",
+            "has_stem": False,
+    },
+    "guitarset_pshift": { # guitarset + pitch shift
+            "eval_vocab": [GUITAR_SOLO_CLASS],
+            "dataset_name": "guitarset",
+            "train_split": "train_pshift",
+            "validation_split": "validation",
+            "test_split": "test",
+            "has_stem": False,
+    },
+    "guitarset_progression": { # progression 1 and 2 as train, progression 3 as test
+            "eval_vocab": [GUITAR_SOLO_CLASS],
+            "dataset_name": "guitarset",
+            "train_split": merge_splits(["progression_1", "progression_2"], dataset_name="guitarset"),
+            "validation_split": "progression_3",
+            "test_split": "progression_3",
+            "has_stem": False,
+    },
+    "guitarset_progression_pshift": { # guuitarset_progression + pitch shift
+            "eval_vocab": [GUITAR_SOLO_CLASS],
+            "dataset_name": "guitarset",
+            "train_split": merge_splits(["progression_1_pshift", "progression_2_pshift"], dataset_name="guitarset"),
+            "validation_split": "progression_3",
+            "test_split": "progression_3",
+            "has_stem": False,
+    },
+    "guitarset_minus_bn": { # guuitarset_style + pitch shift
+            "eval_vocab": [GUITAR_SOLO_CLASS],
+            "dataset_name": "guitarset",
+            "train_split": merge_splits(["Funk_pshift", "SS_pshift", "Jazz_pshift", "Rock_pshift"],
+                                         dataset_name="guitarset"),
+            "validation_split": "BN",
+            "test_split": "BN",
+            "has_stem": False,
+    },
+    "guitarset_minus_funk": { # guuitarset_style + pitch shift
+            "eval_vocab": [GUITAR_SOLO_CLASS],
+            "dataset_name": "guitarset",
+            "train_split": merge_splits(["BN_pshift", "SS_pshift", "Jazz_pshift", "Rock_pshift"],
+                                         dataset_name="guitarset"),
+            "validation_split": "Funk",
+            "test_split": "Funk",
+            "has_stem": False,
+    },
+    "guitarset_minus_ss": { # guuitarset_style + pitch shift
+            "eval_vocab": GUITAR_SOLO_CLASS,
+            "dataset_name": "guitarset",
+            "train_split": merge_splits(["BN_pshift", "Funk_pshift", "Jazz_pshift", "Rock_pshift"],
+                                         dataset_name="guitarset"),
+            "validation_split": "SS",
+            "test_split": "SS",
+            "has_stem": False,
+    },
+    "guitarset_minus_jazz": { # guuitarset_style + pitch shift
+            "eval_vocab": [GUITAR_SOLO_CLASS],
+            "dataset_name": "guitarset",
+            "train_split": merge_splits(["BN_pshift", "Funk_pshift", "SS_pshift", "Rock_pshift"],
+                                         dataset_name="guitarset"),
+            "validation_split": "Jazz",
+            "test_split": "Jazz",
+            "has_stem": False,
+    },
+    "guitarset_minus_rock": { # guuitarset_style + pitch shift
+            "eval_vocab": [GUITAR_SOLO_CLASS],
+            "dataset_name": "guitarset",
+            "train_split": merge_splits(["BN_pshift", "Funk_pshift", "SS_pshift", "Jazz_pshift"],
+                                         dataset_name="guitarset"),
+            "validation_split": "Rock",
+            "test_split": "Rock",
+            "has_stem": False,
+    },
+    "guitarset_all": {
+            "eval_vocab": [None],
+            "dataset_name": "guitarset",
+            "train_split": "all",
+            "validation_split": None,
+            "test_split": None,
+            "has_stem": False,
+    },
+    "enstdrums_dtp": {
+            "eval_vocab": [None],
+            "eval_drum_vocab": drum_vocab_presets["ksh"],
+            "dataset_name": "enstdrums",
+            "train_split": merge_splits(["drummer_1_dtp", "drummer_2_dtp", "drummer_1_dtp", "drummer_2_dtp"], dataset_name="enstdrums"),
+            "validation_split": "drummer_1_dtp", # for sanity check
+            "test_split": "drummer_3_dtp",
+            "has_stem": False,
+    },
+    "enstdrums_dtm": {
+            "eval_vocab": [None],
+            "eval_drum_vocab": drum_vocab_presets["ksh"],
+            "dataset_name": "enstdrums",
+            "train_split": merge_splits(["drummer_1_dtm", "drummer_2_dtm", "drummer_1_dtp", "drummer_2_dtp"], dataset_name="enstdrums"),
+            "validation_split": "drummer_3_dtm_r2", # 0.6 * drum
+            "test_split": "drummer_3_dtm_r1", # 0.75 * drum
+            "has_stem": True,
+    },
+    "enstdrums_random_dtm": { # single dataset training as a denoising ADT model
+            "eval_vocab": [None],
+            "eval_drum_vocab": drum_vocab_presets["ksh"],
+            "dataset_name": "enstdrums",
+            "train_split": "train_dtm",
+            "validation_split": "validation_dtm",
+            "test_split": "test_dtm",
+            "has_stem": True,
+    },
+    "enstdrums_random": { # multi dataset training with random split of 70:15:15
+            "eval_vocab": [None],
+            "eval_drum_vocab": drum_vocab_presets["ksh"],
+            "dataset_name": "enstdrums",
+            "train_split": "train_dtp",
+            "validation_split": "test_dtm",
+            "test_split": "test_dtm",
+            "has_stem": True,
+    },
+    "enstdrums_random_plus_dtd": { # multi dataset training plus dtd
+            "eval_vocab": [None],
+            "eval_drum_vocab": drum_vocab_presets["ksh"],
+            "dataset_name": "enstdrums",
+            "train_split": merge_splits(["train_dtp", "all_dtd"], dataset_name="enstdrums"),
+            "validation_split": "test_dtm",
+            "test_split": "test_dtm",
+            "has_stem": True,
+    },
+    "mir_st500": {
+            "eval_vocab": [SINGING_SOLO_CLASS],
+            "dataset_name": "mir_st500",
+            "train_split": "train_stem",
+            "validation_split": "test",
+            "test_split": "test",
+            "has_stem": True,
+    },
+    "mir_st500_voc": {
+            "eval_vocab": [SINGING_SOLO_CLASS],
+            "dataset_name": "mir_st500",
+            "train_split": "train_vocal",
+            "validation_split": "test_vocal",
+            "test_split": "test_vocal",
+            "has_stem": False,
+    },
+    "mir_st500_voc_debug": { # using train_vocal for test (for debugging)
+            "eval_vocab": [SINGING_SOLO_CLASS],
+            "dataset_name": "mir_st500",
+            "train_split": "train_vocal",
+            "validation_split": "test_vocal",
+            "test_split": "train_vocal",
+            "has_stem": False,
+    },
+    "slakh": {
+            "eval_vocab": [GM_INSTR_CLASS],
+            "eval_drum_vocab": drum_vocab_presets["gm"],
+            "dataset_name": "slakh",
+            "train_split": "train",
+            "validation_split": "validation",
+            "test_split": "test",
+            "has_stem": True,
+    },
+    "slakh_final": {
+            "eval_vocab": [GM_INSTR_CLASS],
+            "eval_drum_vocab": drum_vocab_presets["gm"],
+            "dataset_name": "slakh",
+            "train_split": merge_splits(["train", "validation"], dataset_name="slakh"),
+            "validation_split": "test",
+            "test_split": "test",
+            "has_stem": True,
+    },
+    "rwc_pop_bass": {
+            "eval_vocab": [BASS_SOLO_CLASS],
+            "add_pitch_class_metric": ["Bass"],
+            "dataset_name": "rwc_pop",
+            "train_split": None,
+            "validation_split": "bass",
+            "test_split": "bass",
+            "has_stem": False,
+    },
+    "rwc_pop_full": {
+            "eval_vocab": [GM_INSTR_CLASS_PLUS],
+            "add_pitch_class_metric": list(GM_INSTR_CLASS_PLUS.keys()),
+            "dataset_name": "rwc_pop",
+            "train_split": None,
+            "validation_split": "full",
+            "test_split": "full",
+            "has_stem": False,
+    },
+    "egmd": {
+            "eval_vocab": [None],
+            "eval_drum_vocab": drum_vocab_presets["ksh"],
+            "dataset_name": "egmd",
+            "train_split": "train",
+            "validation_split": "validation",
+            "test_split": "test_reduced", # EGMD has 5000+ test files, so we reudce it to 200 files to save time
+            # "train_limit_num_files": 4402, #8804, # 17608, # limit the number of files for training to random choice of half.
+            "has_stem": False,
+    },
+    "urmp": {
+            "eval_vocab": [GM_INSTR_CLASS],
+            "dataset_name": "urmp",
+            "train_split": "train",
+            "validation_split": "test",
+            "test_split": "test",
+            "has_stem": True,
+    },
+    "cmedia": {
+            "eval_vocab": [SINGING_SOLO_CLASS],
+            "dataset_name": "cmedia",
+            "train_split": "train_stem",
+            "validation_split": "train",
+            "test_split": "train",
+            "has_stem": True,
+    },
+    "cmedia_voc": {
+            "eval_vocab": [SINGING_SOLO_CLASS],
+            "dataset_name": "cmedia",
+            "train_split": "train_vocal",
+            "validation_split": "train_vocal",
+            "test_split": "train_vocal",
+            "has_stem": False,
+    },
+    "idmt_smt_bass": {
+            "eval_vocab": [BASS_SOLO_CLASS],
+            "dataset_name": "idmt_smt_bass",
+            "train_split": "train",
+            "validation_split": "validation",
+            "test_split": "validation",
+            "has_stem": False,
+    },
+    "geerdes": { # full mix dataset for evaluation
+            "eval_vocab": [GM_INSTR_CLASS_PLUS],
+            "dataset_name": "geerdes",
+            "train_split": None,
+            "validation_split": None,
+            "test_split": "all",
+            "has_stem": False,
+    },
+    "geerdes_sep": { # Using vocal/accomp separation for evalutation
+            "eval_vocab": [GM_INSTR_CLASS_PLUS],
+            "dataset_name": "geerdes",
+            "train_split": None,
+            "validation_split": None,
+            "test_split": "all_sep",
+            "has_stem": False,
+    },
+    "geerdes_half": { # Using half dataset for train/val
+            "eval_vocab": [GM_INSTR_CLASS_PLUS],
+            "dataset_name": "geerdes",
+            "train_split": "train",
+            "validation_split": "validation",
+            "test_split": "validation",
+            "has_stem": False,
+    },
+    "geerdes_half_sep": { # Using half dataset with vocal/accomp separation for train/val
+            "eval_vocab": [GM_INSTR_CLASS_PLUS],
+            "dataset_name": "geerdes",
+            "train_split": "train_sep",
+            "validation_split": "validation_sep",
+            "test_split": "validation_sep",
+            "has_stem": False,
+    },
+}
+
+data_preset_multi_cfg = {
+    "musicnet_mt3_em_synth_plus_maps": {
+        "presets": ["musicnet_mt3_em_synth", "maps_all"],
+        "weights": [0.6, 0.4],
+        "eval_vocab": [MUSICNET_INSTR_CLASS],
+    },
+    "musicnet_em_synth_table2_plus_maps": {
+        "presets": ["musicnet_em_synth_table2", "maps_all"],
+        "weights": [0.6, 0.4],
+        "eval_vocab": [MUSICNET_INSTR_CLASS],
+    },
+    "musicnet_em_synth_table2_plus_maps_multi": {
+        "presets": ["musicnet_em_synth_table2", "maps_default"],
+        "weights": [0.6, 0.4],
+        "eval_vocab": [MUSICNET_INSTR_CLASS],
+    },
+    "guitarset_progression_plus_maps": {
+        "presets": ["guitarset_progression", "maps_all"],
+        "weights": [0.5, 0.5],
+        "eval_vocab": [GUITAR_SOLO_CLASS],
+    },
+    "guitarset_pshift_plus_maps": {
+        "presets": ["guitarset_pshift", "maps_default"],
+        "weights": [0.6, 0.4],
+        "eval_vocab": [merge_vocab([GUITAR_SOLO_CLASS, PIANO_SOLO_CLASS])],
+    },
+    "guitarset_pshift_plus_musicnet_thick": {
+        "presets": ["guitarset_pshift", "musicnet_thickstun_em"],
+        "weights": [0.5, 0.5],
+        "eval_vocab": [merge_vocab([GUITAR_SOLO_CLASS, PIANO_SOLO_CLASS])],
+    },
+    "multi_sanity_check": {
+        "presets": ["musicnet_mt3_synth_only", "musicnet_mt3_synth_only"],
+        "weights": [0.6, 0.4],
+        "eval_vocab": [MUSICNET_INSTR_CLASS],
+    },
+    "all_mmegs": {
+        "presets": [
+            "slakh", "musicnet_thickstun_em", "mir_st500_voc", "enstdrums_dtp", "guitarset_pshift"
+        ],
+        "weights": [0.2, 0.2, 0.2, 0.2, 0.2],
+        "eval_vocab": [None] * 5,  # None means instrument-agnostic F1 for each dataset
+        "eval_drum_vocab": drum_vocab_presets["ksh"],  # for drums, kick-snare-hihat metric
+        "val_max_num_files": 20,  # max 20 files per dataset
+        "test_max_num_files": None,
+    },
+    "all_gt_cv0": {
+        "presets": [
+            "slakh", "musicnet_thickstun_em", "mir_st500_voc", "enstdrums_dtp", "guitarset_minus_bn"
+        ],
+        "weights": [0.2, 0.2, 0.2, 0.2, 0.2],
+        "eval_vocab": [None] * 5,  # None means instrument-agnostic F1 for each dataset
+        "eval_drum_vocab": drum_vocab_presets["ksh"],  # for drums, kick-snare-hihat metric
+        "val_max_num_files": 20,  # max 20 files per dataset
+        "test_max_num_files": None,
+    },
+    "all_gt_cv1": {
+        "presets": [
+            "slakh", "musicnet_thickstun_em", "mir_st500_voc", "enstdrums_dtp",
+            "guitarset_minus_funk"
+        ],
+        "weights": [0.2, 0.2, 0.2, 0.2, 0.2],
+        "eval_vocab": [None] * 5,  # None means instrument-agnostic F1 for each dataset
+        "eval_drum_vocab": drum_vocab_presets["ksh"],  # for drums, kick-snare-hihat metric
+        "val_max_num_files": 20,  # max 20 files per dataset
+        "test_max_num_files": None,
+    },
+    "all_gt_cv2": {
+        "presets": [
+            "slakh", "musicnet_thickstun_em", "mir_st500_voc", "enstdrums_dtp", "guitarset_minus_ss"
+        ],
+        "weights": [0.2, 0.2, 0.2, 0.2, 0.2],
+        "eval_vocab": [None] * 5,  # None means instrument-agnostic F1 for each dataset
+        "eval_drum_vocab": drum_vocab_presets["ksh"],  # for drums, kick-snare-hihat metric
+        "val_max_num_files": 20,  # max 20 files per dataset
+        "test_max_num_files": None,
+    },
+    "all_gt_cv3": {
+        "presets": [
+            "slakh", "musicnet_thickstun_em", "mir_st500_voc", "enstdrums_dtp",
+            "guitarset_minus_rock"
+        ],
+        "weights": [0.2, 0.2, 0.2, 0.2, 0.2],
+        "eval_vocab": [None] * 5,  # None means instrument-agnostic F1 for each dataset
+        "eval_drum_vocab": drum_vocab_presets["ksh"],  # for drums, kick-snare-hihat metric
+        "val_max_num_files": 20,  # max 20 files per dataset
+        "test_max_num_files": None,
+    },
+    "all_gt_cv4": {
+        "presets": [
+            "slakh", "musicnet_thickstun_em", "mir_st500_voc", "enstdrums_dtp",
+            "guitarset_minus_jazz"
+        ],
+        "weights": [0.2, 0.2, 0.2, 0.2, 0.2],
+        "eval_vocab": [None] * 5,  # None means instrument-agnostic F1 for each dataset
+        "eval_drum_vocab": drum_vocab_presets["ksh"],  # for drums, kick-snare-hihat metric
+        "val_max_num_files": 20,  # max 20 files per dataset
+        "test_max_num_files": None,
+    },
+    "all_enstdrums_random": {
+        "presets": [
+            "slakh", "musicnet_thickstun_em", "mir_st500_voc", "enstdrums_random", "guitarset"
+        ],
+        "weights": [0.2, 0.2, 0.2, 0.2, 0.2],
+        "eval_vocab": [None] * 5,  # None means instrument-agnostic F1 for each dataset
+        "eval_drum_vocab": drum_vocab_presets["ksh"],  # for drums, kick-snare-hihat metric
+        "val_max_num_files": 20,  # max 20 files per dataset
+        "test_max_num_files": None,
+    },
+    "all_plus_egmd": {
+        "presets": [
+            "slakh", "musicnet_thickstun_em", "mir_st500_voc", "enstdrums_random_plus_dtd",
+            "guitarset", "egmd"
+        ],
+        "weights": [0.2, 0.2, 0.2, 0.1, 0.1, 0.2],
+        "eval_vocab": [None] * 6,  # None means instrument-agnostic F1 for each dataset
+        "eval_drum_vocab": drum_vocab_presets["ksh"],  # for drums, kick-snare-hihat metric
+        "val_max_num_files": 20,  # max 20 files per dataset
+        "test_max_num_files": None,
+    },
+    "all_dtp_egmd": {
+        "presets": [
+            "slakh", "musicnet_thickstun_em", "mir_st500_voc", "enstdrums_dtp", "guitarset", "egmd"
+        ],
+        "weights": [0.2, 0.2, 0.2, 0.1, 0.1, 0.2],
+        "eval_vocab": [None] * 6,  # None means instrument-agnostic F1 for each dataset
+        "eval_drum_vocab": drum_vocab_presets["ksh"],  # for drums, kick-snare-hihat metric
+        "val_max_num_files": 20,  # max 20 files per dataset
+        "test_max_num_files": None,
+    },
+    "all_weighted_slakh": {
+        "presets": [
+            "slakh", "musicnet_thickstun_em", "mir_st500_voc", "enstdrums_dtp", "guitarset_pshift", "egmd"
+        ],
+        "weights": [0.5, 0.1, 0.1, 0.05, 0.05, 0.2],
+        "eval_vocab": [None] * 6,  # None means instrument-agnostic F1 for each dataset
+        "eval_drum_vocab": drum_vocab_presets["ksh"],  # for drums, kick-snare-hihat metric
+        "val_max_num_files": 20,  # max 20 files per dataset
+        "test_max_num_files": None,
+    },
+    "all_weighted_mt3": { # for comparison with MT3
+        "presets": [
+            "slakh", "musicnet_mt3", "mir_st500_voc", "enstdrums_dtp",
+            "guitarset_progression_pshift", "egmd"
+        ],
+        "weights": [0.5, 0.1, 0.1, 0.05, 0.05, 0.2],
+        "eval_vocab": [None] * 6,  # None means instrument-agnostic F1 for each dataset
+        "eval_drum_vocab": drum_vocab_presets["ksh"],  # for drums, kick-snare-hihat metric
+        "val_max_num_files": 20,  # max 20 files per dataset
+        "test_max_num_files": None,
+    },
+    "all_weighted_mt3_em": { # musicnet_mt3_em
+        "presets": [
+            "slakh", "musicnet_mt3_em", "mir_st500_voc", "enstdrums_dtp",
+            "guitarset_progression_pshift", "egmd"
+        ],
+        "weights": [0.5, 0.1, 0.1, 0.05, 0.05, 0.2],
+        "eval_vocab": [None] * 6,  # None means instrument-agnoßstic F1 for each dataset
+        "eval_drum_vocab": drum_vocab_presets["ksh"],  # for drums, kick-snare-hihat metric
+        "val_max_num_files": 20,  # max 20 files per dataset
+        "test_max_num_files": None,
+    },
+    "all_urmp": {
+        "presets": [
+            "slakh", "musicnet_thickstun_em", "mir_st500_voc", "enstdrums_dtp",
+            "guitarset_pshift", "egmd", "urmp"
+        ],
+        "weights": [0.5, 0.2, 0.1, 0.05, 0.05, 0.05, 0.1],
+        "eval_vocab": [None] * 7,  # None means instrument-agnostic F1 for each dataset
+        "eval_drum_vocab": drum_vocab_presets["ksh"],  # for drums, kick-snare-hihat metric
+        "val_max_num_files": 20,  # max 20 files per dataset
+        "test_max_num_files": None,
+    },
+    "all_urmp_mt3": { # for comparison with MT3 including URMP
+        "presets": [
+            "slakh", "musicnet_mt3", "mir_st500_voc", "enstdrums_dtp",
+            "guitarset_progression", "egmd", "urmp"
+        ],
+        "weights": [0.5, 0.2, 0.1, 0.05, 0.05, 0.0125, 0.1],
+        "eval_vocab": [None] * 7,  # None means instrument-agnostic F1 for each dataset
+        "eval_drum_vocab": drum_vocab_presets["ksh"],  # for drums, kick-snare-hihat metric
+        "val_max_num_files": 20,  # max 20 files per dataset
+        "test_max_num_files": None,
+    },
+    "all_urmp_mt3_em": { # musicnet_mt3_em including URMP
+        "presets": [
+            "slakh", "musicnet_mt3_em", "mir_st500_voc", "enstdrums_dtp",
+            "guitarset_progression", "egmd", "urmp"
+        ],
+        "weights": [0.5, 0.2, 0.1, 0.05, 0.05, 0.0125, 0.1],
+        "eval_vocab": [None] * 7,  # None means instrument-agnostic F1 for each dataset
+        "eval_drum_vocab": drum_vocab_presets["ksh"],  # for drums, kick-snare-hihat metric
+        "val_max_num_files": 20,  # max 20 files per dataset
+        "test_max_num_files": None,
+    },
+    "all_maestro": { # including Mestro and URMP
+        "presets": [
+            "slakh", "musicnet_thickstun_em", "mir_st500_voc", "enstdrums_dtp",
+            "guitarset_pshift", "egmd", "urmp", "maestro"
+        ],
+        "weights": [0.5, 0.1, 0.125, 0.075, 0.025, 0.01, 0.1, 0.1],
+        "eval_vocab": [None] * 8,  # None means instrument-agnostic F1 for each dataset
+        "eval_drum_vocab": drum_vocab_presets["ksh"],  # for drums, kick-snare-hihat metric
+        "val_max_num_files": 20,  # max 20 files per dataset
+        "test_max_num_files": None,
+    },
+    "all_maestro_mt3": { # for comparison with MT3 including URMP
+        "presets": [
+            "slakh", "musicnet_mt3", "mir_st500_voc", "enstdrums_dtp",
+            "guitarset_progression", "egmd", "urmp", "maestro"
+        ],
+        "weights": [0.5, 0.1, 0.1, 0.05, 0.05, 0.0125, 0.1, 0.1],
+        "eval_vocab": [None] * 8,  # None means instrument-agnostic F1 for each dataset
+        "eval_drum_vocab": drum_vocab_presets["ksh"],  # for drums, kick-snare-hihat metric
+        "val_max_num_files": 20,  # max 20 files per dataset
+        "test_max_num_files": None,
+    },
+    "all_maestro_mt3_em": { # musicnet_mt3_em including URMP
+        "presets": [
+            "slakh", "musicnet_mt3_em", "mir_st500_voc", "enstdrums_dtp",
+            "guitarset_progression", "egmd", "urmp", "maestro"
+        ],
+        "weights": [0.5, 0.1, 0.1, 0.05, 0.05, 0.0125, 0.1, 0.1],
+        "eval_vocab": [None] * 8,  # None means instrument-agnostic F1 for each dataset
+        "eval_drum_vocab": drum_vocab_presets["ksh"],  # for drums, kick-snare-hihat metric
+        "val_max_num_files": 20,  # max 20 files per dataset
+        "test_max_num_files": None,
+    },
+    "singing_v1": { # slakh + mir_st500 without spleeter
+        "presets": ["slakh", "mir_st500"],
+        "weights": [0.8, 0.2],
+        "eval_vocab": [None, SINGING_SOLO_CLASS],  # None means instrument-agnostic F1 for each dataset
+        "eval_drum_vocab": drum_vocab_presets["ksh"],  # for drums, kick-snare-hihat metric
+        "val_max_num_files": 20,  # max 20 files per dataset
+        "test_max_num_files": None,
+    },
+    "all_singing_v1": { # for singing-only task
+        "presets": [
+            "slakh", "musicnet_thickstun_em", "mir_st500_stem", "enstdrums_dtp",
+            "guitarset_pshift", "egmd", "urmp", "maestro"
+        ],
+        "weights": [0.5, 0.1, 0.1, 0.05, 0.05, 0.0125, 0.1, 0.1],
+        "eval_vocab": [None, None, SINGING_SOLO_CLASS, None, None, None, None, None],  # None means instrument-agnostic F1 for each dataset
+        "eval_drum_vocab": drum_vocab_presets["ksh"],  # for drums, kick-snare-hihat metric
+        "val_max_num_files": 20,  # max 20 files per dataset
+        "test_max_num_files": None,
+    },
+    "all_singing_drum_v1": { # for singing-only and drum-only tasks
+        "presets": [
+            "slakh", "musicnet_thickstun_em", "mir_st500_stem", "enstdrums_dtm",
+            "guitarset_pshift", "egmd", "urmp", "maestro"
+        ],
+        "weights": [0.5, 0.1, 0.1, 0.05, 0.05, 0.0125, 0.1, 0.1],
+        "eval_vocab": [None, None, SINGING_SOLO_CLASS, None, None, None, None, None],  # None means instrument-agnostic F1 for each dataset
+        "eval_drum_vocab": drum_vocab_presets["ksh"],  # for drums, kick-snare-hihat metric
+        "val_max_num_files": 20,  # max 20 files per dataset
+        "test_max_num_files": None,
+    },
+    "all_cross": { # including Mestro and URMP
+        "presets": [
+            "slakh", "musicnet_thickstun_em", "mir_st500_voc", "enstdrums_dtp",
+            "guitarset_pshift", "egmd", "urmp", "maestro"
+        ],
+        "weights": [0.5, 0.1, 0.125, 0.075, 0.025, 0.01, 0.1, 0.1],
+        "eval_vocab": [None, None, SINGING_SOLO_CLASS, None, None, None, None, None],  # None means instrument-agnostic F1 for each dataset
+        "eval_drum_vocab": drum_vocab_presets["ksh"],  # for drums, kick-snare-hihat metric
+        "val_max_num_files": 20,  # max 20 files per dataset
+        "test_max_num_files": None,
+    },
+    "all_cross_rebal": { # rebalanced for cross-augment, using spleeter
+        "presets": [
+            "slakh", "musicnet_thickstun_em", "mir_st500_voc", "enstdrums_dtp",
+            "guitarset_pshift", "egmd", "urmp", "maestro"
+        ],
+        "weights": [0.4, 0.15, 0.15, 0.075, 0.025, 0.01, 0.1, 0.1],
+        "eval_vocab": [None, None, SINGING_SOLO_CLASS, None, None, None, None, None],  # None means instrument-agnostic F1 for each dataset
+        "eval_drum_vocab": drum_vocab_presets["ksh"],  # for drums, kick-snare-hihat metric
+        "val_max_num_files": 20,  # max 20 files per dataset
+        "test_max_num_files": None,
+    },
+    "all_cross_rebal2": { # rebalanced for cross-augment, using spleeter
+        "presets": [
+            "slakh", "musicnet_thickstun_em", "mir_st500_voc", "enstdrums_dtp",
+            "guitarset_pshift", "egmd", "urmp", "maestro"
+        ],
+        "weights": [0.275, 0.19, 0.19, 0.1, 0.025, 0.02, 0.1, 0.1],
+        "eval_vocab": [None, None, SINGING_SOLO_CLASS, None, None, None, None, None],  # None means instrument-agnostic F1 for each dataset
+        "eval_drum_vocab": drum_vocab_presets["ksh"],  # for drums, kick-snare-hihat metric
+        "val_max_num_files": 20,  # max 20 files per dataset
+        "test_max_num_files": None,
+    },
+    "all_cross_rebal4": { # rebalanced for cross-augment, using spleeter
+        "presets": [
+            "slakh", "musicnet_thickstun_em", "mir_st500_voc", "enstdrums_dtp",
+            "guitarset_pshift", "egmd", "urmp", "maestro"
+        ],
+        "weights": [0.258, 0.19, 0.2, 0.125, 0.022, 0.005, 0.1, 0.1],
+        "eval_vocab": [None, None, SINGING_SOLO_CLASS, None, None, None, None, None],  # None means instrument-agnostic F1 for each dataset
+        "eval_drum_vocab": drum_vocab_presets["ksh"],  # for drums, kick-snare-hihat metric
+        "val_max_num_files": 20,  # max 20 files per dataset
+        "test_max_num_files": None,
+    },
+    "all_cross_rebal5": { # rebalanced for cross-augment, using spleeter
+        "presets": [
+            "slakh", "musicnet_thickstun_em", "mir_st500_voc", "enstdrums_dtp",
+            "guitarset_pshift", "egmd", "urmp", "maestro"
+        ],
+        "weights": [0.295, 0.19, 0.24, 0.05, 0.02, 0.005, 0.1, 0.1],
+        "eval_vocab": [None, None, SINGING_SOLO_CLASS, None, None, None, None, None],  # None means instrument-agnostic F1 for each dataset
+        "eval_drum_vocab": drum_vocab_presets["ksh"],  # for drums, kick-snare-hihat metric
+        "val_max_num_files": 20,  # max 20 files per dataset
+        "test_max_num_files": None,
+    },
+    "all_cross_stem": { # accomp stem for sub-task learning + rebalanced for cross-augment
+        "presets": [
+            "slakh", "musicnet_thickstun_em", "mir_st500_stem", "enstdrums_dtm",
+            "guitarset_pshift", "egmd", "urmp", "maestro"
+        ],
+        "weights": [0.4, 0.15, 0.15, 0.075, 0.025, 0.01, 0.1, 0.1],
+        "eval_vocab": [None, None, SINGING_SOLO_CLASS, None, None, None, None, None],  # None means instrument-agnostic F1 for each dataset
+        "eval_drum_vocab": drum_vocab_presets["ksh"],  # for drums, kick-snare-hihat metric
+        "val_max_num_files": 20,  # max 20 files per dataset
+        "test_max_num_files": None,
+    },
+    "all_cross_stem_rebal3": { # accomp stem for sub-task learning + rebalanced for cross-augment
+        "presets": [
+            "slakh", "musicnet_thickstun_em", "mir_st500_stem", "enstdrums_dtm",
+            "guitarset_pshift", "egmd", "urmp", "maestro"
+        ],
+        "weights": [0.265, 0.18, 0.21, 0.1, 0.025, 0.02, 0.1, 0.1],
+        "eval_vocab": [None, None, SINGING_SOLO_CLASS, None, None, None, None, None],  # None means instrument-agnostic F1 for each dataset
+        "eval_drum_vocab": drum_vocab_presets["ksh"],  # for drums, kick-snare-hihat metric
+        "val_max_num_files": 20,  # max 20 files per dataset
+        "test_max_num_files": None,
+    },
+    "all_cross_v6": { # +cmeida +idmt_smt_bass
+        "presets": [
+            "slakh", "musicnet_thickstun_em", "mir_st500_voc", "enstdrums_dtp",
+            "guitarset", "egmd", "urmp", "maestro", "idmt_smt_bass", "cmedia_voc",
+        ],
+        "weights": [0.295, 0.19, 0.19, 0.05, 0.01, 0.005, 0.1, 0.1, 0.01, 0.05],
+        "eval_vocab": [None, None, SINGING_SOLO_CLASS, None, None, None, None, None, BASS_SOLO_CLASS, SINGING_SOLO_CLASS],  # None means instrument-agnostic F1 for each dataset
+        "eval_drum_vocab": drum_vocab_presets["ksh"],  # for drums, kick-snare-hihat metric
+        "val_max_num_files": 20,  # max 20 files per dataset
+        "test_max_num_files": None,
+    },
+    "all_cross_v6_geerdes": { # +geerdes_half
+        "presets": [
+            "slakh", "musicnet_thickstun_em", "mir_st500_voc", "enstdrums_dtp",
+            "guitarset", "egmd", "urmp", "maestro", "idmt_smt_bass", "cmedia_voc",
+            "geerdes_half", "geerdes_half_sep"
+        ],
+        "weights": [0.295, 0.19, 0.19, 0.05, 0.01, 0.005, 0.075, 0.075, 0.01, 0.05, 0.025, 0.025],
+        "eval_vocab": [None, None, SINGING_SOLO_CLASS, None, None, None, None, None, BASS_SOLO_CLASS,
+            SINGING_SOLO_CLASS, GM_INSTR_CLASS_PLUS, GM_INSTR_CLASS_PLUS],  # None means instrument-agnostic F1 for each dataset
+        "eval_drum_vocab": drum_vocab_presets["ksh"],  # for drums, kick-snare-hihat metric
+        "val_max_num_files": 20,  # max 20 files per dataset
+        "test_max_num_files": None,
+    },
+    "all_cross_v6_geerdes_rebal": { # +geerdes_half
+            "presets": [
+                "slakh", "musicnet_thickstun_em", "mir_st500_voc", "enstdrums_dtp",
+                "guitarset", "egmd", "urmp", "maestro", "idmt_smt_bass", "cmedia_voc",
+                "geerdes_half", "geerdes_half_sep"
+            ],
+            "weights": [0.245, 0.175, 0.19, 0.05, 0.01, 0.005, 0.075, 0.05, 0.01, 0.05, 0.075, 0.075],
+            "eval_vocab": [None, None, SINGING_SOLO_CLASS, None, None, None, None, None, BASS_SOLO_CLASS,
+                SINGING_SOLO_CLASS, GM_INSTR_EXT_CLASS_PLUS, GM_INSTR_EXT_CLASS_PLUS],  # None means instrument-agnostic F1 for each dataset
+            "eval_drum_vocab": drum_vocab_presets["ksh"],  # for drums, kick-snare-hihat metric
+            "val_max_num_files": 20,  # max 20 files per dataset
+            "test_max_num_files": None,
+        },
+   "all_cross_v7": {
+        "presets": [
+            "slakh", "musicnet_thickstun_em", "mir_st500_voc", "enstdrums_dtp",
+            "guitarset_progression_pshift", "egmd", "urmp", "maestro", "idmt_smt_bass", "cmedia_voc",
+        ],
+        "weights": [0.295, 0.19, 0.191, 0.05, 0.01, 0.004, 0.1, 0.1, 0.01, 0.05],
+        "eval_vocab": [None, None, SINGING_SOLO_CLASS, None, None, None, None, None, BASS_SOLO_CLASS, SINGING_SOLO_CLASS],  # None means instrument-agnostic F1 for each dataset
+        "eval_drum_vocab": drum_vocab_presets["ksh"],  # for drums, kick-snare-hihat metric
+        "val_max_num_files": 20,  # max 20 files per dataset
+        "test_max_num_files": None,
+    },
+   "all_cross_final": {
+        "presets": [
+            "slakh_final", "musicnet_thickstun_em", "mir_st500_voc", "enstdrums_dtp",
+            "guitarset_progression_pshift", "egmd", "urmp", "maestro_final", "idmt_smt_bass", "cmedia_voc",
+        ],
+        "weights": [0.295, 0.19, 0.191, 0.05, 0.01, 0.004, 0.1, 0.1, 0.01, 0.05],
+        "eval_vocab": [None, None, SINGING_SOLO_CLASS, None, None, None, None, None, BASS_SOLO_CLASS, SINGING_SOLO_CLASS],  # None means instrument-agnostic F1 for each dataset
+        "eval_drum_vocab": drum_vocab_presets["ksh"],  # for drums, kick-snare-hihat metric
+        "val_max_num_files": 20,  # max 20 files per dataset
+        "test_max_num_files": None,
+    },
+    "all_eval_final": { # The final evaluation set
+        "presets": [
+            "slakh", "musicnet_thickstun", "musicnet_thickstun_em", "musicnet_thickstun_ext",
+            "musicnet_thickstun_ext_em", "mir_st500_voc", "mir_st500", "enstdrums_dtp",
+            "enstdrums_dtm", "guitarset_progression_pshift", "rwc_pop_bass", "maestro", "urmp",
+            "maps_default", "rwc_pop_full", # "geerdes", "geerdes_sep",
+        ],
+        "eval_vocab": [
+            GM_INSTR_CLASS, MUSICNET_INSTR_CLASS, MUSICNET_INSTR_CLASS, MUSICNET_INSTR_CLASS,
+            MUSICNET_INSTR_CLASS, SINGING_SOLO_CLASS, SINGING_SOLO_CLASS, None,
+            None, None, BASS_SOLO_CLASS, PIANO_SOLO_CLASS, GM_INSTR_CLASS,
+            PIANO_SOLO_CLASS, GM_INSTR_CLASS_PLUS, # GM_INSTR_CLASS_PLUS, GM_INSTR_CLASS_PLUS
+        ],
+        "eval_drum_vocab": drum_vocab_presets["ksh"],
+    },
+    "geerdes_eval": { # Geerdes evaluation sets for models trained without Geerdes.
+        "presets": ["geerdes_sep", "geerdes"],
+        "eval_vocab": [GM_INSTR_CLASS_PLUS, GM_INSTR_CLASS_PLUS],
+        "eval_drum_vocab": drum_vocab_presets["gm"],
+    },
+    "geerdes_half_eval": { # Geerdes evaluation sets for models trained with Geerdes-half
+        "presets": ["geerdes_half_sep", "geerdes_half"],
+        "eval_vocab": [GM_INSTR_CLASS_PLUS, GM_INSTR_CLASS_PLUS],
+        "eval_drum_vocab": drum_vocab_presets["gm"],
+    },
+    "minimal": { # slakh + mir_st500 with spleeter
+        "presets": ["slakh", "mir_st500_voc"],
+        "weights": [0.8, 0.2],
+        "eval_vocab": [None, SINGING_SOLO_CLASS],  # None means instrument-agnostic F1 for each dataset
+        "eval_drum_vocab": drum_vocab_presets["ksh"],  # for drums, kick-snare-hihat metric
+        "val_max_num_files": 20,  # max 20 files per dataset
+        "test_max_num_files": None,
+    },
+    "singing_debug": { # slakh + mir_st500 with spleeter
+        "presets": ["mir_st500_voc_debug"],
+        "weights": [1.0],
+        "eval_vocab": [SINGING_SOLO_CLASS],  # None means instrument-agnostic F1 for each dataset
+        "eval_drum_vocab": drum_vocab_presets["ksh"],  # for drums, kick-snare-hihat metric
+        "val_max_num_files": 20,  # max 20 files per dataset
+        "test_max_num_files": None,
+    },
+}

config/vocabulary.py

@@ -0,0 +1,384 @@
+# Copyright 2024 The YourMT3 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
+#
+# Please see the details in the LICENSE file.
+"""vocabulary.py 
+
+Vocabulary for instrument classes. Vocabulary can be used as train_vocab
+or test_vocab in data_presets.py or train.py arguments.
+
+- When it is used as train_vocab, it maps the instrument classes to the first
+  program number of the class. For example, if you use 'GM_INSTR_CLASS' as
+  train_vocab, then the program number of 'Piano' is [0,1,2,3,4,5,6,7]. These
+  program numbers are trained as program [0] in the model.
+
+  - When it is used as eval_vocab, any program number in the instrument class 
+  is considered as correct.
+
+  
+MUSICNET_INSTR_CLASS: 3 classes used for MusicNet benchmark
+GM_INSTR_CLASS: equivalent to 'MIDI Class' defined by MT3. 
+GM_INSTR_CLASS_PLUS: GM_INSTR_CLASS + singing voice
+GM_INSTR_FULL: 128 GM instruments, which is extended from 'MT3_FULL'
+MT3_FULL: this matches the class names in Table 3 of MT3 paper
+ENST_DRUM_NOTES: 20 drum notes used in ENST dataset
+GM_DRUM_NOTES: 45 GM drum notes with percussions
+
+Program 128 is reserved for 'drum' internally.
+Program 129 is reserved for 'unannotated', internally.
+Program 100 is reserved for 'singing voice (melody)' in GM_INSTR_CLASS_PLUS.
+Program 101 is reserved for 'singing voice (chorus)' in GM_INSTR_CLASS_PLUS.
+
+
+"""
+# yapf: disable
+import numpy as np
+
+PIANO_SOLO_CLASS = {
+    "Piano": np.arange(0, 8),
+}
+
+GUITAR_SOLO_CLASS = {
+    "Guitar": np.arange(24, 32),
+}
+
+SINGING_SOLO_CLASS = {
+    "Singing Voice": [100, 101],
+}
+
+SINGING_CHORUS_SEP_CLASS = {
+    "Singing Voice": [100],
+    "Singing Voice (chorus)": [101],
+}
+
+BASS_SOLO_CLASS = {
+    "Bass": np.arange(32, 40),
+}
+
+MUSICNET_INSTR_CLASS = {
+    "Piano": np.arange(0, 8),
+    "Strings": np.arange(40, 52),  # Solo strings + ensemble strings
+    "Winds": np.arange(64, 80),  # Reed + Pipe
+}
+
+GM_INSTR_CLASS = {
+    "Piano": np.arange(0, 8),
+    "Chromatic Percussion": np.arange(8, 16),
+    "Organ": np.arange(16, 24),
+    "Guitar": np.arange(24, 32),
+    "Bass": np.arange(32, 40),
+    "Strings": np.arange(40, 56),  # Strings + Ensemble
+    # "Strings": np.arange(40, 48),
+    # "Ensemble": np.arange(48, 56),
+    "Brass": np.arange(56, 64),
+    "Reed": np.arange(64, 72),
+    "Pipe": np.arange(72, 80),
+    "Synth Lead": np.arange(80, 88),
+    "Synth Pad": np.arange(88, 96),
+}
+
+GM_INSTR_CLASS_PLUS = GM_INSTR_CLASS.copy()
+GM_INSTR_CLASS_PLUS["Singing Voice"] = [100, 101]
+
+GM_INSTR_EXT_CLASS = { # Best for enjoyable MIDI file generation
+    "Acoustic Piano": [0, 1, 3, 6, 7],
+    "Electric Piano": [2, 4, 5],
+    "Chromatic Percussion": np.arange(8, 16),
+    "Organ": np.arange(16, 24),
+    "Guitar (clean)": np.arange(24, 28),
+    "Guitar (distortion)": [30, 28, 29, 31], # np.arange(28, 32),
+    "Bass": [33, 32, 34, 35, 36, 37, 38, 39], # np.arange(32, 40),
+    "Strings": [48, 40, 41, 42, 43, 44, 45, 46, 47, 49, 50, 51, 52, 53, 54, 55], # np.arange(40, 56),
+    "Brass": np.arange(56, 64),
+    "Reed": np.arange(64, 72),
+    "Pipe": np.arange(72, 80),
+    "Synth Lead": np.arange(80, 88),
+    "Synth Pad": np.arange(88, 96),
+}
+GM_INSTR_EXT_CLASS_PLUS = GM_INSTR_EXT_CLASS.copy()
+GM_INSTR_EXT_CLASS_PLUS["Singing Voice"] = [100]
+GM_INSTR_EXT_CLASS_PLUS["Singing Voice (chorus)"] = [101]
+
+GM_INSTR_FULL = {
+    "Acoustic Grand Piano": [0],
+    "Bright Acoustic Piano": [1],
+    "Electric Grand Piano": [2],
+    "Honky-tonk Piano": [3],
+    "Electric Piano 1": [4],
+    "Electric Piano 2": [5],
+    "Harpsichord": [6],
+    "Clavinet": [7],
+    "Celesta": [8],
+    "Glockenspiel": [9],
+    "Music Box": [10],
+    "Vibraphone": [11],
+    "Marimba": [12],
+    "Xylophone": [13],
+    "Tubular Bells": [14],
+    "Dulcimer": [15],
+    "Drawbar Organ": [16],
+    "Percussive Organ": [17],
+    "Rock Organ": [18],
+    "Church Organ": [19],
+    "Reed Organ": [20],
+    "Accordion": [21],
+    "Harmonica": [22],
+    "Tango Accordion": [23],
+    "Acoustic Guitar (nylon)": [24],
+    "Acoustic Guitar (steel)": [25],
+    "Electric Guitar (jazz)": [26],
+    "Electric Guitar (clean)": [27],
+    "Electric Guitar (muted)": [28],
+    "Overdriven Guitar": [29],
+    "Distortion Guitar": [30],
+    "Guitar Harmonics": [31],
+    "Acoustic Bass": [32],
+    "Electric Bass (finger)": [33],
+    "Electric Bass (pick)": [34],
+    "Fretless Bass": [35],
+    "Slap Bass 1": [36],
+    "Slap Bass 2": [37],
+    "Synth Bass 1": [38],
+    "Synth Bass 2": [39],
+    "Violin": [40],
+    "Viola": [41],
+    "Cello": [42],
+    "Contrabass": [43],
+    "Tremolo Strings": [44],
+    "Pizzicato Strings": [45],
+    "Orchestral Harp": [46],
+    "Timpani": [47],
+    "String Ensemble 1": [48],
+    "String Ensemble 2": [49],
+    "Synth Strings 1": [50],
+    "Synth Strings 2": [51],
+    "Choir Aahs": [52],
+    "Voice Oohs": [53],
+    "Synth Choir": [54],
+    "Orchestra Hit": [55],
+    "Trumpet": [56],
+    "Trombone": [57],
+    "Tuba": [58],
+    "Muted Trumpet": [59],
+    "French Horn": [60],
+    "Brass Section": [61],
+    "Synth Brass 1": [62],
+    "Synth Brass 2": [63],
+    "Soprano Sax": [64],
+    "Alto Sax": [65],
+    "Tenor Sax": [66],
+    "Baritone Sax": [67],
+    "Oboe": [68],
+    "English Horn": [69],
+    "Bassoon": [70],
+    "Clarinet": [71],
+    "Piccolo": [72],
+    "Flute": [73],
+    "Recorder": [74],
+    "Pan Flute": [75],
+    "Bottle Blow": [76],
+    "Shakuhachi": [77],
+    "Whistle": [78],
+    "Ocarina": [79],
+    "Lead 1 (square)": [80],
+    "Lead 2 (sawtooth)": [81],
+    "Lead 3 (calliope)": [82],
+    "Lead 4 (chiff)": [83],
+    "Lead 5 (charang)": [84],
+    "Lead 6 (voice)": [85],
+    "Lead 7 (fifths)": [86],
+    "Lead 8 (bass + lead)": [87],
+    "Pad 1 (new age)": [88],
+    "Pad 2 (warm)": [89],
+    "Pad 3 (polysynth)": [90],
+    "Pad 4 (choir)": [91],
+    "Pad 5 (bowed)": [92],
+    "Pad 6 (metallic)": [93],
+    "Pad 7 (halo)": [94],
+    "Pad 8 (sweep)": [95],
+    # "FX 1 (rain)": [96],
+    # "FX 2 (soundtrack)": [97],
+    # "FX 3 (crystal)": [98],
+    # "FX 4 (atmosphere)": [99],
+    # "FX 5 (brightness)": [100],
+    # "FX 6 (goblins)": [101],
+    # "FX 7 (echoes)": [102],
+    # "FX 8 (sci-fi)": [103],
+    # "Sitar": [104],
+    # "Banjo": [105],
+    # "Shamisen": [106],
+    # "Koto": [107],
+    # "Kalimba": [108],
+    # "Bagpipe": [109],
+    # "Fiddle": [110],
+    # "Shanai": [111],
+    # "Tinkle Bell": [112],
+    # "Agogo": [113],
+    # "Steel Drums": [114],
+    # "Woodblock": [115],
+    # "Taiko Drum": [116],
+    # "Melodic Tom": [117],
+    # "Synth Drum": [118],
+    # "Reverse Cymbal": [119],
+    # "Guitar Fret Noise": [120],
+    # "Breath Noise": [121],
+    # "Seashore": [122],
+    # "Bird Tweet": [123],
+    # "Telephone Ring": [124],
+    # "Helicopter": [125],
+    # "Applause": [126],
+    # "Gunshot": [127]
+}
+
+MT3_FULL = { # this matches the class names in Table 3 of MT3 paper 
+    "Acoustic Piano": [0, 1, 3, 6, 7],
+    "Electric Piano": [2, 4, 5],
+    "Chromatic Percussion": np.arange(8, 16),
+    "Organ": np.arange(16, 24),
+    "Acoustic Guitar": np.arange(24, 26),
+    "Clean Electric Guitar": np.arange(26, 29),
+    "Distorted Electric Guitar": np.arange(29, 32),
+    "Acoustic Bass": [32, 35],
+    "Electric Bass": [33, 34, 36, 37, 38, 39],
+    "Violin": [40],
+    "Viola": [41],
+    "Cello": [42],
+    "Contrabass": [43],
+    "Orchestral Harp": [46],
+    "Timpani": [47],
+    "String Ensemble": [48, 49, 44, 45],
+    "Synth Strings": [50, 51],
+    "Choir and Voice": [52, 53, 54],
+    "Orchestra Hit": [55],
+    "Trumpet": [56, 59],
+    "Trombone": [57],
+    "Tuba": [58],
+    "French Horn": [60],
+    "Brass Section": [61, 62, 63],
+    "Soprano/Alto Sax": [64, 65],
+    "Tenor Sax": [66],
+    "Baritone Sax": [67],
+    "Oboe": [68],
+    "English Horn": [69],
+    "Bassoon": [70],
+    "Clarinet": [71],
+    "Pipe": [73, 72, 74, 75, 76, 77, 78, 79],
+    "Synth Lead": np.arange(80, 88),
+    "Synth Pad": np.arange(88, 96),
+}
+
+MT3_FULL_PLUS = MT3_FULL.copy()
+MT3_FULL_PLUS["Singing Voice"] = [100]
+MT3_FULL_PLUS["Singing Voice (chorus)"] = [101]
+
+ENST_DRUM_NOTES = {
+    "bd": [36],  # Kick Drum
+    "sd": [38],  # Snare Drum
+    "sweep": [0],  # Brush sweep
+    "sticks": [1],  # Sticks
+    "rs": [2],  # Rim shot
+    "cs": [37],  # X-stick
+    "chh": [42],  # Closed Hi-Hat
+    "ohh": [46],  # Open Hi-Hat
+    "cb": [56],  # Cowbell
+    "c": [3],  # Other Cymbals
+    "lmt": [47],  # Low Mid Tom
+    "mt": [48],  # Mid Tom
+    "mtr": [58],  # Mid Tom Rim
+    "lt": [45],  # Low Tom
+    "ltr": [50],  # Low Tom Rim
+    "lft": [41],  # Low Floor Tom
+    "rc": [51],  # Ride Cymbal
+    "ch": [52],  # Chinese Cymbal
+    "cr": [49],  # Crash Cymbal
+    "spl": [55],  # Splash Cymbal
+}
+
+EGMD_DRUM_NOTES = {
+    "Kick Drum": [36],  # Listed by order of most common annotation
+    "Snare X-stick": [37],  # Snare X-Stick, https://youtu.be/a2KFrrKaoYU?t=80
+    "Snare Drum": [38],  # Snare (head) and Electric Snare
+    "Closed Hi-Hat": [42, 44, 22],  # 44 is pedal hi-hat
+    "Open Hi-Hat": [46, 26],
+    "Cowbell": [56],
+    "High Floor Tom": [43],
+    "Low Floor Tom": [41],  # Lowest Tom
+    "Low Tom": [45],
+    "Low-Mid Tom": [47],
+    "Mid Tom": [48],
+    "Low Tom (Rim)": [50],  # TD-17: 47, 50, 58  
+    "Mid Tom (Rim)": [58],
+    # "Ride Cymbal": [51, 53, 59],
+    "Ride": [51],
+    "Ride (Bell)": [53],  # https://youtu.be/b94hZoM5s3k?t=323
+    "Ride (Edge)": [59],
+    "Chinese Cymbal": [52],
+    "Crash Cymbal": [49, 57],
+    "Splash Cymbal": [55],
+}
+
+# Inspired by Roland TD-17 MIDI note map, https://rolandus.zendesk.com/hc/en-us/articles/360005173411-TD-17-Default-Factory-MIDI-Note-Map
+GM_DRUM_NOTES = {
+    "Kick Drum": [36, 35],  # Listed by order of most common annotation
+    "Snare X-stick": [37, 2],  # Snare X-Stick, https://youtu.be/a2KFrrKaoYU?t=80
+    "Snare Drum": [38, 40],  # Snare (head) and Electric Snare
+    "Closed Hi-Hat": [42, 44, 22],  # 44 is pedal hi-hat
+    "Open Hi-Hat": [46, 26],
+    "Cowbell": [56],
+    "High Floor Tom": [43],
+    "Low Floor Tom": [41],  # Lowest Tom
+    "Low Tom": [45],
+    "Low-Mid Tom": [47],
+    "Mid Tom": [48],
+    "Low Tom (Rim)": [50],  # TD-17: 47, 50, 58  
+    "Mid Tom (Rim)": [58],
+    # "Ride Cymbal": [51, 53, 59],
+    "Ride": [51],
+    "Ride (Bell)": [53],  # https://youtu.be/b94hZoM5s3k?t=323
+    "Ride (Edge)": [59],
+    "Chinese Cymbal": [52],
+    "Crash Cymbal": [49, 57],
+    "Splash Cymbal": [55],
+}
+
+KICK_SNARE_HIHAT = {
+    "Kick Drum": [36, 35],
+    "Snare Drum": [38, 40],
+    # "Snare Drum + X-Stick": [38, 40, 37, 2],
+    # "Snare X-stick": [37, 2],  # Snare X-Stick, https://youtu.be/a2KFrrKaoYU?t=80
+    "Hi-Hat": [42, 44, 46, 22, 26],
+    # "Ride Cymbal": [51, 53, 59],
+    # "Hi-Hat + Ride": [42, 44, 46, 22, 26, 51, 53, 59],
+    # "HiHat + all Cymbals": [42, 44, 46, 22, 26, 51, 53, 59, 52, 49, 57, 55],
+    # "Kick Drum + Low Tom": [36, 35, 45],
+    # "All Cymbal": [51, 53, 59, 52, 49, 57, 55]
+    # "all": np.arange(30, 60)
+}
+
+drum_vocab_presets = {
+    "gm": GM_DRUM_NOTES,
+    "egmd": EGMD_DRUM_NOTES,
+    "enst": ENST_DRUM_NOTES,
+    "ksh": KICK_SNARE_HIHAT,
+    "kshr": {
+        "Kick Drum": [36, 35],
+        "Snare Drum": [38, 40],
+        "Hi-Hat": [42, 44, 46, 22, 26, 51, 53, 59],
+    }
+}
+
+program_vocab_presets = {
+    "gm_full": GM_INSTR_FULL,  # 96 classes (except drums)
+    "mt3_full": MT3_FULL,  # 34 classes (except drums) as in MT3 paper
+    "mt3_midi": GM_INSTR_CLASS,  # 11 classes (except drums) as in MT3 paper
+    "mt3_midi_plus": GM_INSTR_CLASS_PLUS,  # 11 classes + singing (except drums)
+    "mt3_full_plus": MT3_FULL_PLUS,  # 34 classes (except drums) mt3_full + singing (except drums)
+    "gm": GM_INSTR_CLASS,  # 11 classes (except drums)
+    "gm_plus": GM_INSTR_CLASS_PLUS,  # 11 classes + singing (except drums)
+    "gm_ext_plus": GM_INSTR_EXT_CLASS_PLUS,  # 13 classes + singing + chorus (except drums)
+}

extras/Dockerfile

@@ -0,0 +1,18 @@
+FROM pytorch/pytorch:2.0.1-cuda11.7-cudnn8-devel
+LABEL maintainer="https://github.com/mimbres/YourMT3" 
+
+ENV TZ=Europe/London \
+    DEBIAN_FRONTEND=noninteractive
+RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
+
+RUN apt-get update
+ENV LANG=C.UTF-8 LC_ALL=C.UTF-8
+
+RUN apt-get update --fix-missing && apt-get install -y wget curl \
+    nano git ffmpeg sox tmux htop 
+RUN pip3 install --upgrade pip
+RUN pip3 install mirdata mido git+https://github.com/craffel/mir_eval.git \
+    matplotlib lightning>=2.0.2 pytest-timeout pytest deprecated librosa \
+    einops transformers wandb
+
+CMD [ "/bin/bash" ]

extras/demo_cross_augmentation.py

@@ -0,0 +1,69 @@
+# Copyright 2024 The YourMT3 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
+#
+# Please see the details in the LICENSE file.
+from typing import Dict, Tuple
+from copy import deepcopy
+import soundfile as sf
+import torch
+from utils.data_modules import AMTDataModule
+from config.data_presets import data_preset_single_cfg, data_preset_multi_cfg
+from utils.augment import intra_stem_augment_processor
+
+
+def get_ds(data_preset_multi: Dict, train_num_samples_per_epoch: int = 90000):
+    dm = AMTDataModule(data_preset_multi=data_preset_multi, train_num_samples_per_epoch=train_num_samples_per_epoch)
+    dm.setup('fit')
+    dl = dm.train_dataloader()
+    ds = dl.flattened[0].dataset
+    return ds
+
+
+def debug_func(num_segments: int = 10):
+    sampled_data, sampled_ids = ds._get_rand_segments_from_cache(num_segments)
+    ux_sampled_data, _ = ds._get_rand_segments_from_cache(ux_count_sum, False, sampled_ids)
+    s = deepcopy(sampled_data)
+    intra_stem_augment_processor(sampled_data, submix_audio=False)
+
+
+def gen_audio(index: int = 0):
+    # audio_arr: (b, 1, nframe), note_token_arr: (b, l), task_token_arr: (b, task_l)
+    audio_arr, note_token_arr, task_token_arr = ds.__getitem__(index)
+
+    # merge all the segments into one audio file
+    audio = audio_arr.permute(0, 2, 1).reshape(-1).squeeze().numpy()
+
+    # save the audio file
+    sf.write('xaug_demo_audio.wav', audio, 16000, subtype='PCM_16')
+
+
+data_preset_multi = data_preset_multi_cfg["all_cross_rebal5"]
+ds = get_ds(data_preset_multi)
+ds.random_amp_range = [0.8, 1.1]
+ds.stem_xaug_policy = {
+    "max_k": 5,
+    "tau": 0.3,
+    "alpha": 1.0,
+    "max_subunit_stems": 12,
+    "no_instr_overlap": True,
+    "no_drum_overlap": True,
+    "uhat_intra_stem_augment": True,
+}
+gen_audio(3)
+
+# for k in ds.cache.keys():
+#     arr = ds.cache[k]['audio_array']
+#     arr = np.sum(arr, axis=1).reshape(-1)
+#     # sf.write(f'xxx/{k}.wav', arr, 16000, subtype='PCM_16')
+#     if np.min(arr) > -0.5:
+#         print(k)
+
+# arr = ds.cache[52]['audio_array']
+# for i in range(arr.shape[1]):
+#     a = arr[:, i, :].reshape(-1)
+#     sf.write(f'xxx52/52_{i}.wav', a, 16000, subtype='PCM_16')

extras/download_mirst500.py

@@ -0,0 +1,50 @@
+import os
+import json
+import numpy as np
+from pytube import YouTube
+
+
+def downloadMp3(yt, idx, askPath=0):
+    # extract only audio
+    video = yt.streams.filter(only_audio=True).first()
+
+    destination = 'mp3File'
+    # check for destination to save file
+    if (askPath == 1):
+        print("Enter the destination (leave blank for default dir mp3File)")
+        destination = str(input(">> ")) or 'mp3File'
+
+    # download the file
+    out_file = video.download(output_path=destination)
+
+    # save the file
+    # base, ext = os.path.splitext(out_file)
+    dir_path, file_base = os.path.split(out_file)
+
+    new_file = os.path.join(dir_path, f'{idx}.mp3')
+    os.rename(out_file, new_file)
+    # result of success
+    print(yt.title + " has been successfully downloaded.")
+
+
+MISSING_FILE_IDS = [
+    16, 26, 33, 38, 40, 50, 53, 55, 60, 81, 82, 98, 107, 122, 126, 127, 129, 141, 145, 150, 172,
+    201, 205, 206, 215, 216, 221, 226, 232, 240, 243, 245, 255, 257, 267, 273, 278, 279, 285, 287,
+    291, 304, 312, 319, 321, 325, 329, 332, 333, 336, 337, 342, 359, 375, 402, 417, 438, 445, 454,
+    498
+]
+
+data_link_file = '../../../data/mir_St500_yourmt3_16k/MIR-ST500_20210206/MIR-ST500_link.json'
+data_link = json.load(open(data_link_file, 'r'))
+download_fail = []
+
+for i in MISSING_FILE_IDS:
+    print(f'Downloading {i}...')
+    yt = YouTube(data_link[str(i)])
+    try:
+        downloadMp3(yt, idx=i)
+    except:
+        download_fail.append(i)
+        print(f'Failed to download {i}.')
+
+print(f'Failed to download {len(download_fail)} files: {download_fail}')

extras/inspecting_slakh_bass.py

@@ -0,0 +1,34 @@
+import mirdata
+from utils.mirdata_dev.datasets import slakh16k
+
+ds = slakh16k.Dataset(data_home='../../data', version='2100-yourmt3-16k')
+mtrack_ids = ds.mtrack_ids
+
+# Collect plugin names
+plugin_names = set()
+cnt = 0
+for mtrack_id in mtrack_ids:
+    mtrack = ds.multitrack(mtrack_id)
+    for track_id in mtrack.track_ids:
+        track = ds.track(track_id)
+        if track.instrument.lower() == 'bass':
+            if track.plugin_name == 'upright_bass.nkm':
+                print(f'{str(cnt)}: {track_id}: {track.plugin_name}')
+            # if track.plugin_name not in plugin_names:
+            #     plugin_names.add(track.plugin_name)
+            #     print(f'{str(cnt)}: {track_id}: {track.plugin_name}')
+            #     cnt += 1
+"""
+0: Track00001-S03: scarbee_rickenbacker_bass_palm_muted.nkm
+1: Track00002-S01: classic_bass.nkm
+2: Track00004-S01: scarbee_rickenbacker_bass.nkm
+3: Track00005-S04: scarbee_jay_bass_both.nkm
+4: Track00006-S03: pop_bass.nkm
+5: Track00008-S00: scarbee_pre_bass.nkm
+6: Track00013-S00: jazz_upright.nkm
+7: Track00014-S01: funk_bass.nkm
+8: Track00016-S01: scarbee_mm_bass.nkm
+9: Track00024-S07: upright_bass.nkm
+10: Track00027-S03: scarbee_jay_bass_slap_both.nkm
+11: Track00094-S08: upright_bass2.nkm
+"""

extras/rotary_positional_embedding.py

@@ -0,0 +1,191 @@
+"""rotary_positional_embedding.py - Rotary Positional Embedding
+
+code from github.com/lucidrains/rotary-embedding-torch
+
+MIT License
+"""
+
+from math import pi, log
+import torch
+from torch import nn, einsum
+from einops import rearrange, repeat
+
+
+def exists(val):
+    return val is not None
+
+
+def broadcat(tensors, dim=-1):
+    num_tensors = len(tensors)
+    shape_lens = set(list(map(lambda t: len(t.shape), tensors)))
+    assert len(shape_lens) == 1, 'tensors must all have the same number of dimensions'
+    shape_len = list(shape_lens)[0]
+
+    dim = (dim + shape_len) if dim < 0 else dim
+    dims = list(zip(*map(lambda t: list(t.shape), tensors)))
+
+    expandable_dims = [(i, val) for i, val in enumerate(dims) if i != dim]
+    assert all([*map(lambda t: len(set(t[1])) <= 2, expandable_dims)
+               ]), 'invalid dimensions for broadcastable concatentation'
+    max_dims = list(map(lambda t: (t[0], max(t[1])), expandable_dims))
+    expanded_dims = list(map(lambda t: (t[0], (t[1],) * num_tensors), max_dims))
+    expanded_dims.insert(dim, (dim, dims[dim]))
+    expandable_shapes = list(zip(*map(lambda t: t[1], expanded_dims)))
+    tensors = list(map(lambda t: t[0].expand(*t[1]), zip(tensors, expandable_shapes)))
+    return torch.cat(tensors, dim=dim)
+
+
+# rotary embedding helper functions
+def rotate_half(x):
+    x = rearrange(x, '... (d r) -> ... d r', r=2)
+    x1, x2 = x.unbind(dim=-1)
+    x = torch.stack((-x2, x1), dim=-1)
+    return rearrange(x, '... d r -> ... (d r)')
+
+
+def apply_rotary_emb(freqs, t, start_index=0, scale=1.):
+    rot_dim, seq_len = freqs.shape[-1], t.shape[-2]
+    freqs = freqs[-seq_len:, :]
+
+    freqs = freqs.to(t)
+    end_index = start_index + rot_dim
+    assert rot_dim <= t.shape[
+        -1], f'feature dimension {t.shape[-1]} is not of sufficient size to rotate in all the positions {rot_dim}'
+    t_left, t, t_right = t[..., :start_index], t[..., start_index:end_index], t[..., end_index:]
+    t = (t * freqs.cos() * scale) + (rotate_half(t) * freqs.sin() * scale)
+    return torch.cat((t_left, t, t_right), dim=-1)
+
+
+# learned rotation helpers
+def apply_learned_rotations(rotations, t, start_index=0, freq_ranges=None):
+    if exists(freq_ranges):
+        rotations = einsum('..., f -> ... f', rotations, freq_ranges)
+        rotations = rearrange(rotations, '... r f -> ... (r f)')
+
+    rotations = repeat(rotations, '... n -> ... (n r)', r=2)
+    return apply_rotary_emb(rotations, t, start_index=start_index)
+
+
+# classes
+class RotaryEmbedding(nn.Module):
+
+    def __init__(self,
+                 dim,
+                 custom_freqs=None,
+                 freqs_for='lang',
+                 theta=10000,
+                 max_freq=10,
+                 num_freqs=1,
+                 learned_freq=False,
+                 use_xpos=False,
+                 xpos_scale_base=512,
+                 interpolate_factor=1.,
+                 theta_rescale_factor=1.):
+        super().__init__()
+        # proposed by reddit user bloc97, to rescale rotary embeddings to longer sequence length without fine-tuning
+        # has some connection to NTK literature
+        # https://www.reddit.com/r/LocalLLaMA/comments/14lz7j5/ntkaware_scaled_rope_allows_llama_models_to_have/
+        theta *= theta_rescale_factor**(dim / (dim - 2))
+
+        if exists(custom_freqs):
+            freqs = custom_freqs
+        elif freqs_for == 'lang':
+            freqs = 1. / (theta**(torch.arange(0, dim, 2)[:(dim // 2)].float() / dim))
+        elif freqs_for == 'pixel':
+            freqs = torch.linspace(1., max_freq / 2, dim // 2) * pi
+        elif freqs_for == 'constant':
+            freqs = torch.ones(num_freqs).float()
+        else:
+            raise ValueError(f'unknown modality {freqs_for}')
+
+        self.cache = dict()
+        self.cache_scale = dict()
+        self.freqs = nn.Parameter(freqs, requires_grad=learned_freq)
+
+        # interpolation factors
+
+        assert interpolate_factor >= 1.
+        self.interpolate_factor = interpolate_factor
+
+        # xpos
+
+        self.use_xpos = use_xpos
+        if not use_xpos:
+            self.register_buffer('scale', None)
+            return
+
+        scale = (torch.arange(0, dim, 2) + 0.4 * dim) / (1.4 * dim)
+        self.scale_base = xpos_scale_base
+        self.register_buffer('scale', scale)
+
+    def get_seq_pos(self, seq_len, device, dtype, offset=0):
+        return (torch.arange(seq_len, device=device, dtype=dtype) +
+                offset) / self.interpolate_factor
+
+    def rotate_queries_or_keys(self, t, seq_dim=-2, offset=0, freq_seq_len=None):
+        assert not self.use_xpos, 'you must use `.rotate_queries_and_keys` method instead and pass in both queries and keys, for length extrapolatable rotary embeddings'
+
+        device, dtype, seq_len = t.device, t.dtype, t.shape[seq_dim]
+
+        if exists(freq_seq_len):
+            assert freq_seq_len >= seq_len
+            seq_len = freq_seq_len
+
+        freqs = self.forward(
+            lambda: self.get_seq_pos(seq_len, device=device, dtype=dtype, offset=offset),
+            cache_key=f'freqs:{seq_len}|offset:{offset}')
+        return apply_rotary_emb(freqs, t)
+
+    def rotate_queries_with_cached_keys(self, q, k, seq_dim=-2):
+        q_len, k_len = q.shape[seq_dim], k.shape[seq_dim]
+        assert q_len <= k_len
+        q = self.rotate_queries_or_keys(q, seq_dim=seq_dim, freq_seq_len=k_len)
+        k = self.rotate_queries_or_keys(k, seq_dim=seq_dim)
+        return q, k
+
+    def rotate_queries_and_keys(self, q, k, seq_dim=-2):
+        assert self.use_xpos
+        device, dtype, seq_len = q.device, q.dtype, q.shape[seq_dim]
+        seq = self.get_seq_pos(seq_len, dtype=dtype, device=device)
+        freqs = self.forward(lambda: seq, cache_key=f'freqs:{seq_len}')
+        scale = self.get_scale(lambda: seq, cache_key=f'scale:{seq_len}').to(dtype)
+        rotated_q = apply_rotary_emb(freqs, q, scale=scale)
+        rotated_k = apply_rotary_emb(freqs, k, scale=scale**-1)
+        return rotated_q, rotated_k
+
+    def get_scale(self, t, cache_key=None):
+        assert self.use_xpos
+
+        if exists(cache_key) and cache_key in self.cache:
+            return self.cache[cache_key]
+
+        if callable(t):
+            t = t()
+
+        scale = 1.
+        if self.use_xpos:
+            power = (t - len(t) // 2) / self.scale_base
+            scale = self.scale**rearrange(power, 'n -> n 1')
+            scale = torch.cat((scale, scale), dim=-1)
+
+        if exists(cache_key):
+            self.cache[cache_key] = scale
+
+        return scale
+
+    def forward(self, t, cache_key=None):
+        if exists(cache_key) and cache_key in self.cache:
+            return self.cache[cache_key]
+
+        if callable(t):
+            t = t()
+
+        freqs = self.freqs
+
+        freqs = einsum('..., f -> ... f', t.type(freqs.dtype), freqs)
+        freqs = repeat(freqs, '... n -> ... (n r)', r=2)
+
+        if exists(cache_key):
+            self.cache[cache_key] = freqs
+
+        return freqs

extras/run_spleeter_mirst500_cmedia.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+shopt -s globstar
+for file in "$1"/**/*.wav; do
+    output_dir="${file%/*}"
+    input_file="$output_dir/converted_Mixture.wav"
+    spleeter separate -p spleeter:2stems -o $output_dir $input_file -f {instrument}.{codec}
+    ffmpeg -i "$output_dir/vocals.wav" -acodec pcm_s16le -ac 1 -ar 16000 -y "$output_dir/vocals_16k.wav"
+    ffmpeg -i "$output_dir/accompaniment.wav" -acodec pcm_s16le -ac 1 -ar 16000 -y "$output_dir/accompaniment_16k.wav"
+    rm "$output_dir/vocals.wav"
+    rm "$output_dir/accompaniment.wav"
+    mv "$output_dir/vocals_16k.wav" "$output_dir/vocals.wav"
+    mv "$output_dir/accompaniment_16k.wav" "$output_dir/accompaniment.wav"    
+done

extras/swap_channel.py

@@ -0,0 +1,122 @@
+import numpy as np
+
+a = np.arange(12).reshape(2, 3, 2)  # (batch, channel, dim)
+print(a)
+array([[[0, 1], [2, 3], [4, 5]], [[6, 7], [8, 9], [10, 11]]])
+
+swap_mat = create_swap_channel_mat(input_shape, swap_channel=(1, 2))
+
+# will swap channel 1 and 2 of batch 0 with channel 1 and 2 of batch 1
+b = a @ swap_mat
+print(b)
+# expected output
+array([[[0, 1], [8, 9], [10, 11]], [[6, 7], [2, 3], [4, 5]]])
+
+import torch
+
+
+def swap_channels_between_batches(a_tensor, swap_channels):
+    # Copy the tensor to avoid modifying the original tensor
+    result_tensor = a_tensor.clone()
+
+    # Unpack the channels to be swapped
+    ch1, ch2 = swap_channels
+
+    # Swap the specified channels between batches
+    result_tensor[0, ch1, :], result_tensor[1, ch1, :] = a_tensor[1, ch1, :].clone(), a_tensor[0, ch1, :].clone()
+    result_tensor[0, ch2, :], result_tensor[1, ch2, :] = a_tensor[1, ch2, :].clone(), a_tensor[0, ch2, :].clone()
+
+    return result_tensor
+
+
+# Define a sample tensor 'a_tensor'
+a_tensor = torch.tensor([[[0, 1], [2, 3], [4, 5]], [[6, 7], [8, 9], [10, 11]]], dtype=torch.float32)
+
+# Define channels to swap
+swap_channels = (1, 2)  # Channels to swap between batches
+
+# Swap the channels between batches
+swapped_tensor = swap_channels_between_batches(a_tensor, swap_channels)
+
+# Print the original tensor and the tensor after swapping channels between batches
+print("Original Tensor 'a_tensor':")
+print(a_tensor)
+print("\nTensor after swapping channels between batches:")
+print(swapped_tensor)
+
+#-------------------------------------------------
+
+import torch
+from einops import rearrange
+
+
+def shift(arr, num, fill_value=np.nan):
+    result = np.empty_like(arr)
+    if num > 0:
+        result[:num] = fill_value
+        result[num:] = arr[:-num]
+    elif num < 0:
+        result[num:] = fill_value
+        result[:num] = arr[-num:]
+    else:
+        result[:] = arr
+    return result
+
+
+def create_batch_swap_matrix(batch_size, channels, swap_channels):
+    swap_mat = np.eye(batch_size * channels)
+
+    for c in swap_channels:
+        idx1 = c  # 첫 번째 배치의 교환할 채널 인덱스
+        idx2 = c + channels  # 두 번째 배치의 교환할 채널 인덱스
+
+        swap_mat[idx1, idx1], swap_mat[idx2, idx2] = 0, 0  # 대각선 값을 0으로 설정
+        swap_mat[idx1, idx2], swap_mat[idx2, idx1] = 1, 1  # 해당 채널을 교환
+    return swap_mat
+
+
+def create_batch_swap_matrix(batch_size, channels, swap_channels):
+    swap_mat = np.eye(batch_size * channels)
+
+    # 모든 채널에 대해 교환 수행
+    for c in swap_channels:
+        idx1 = np.arange(c, batch_size * channels, channels)  # 현재 채널의 모든 배치 인덱스
+        idx2 = (idx1 + channels) % (batch_size * channels)  # 순환을 위해 modulo 사용
+
+        swap_mat[idx1, idx1] = 0
+        swap_mat[idx2, idx2] = 0
+        swap_mat[idx1, idx2] = 1
+        swap_mat[idx2, idx1] = 1
+
+    return swap_mat
+
+
+def swap_channels_between_batches(input_tensor, swap_matrix):
+    reshaped_tensor = rearrange(input_tensor, 'b c d -> (b c) d')
+    swapped_tensor = swap_matrix @ reshaped_tensor
+    return rearrange(swapped_tensor, '(b c) d -> b c d', b=input_tensor.shape[0])
+
+
+# 예제 파라미터
+batch_size = 2
+channels = 3
+# swap_info  = {
+#     : [1, 2] # batch_index: [channel_indices]
+# }
+swap_channels = [1, 2]  # 교환할 채널
+
+# 예제 텐서 생성
+input_tensor = torch.tensor([[[0, 1], [2, 3], [4, 5]], [[6, 7], [8, 9], [10, 11]]], dtype=torch.float32)
+
+# swap matrix 생성
+swap_matrix = create_batch_swap_matrix(batch_size, channels, swap_channels)
+swap_matrix = torch.Tensor(swap_matrix)
+
+# 채널 교환 수행
+swapped_tensor = swap_channels_between_batches(input_tensor, swap_matrix)
+
+# 결과 출력
+print("Original Tensor:")
+print(input_tensor)
+print("\nSwapped Tensor:")
+print(swapped_tensor)

extras/t5_dev.py

@@ -0,0 +1,41 @@
+import torch
+from transformers import T5Config
+from model.t5mod import T5ForConditionalGeneration
+
+a = {
+    "architectures": ["T5ForConditionalGeneration"],
+    "d_ff": 1024,  # size of the intermediate feed forward layer in each T5Block
+    "d_kv": 64,  # d_kv has to be equal to d_model // num_heads.
+    # "d_model": 512,  # encoder hiddnen size, defined by model_cfg
+    "decoder_start_token_id": 0,
+    "dense_act_fn": "gelu_new",
+    # "dropout_rate": 0.05,  # can be overwritten by args in ymt3
+    "eos_token_id": 1,
+    "feed_forward_proj": "gated-gelu",
+    "initializer_factor": 1.0,
+    # "is_encoder_decoder": True,
+    "is_gated_act": True,
+    "layer_norm_epsilon": 1e-06,
+    "model_type": "t5",
+    # "num_decoder_layers": 8,
+    "num_heads": 6,
+    "num_layers": 8,
+    "output_past": True,
+    "pad_token_id": 0,
+    "relative_attention_num_buckets": 32,
+    "use_cache": True,
+    "vocab_size": 1391  # vocab_size is automatically set by the task manager...
+}
+cfg = T5Config(**a)
+cfg.num_decoder_layers = 4
+cfg.num_layers = 0
+
+model = T5ForConditionalGeneration(cfg)
+print(model)
+
+x = torch.rand(((2, 256, 512)))
+out = model.encoder.forward(inputs_embeds=x)
+
+enc_hs = torch.rand((2, 256, 512))
+labels = torch.randint(0, 1391, (2, 256))
+pred = model(encoder_outputs=(enc_hs,), labels=labels)  # important (enc_hs,) comma!

extras/t5perceiver.py

@@ -0,0 +1,443 @@
+# Copyright 2024 The YourMT3 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
+#
+# Please see the details in the LICENSE file.
+""" Bare wrapper of HF PyTorch T5 and Perceiver with the following modifications:
+- PerceiverTF encoder
+- ResConv pre-encoder
+- Projection layers for dynamic dimension matching
+- Sinusoidal absolute positional embeddings
+- Positional embeddings from Perceiver implementation
+- Task conditioning on encoder and decoder by input tokens
+"""
+import copy
+import warnings
+from typing import Optional, Tuple, Union
+
+import torch
+from torch import nn
+from torch.nn import CrossEntropyLoss
+from torch.utils.checkpoint import checkpoint
+
+from transformers.utils import logging
+from transformers.utils.model_parallel_utils import assert_device_map, get_device_map
+from transformers.modeling_utils import PreTrainedModel
+from transformers.models.t5.modeling_t5 import (T5LayerNorm, T5Block, PARALLELIZE_DOCSTRING, DEPARALLELIZE_DOCSTRING,
+                                                T5_START_DOCSTRING, T5_INPUTS_DOCSTRING, _CONFIG_FOR_DOC,
+                                                __HEAD_MASK_WARNING_MSG)
+from transformers.modeling_outputs import (Seq2SeqLMOutput, BaseModelOutput, BaseModelOutputWithPastAndCrossAttentions)
+from transformers import T5Config  #, T5PreTrainedModel
+from model.ops import FixedSinusoidalPositionalEmbedding
+
+# additional imports
+from model.t5mod import T5Stack
+from transformers.models.t5.modeling_t5 import (T5Model, T5ForConditionalGeneration, T5EncoderModel, T5DenseActDense,
+                                                T5DenseGatedActDense, T5Attention, load_tf_weights_in_t5,
+                                                is_torch_fx_proxy)
+
+from transformers.utils import (DUMMY_INPUTS, DUMMY_MASK)
+
+logger = logging.get_logger(__name__)
+
+
+class T5PerceiverPreTrainedModel(PreTrainedModel):
+    """
+    An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
+    models.
+    """
+
+    config_class = None
+    load_tf_weights = load_tf_weights_in_t5
+    base_model_prefix = "transformer"
+    is_parallelizable = True
+    supports_gradient_checkpointing = True
+    _no_split_modules = ["T5Block"]
+    _keep_in_fp32_modules = ["wo"]
+
+    @property
+    def dummy_inputs(self):
+        input_ids = torch.tensor(DUMMY_INPUTS)
+        input_mask = torch.tensor(DUMMY_MASK)
+        dummy_inputs = {
+            "decoder_input_ids": input_ids,
+            "input_ids": input_ids,
+            "decoder_attention_mask": input_mask,
+        }
+        return dummy_inputs
+
+    def _init_weights(self, module):
+        """Initialize the weights"""
+        factor = self.config.initializer_factor  # Used for testing weights initialization
+        if isinstance(module, T5LayerNorm):
+            module.weight.data.fill_(factor * 1.0)
+        elif isinstance(module, (T5Model, T5ForConditionalGeneration, T5EncoderModel)):
+            # Mesh TensorFlow embeddings initialization
+            # See https://github.com/tensorflow/mesh/blob/fa19d69eafc9a482aff0b59ddd96b025c0cb207d/mesh_tensorflow/layers.py#L1624
+            module.shared.weight.data.normal_(mean=0.0, std=factor * 1.0)
+            if hasattr(module, "lm_head") and not self.config.tie_word_embeddings:
+                module.lm_head.weight.data.normal_(mean=0.0, std=factor * 1.0)
+        elif isinstance(module, T5DenseActDense):
+            # Mesh TensorFlow FF initialization
+            # See https://github.com/tensorflow/mesh/blob/master/mesh_tensorflow/transformer/transformer_layers.py#L56
+            # and https://github.com/tensorflow/mesh/blob/fa19d69eafc9a482aff0b59ddd96b025c0cb207d/mesh_tensorflow/layers.py#L89
+            module.wi.weight.data.normal_(mean=0.0, std=factor * ((self.config.d_model)**-0.5))
+            if hasattr(module.wi, "bias") and module.wi.bias is not None:
+                module.wi.bias.data.zero_()
+            module.wo.weight.data.normal_(mean=0.0, std=factor * ((self.config.d_ff)**-0.5))
+            if hasattr(module.wo, "bias") and module.wo.bias is not None:
+                module.wo.bias.data.zero_()
+        elif isinstance(module, T5DenseGatedActDense):
+            module.wi_0.weight.data.normal_(mean=0.0, std=factor * ((self.config.d_model)**-0.5))
+            if hasattr(module.wi_0, "bias") and module.wi_0.bias is not None:
+                module.wi_0.bias.data.zero_()
+            module.wi_1.weight.data.normal_(mean=0.0, std=factor * ((self.config.d_model)**-0.5))
+            if hasattr(module.wi_1, "bias") and module.wi_1.bias is not None:
+                module.wi_1.bias.data.zero_()
+            module.wo.weight.data.normal_(mean=0.0, std=factor * ((self.config.d_ff)**-0.5))
+            if hasattr(module.wo, "bias") and module.wo.bias is not None:
+                module.wo.bias.data.zero_()
+        elif isinstance(module, T5Attention):
+            # Mesh TensorFlow attention initialization to avoid scaling before softmax
+            # See https://github.com/tensorflow/mesh/blob/fa19d69eafc9a482aff0b59ddd96b025c0cb207d/mesh_tensorflow/transformer/attention.py#L136
+            d_model = self.config.d_model
+            key_value_proj_dim = self.config.d_kv
+            n_heads = self.config.num_heads
+            module.q.weight.data.normal_(mean=0.0, std=factor * ((d_model * key_value_proj_dim)**-0.5))
+            module.k.weight.data.normal_(mean=0.0, std=factor * (d_model**-0.5))
+            module.v.weight.data.normal_(mean=0.0, std=factor * (d_model**-0.5))
+            module.o.weight.data.normal_(mean=0.0, std=factor * ((n_heads * key_value_proj_dim)**-0.5))
+            if module.has_relative_attention_bias:
+                module.relative_attention_bias.weight.data.normal_(mean=0.0, std=factor * ((d_model)**-0.5))
+
+    def _set_gradient_checkpointing(self, module, value=False):
+        if isinstance(module, (T5Attention, T5Stack)):
+            module.gradient_checkpointing = value
+
+    def _shift_right(self, input_ids):
+        decoder_start_token_id = self.config.decoder_start_token_id
+        pad_token_id = self.config.pad_token_id
+
+        assert decoder_start_token_id is not None, (
+            "self.model.config.decoder_start_token_id has to be defined. In T5 it is usually set to the pad_token_id."
+            " See T5 docs for more information")
+
+        # shift inputs to the right
+        if is_torch_fx_proxy(input_ids):
+            # Item assignment is not supported natively for proxies.
+            shifted_input_ids = torch.full(input_ids.shape[:-1] + (1,), decoder_start_token_id)
+            shifted_input_ids = torch.cat([shifted_input_ids, input_ids[..., :-1]], dim=-1)
+        else:
+            shifted_input_ids = input_ids.new_zeros(input_ids.shape)
+            shifted_input_ids[..., 1:] = input_ids[..., :-1].clone()
+            shifted_input_ids[..., 0] = decoder_start_token_id
+
+        assert pad_token_id is not None, "self.model.config.pad_token_id has to be defined."
+        # replace possible -100 values in labels by `pad_token_id`
+        shifted_input_ids.masked_fill_(shifted_input_ids == -100, pad_token_id)
+
+        return shifted_input_ids
+
+
+class T5PerceiverForConditionalGeneration(T5PerceiverPreTrainedModel):
+    config_class = None
+    load_tf_weights = load_tf_weights_in_t5
+    base_model_prefix = "transformer"
+    is_parallelizable = True
+    supports_gradient_checkpointing = True
+    _no_split_modules = ["T5Block"]
+    _keep_in_fp32_modules = ["wo"]
+
+    @property
+    def dummy_inputs(self):
+        input_ids = torch.tensor(DUMMY_INPUTS)
+        input_mask = torch.tensor(DUMMY_MASK)
+        dummy_inputs = {
+            "decoder_input_ids": input_ids,
+            "input_ids": input_ids,
+            "decoder_attention_mask": input_mask,
+        }
+        return dummy_inputs
+
+    def __init__(
+        self,
+        model_cfg: dict,
+        #  config: T5Config,
+        #  use_fixed_absolute_pe: bool = True,
+        #  num_max_positions: int = 1025
+    ):
+        super().__init__(config)
+        self.model_dim = config.d_model
+        """ mod: absolute position embedding """
+        self.use_fixed_absolute_pe = use_fixed_absolute_pe
+
+        self.shared = nn.Embedding(config.vocab_size, config.d_model)
+
+        encoder_config = copy.deepcopy(config)
+        encoder_config.is_decoder = False
+        encoder_config.use_cache = False
+        encoder_config.is_encoder_decoder = False
+        self.encoder = T5Stack(encoder_config,
+                               self.shared,
+                               use_fixed_absolute_pe=use_fixed_absolute_pe,
+                               num_max_positions=num_max_positions)
+
+        decoder_config = copy.deepcopy(config)
+        decoder_config.is_decoder = True
+        decoder_config.is_encoder_decoder = False
+        decoder_config.num_layers = config.num_decoder_layers
+        self.decoder = T5Stack(decoder_config,
+                               self.shared,
+                               use_fixed_absolute_pe=use_fixed_absolute_pe,
+                               num_max_positions=num_max_positions)
+
+        self.lm_head = nn.Linear(config.d_model, config.vocab_size, bias=False)
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+        # Model parallel
+        self.model_parallel = False
+        self.device_map = None
+
+    def get_input_embeddings(self):
+        return self.shared
+
+    def set_input_embeddings(self, new_embeddings):
+        self.shared = new_embeddings
+        self.encoder.set_input_embeddings(new_embeddings)
+        self.decoder.set_input_embeddings(new_embeddings)
+
+    def set_output_embeddings(self, new_embeddings):
+        self.lm_head = new_embeddings
+
+    def get_output_embeddings(self):
+        return self.lm_head
+
+    def get_encoder(self):
+        return self.encoder
+
+    def get_decoder(self):
+        return self.decoder
+
+    def forward(
+        self,
+        input_ids: Optional[torch.LongTensor] = None,
+        attention_mask: Optional[torch.FloatTensor] = None,
+        decoder_input_ids: Optional[torch.LongTensor] = None,
+        decoder_attention_mask: Optional[torch.BoolTensor] = None,
+        head_mask: Optional[torch.FloatTensor] = None,
+        decoder_head_mask: Optional[torch.FloatTensor] = None,
+        cross_attn_head_mask: Optional[torch.Tensor] = None,
+        encoder_outputs: Optional[Tuple[Tuple[torch.Tensor]]] = None,
+        past_key_values: Optional[Tuple[Tuple[torch.Tensor]]] = None,
+        inputs_embeds: Optional[torch.FloatTensor] = None,
+        decoder_inputs_embeds: Optional[torch.FloatTensor] = None,
+        labels: Optional[torch.LongTensor] = None,
+        use_cache: Optional[bool] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple[torch.FloatTensor], Seq2SeqLMOutput]:
+        r"""
+        labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+            Labels for computing the sequence classification/regression loss. Indices should be in `[-100, 0, ...,
+            config.vocab_size - 1]`. All labels set to `-100` are ignored (masked), the loss is only computed for
+            labels in `[0, ..., config.vocab_size]`
+
+        Returns:
+
+        Examples:
+
+        ```python
+        >>> from transformers import AutoTokenizer, T5ForConditionalGeneration
+
+        >>> tokenizer = AutoTokenizer.from_pretrained("t5-small")
+        >>> model = T5ForConditionalGeneration.from_pretrained("t5-small")
+
+        >>> # training
+        >>> input_ids = tokenizer("The <extra_id_0> walks in <extra_id_1> park", return_tensors="pt").input_ids
+        >>> labels = tokenizer("<extra_id_0> cute dog <extra_id_1> the <extra_id_2>", return_tensors="pt").input_ids
+        >>> outputs = model(input_ids=input_ids, labels=labels)
+        >>> loss = outputs.loss
+        >>> logits = outputs.logits
+
+        >>> # inference
+        >>> input_ids = tokenizer(
+        ...     "summarize: studies have shown that owning a dog is good for you", return_tensors="pt"
+        ... ).input_ids  # Batch size 1
+        >>> outputs = model.generate(input_ids)
+        >>> print(tokenizer.decode(outputs[0], skip_special_tokens=True))
+        >>> # studies have shown that owning a dog is good for you.
+        ```"""
+        use_cache = use_cache if use_cache is not None else self.config.use_cache
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        # FutureWarning: head_mask was separated into two input args - head_mask, decoder_head_mask
+        if head_mask is not None and decoder_head_mask is None:
+            if self.config.num_layers == self.config.num_decoder_layers:
+                warnings.warn(__HEAD_MASK_WARNING_MSG, FutureWarning)
+                decoder_head_mask = head_mask
+
+        # Encode if needed (training, first prediction pass)
+        if encoder_outputs is None:
+            # Convert encoder inputs in embeddings if needed
+            encoder_outputs = self.encoder(
+                input_ids=input_ids,
+                attention_mask=attention_mask,
+                inputs_embeds=inputs_embeds,
+                head_mask=head_mask,
+                output_attentions=output_attentions,
+                output_hidden_states=output_hidden_states,
+                return_dict=return_dict,
+            )
+        elif return_dict and not isinstance(encoder_outputs, BaseModelOutput):
+            encoder_outputs = BaseModelOutput(
+                last_hidden_state=encoder_outputs[0],
+                hidden_states=encoder_outputs[1] if len(encoder_outputs) > 1 else None,
+                attentions=encoder_outputs[2] if len(encoder_outputs) > 2 else None,
+            )
+
+        hidden_states = encoder_outputs[0]
+
+        if self.model_parallel:
+            torch.cuda.set_device(self.decoder.first_device)
+
+        if labels is not None and decoder_input_ids is None and decoder_inputs_embeds is None:
+            # get decoder inputs from shifting lm labels to the right
+            decoder_input_ids = self._shift_right(labels)
+
+        # Set device for model parallelism
+        if self.model_parallel:
+            torch.cuda.set_device(self.decoder.first_device)
+            hidden_states = hidden_states.to(self.decoder.first_device)
+            if decoder_input_ids is not None:
+                decoder_input_ids = decoder_input_ids.to(self.decoder.first_device)
+            if attention_mask is not None:
+                attention_mask = attention_mask.to(self.decoder.first_device)
+            if decoder_attention_mask is not None:
+                decoder_attention_mask = decoder_attention_mask.to(self.decoder.first_device)
+
+        # Decode
+        decoder_outputs = self.decoder(
+            input_ids=decoder_input_ids,
+            attention_mask=decoder_attention_mask,
+            inputs_embeds=decoder_inputs_embeds,
+            past_key_values=past_key_values,
+            encoder_hidden_states=hidden_states,
+            encoder_attention_mask=attention_mask,
+            head_mask=decoder_head_mask,
+            cross_attn_head_mask=cross_attn_head_mask,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+
+        sequence_output = decoder_outputs[0]
+
+        # Set device for model parallelism
+        if self.model_parallel:
+            torch.cuda.set_device(self.encoder.first_device)
+            self.lm_head = self.lm_head.to(self.encoder.first_device)
+            sequence_output = sequence_output.to(self.lm_head.weight.device)
+
+        if self.config.tie_word_embeddings:
+            # Rescale output before projecting on vocab
+            # See https://github.com/tensorflow/mesh/blob/fa19d69eafc9a482aff0b59ddd96b025c0cb207d/mesh_tensorflow/transformer/transformer.py#L586
+            sequence_output = sequence_output * (self.model_dim**-0.5)
+
+        lm_logits = self.lm_head(sequence_output)
+
+        loss = None
+        if labels is not None:
+            loss_fct = CrossEntropyLoss(ignore_index=-100)
+            # move labels to correct device to enable PP
+            labels = labels.to(lm_logits.device)
+            loss = loss_fct(lm_logits.view(-1, lm_logits.size(-1)), labels.view(-1))
+            # TODO(thom): Add z_loss https://github.com/tensorflow/mesh/blob/fa19d69eafc9a482aff0b59ddd96b025c0cb207d/mesh_tensorflow/layers.py#L666
+
+        if not return_dict:
+            output = (lm_logits,) + decoder_outputs[1:] + encoder_outputs
+            return ((loss,) + output) if loss is not None else output
+
+        return Seq2SeqLMOutput(
+            loss=loss,
+            logits=lm_logits,
+            past_key_values=decoder_outputs.past_key_values,
+            decoder_hidden_states=decoder_outputs.hidden_states,
+            decoder_attentions=decoder_outputs.attentions,
+            cross_attentions=decoder_outputs.cross_attentions,
+            encoder_last_hidden_state=encoder_outputs.last_hidden_state,
+            encoder_hidden_states=encoder_outputs.hidden_states,
+            encoder_attentions=encoder_outputs.attentions,
+        )
+
+    def prepare_inputs_for_generation(
+        self,
+        input_ids,
+        past_key_values=None,
+        attention_mask=None,
+        head_mask=None,
+        decoder_head_mask=None,
+        cross_attn_head_mask=None,
+        use_cache=None,
+        encoder_outputs=None,
+        **kwargs,
+    ):
+        # cut decoder_input_ids if past is used
+        if past_key_values is not None:
+            input_ids = input_ids[:, -1:]
+
+        return {
+            "decoder_input_ids": input_ids,
+            "past_key_values": past_key_values,
+            "encoder_outputs": encoder_outputs,
+            "attention_mask": attention_mask,
+            "head_mask": head_mask,
+            "decoder_head_mask": decoder_head_mask,
+            "cross_attn_head_mask": cross_attn_head_mask,
+            "use_cache": use_cache,
+        }
+
+    def prepare_decoder_input_ids_from_labels(self, labels: torch.Tensor):
+        return self._shift_right(labels)
+
+    def _reorder_cache(self, past_key_values, beam_idx):
+        # if decoder past is not included in output
+        # speedy decoding is disabled and no need to reorder
+        if past_key_values is None:
+            logger.warning("You might want to consider setting `use_cache=True` to speed up decoding")
+            return past_key_values
+
+        reordered_decoder_past = ()
+        for layer_past_states in past_key_values:
+            # get the correct batch idx from layer past batch dim
+            # batch dim of `past` is at 2nd position
+            reordered_layer_past_states = ()
+            for layer_past_state in layer_past_states:
+                # need to set correct `past` for each of the four key / value states
+                reordered_layer_past_states = reordered_layer_past_states + (layer_past_state.index_select(
+                    0, beam_idx.to(layer_past_state.device)),)
+
+            assert reordered_layer_past_states[0].shape == layer_past_states[0].shape
+            assert len(reordered_layer_past_states) == len(layer_past_states)
+
+            reordered_decoder_past = reordered_decoder_past + (reordered_layer_past_states,)
+        return reordered_decoder_past
+
+
+from transformers import PreTrainedModel, PretrainedConfig
+from transformers import AutoModel, AutoConfig
+
+
+class MyConfig(T5Config, PerceiverConfig):
+    model_type = 'mymodel'
+
+    def __init__(self, important_param=42, **kwargs):
+        super().__init__(**kwargs)
+        self.important_param = important_param

extras/unimax_sampler/README.md

@@ -0,0 +1,45 @@
+# UniMax Language Dataset Sampler with DDP support
+
+This repository contains an unofficial implementation of the UNIMAX sampling algorithm using PyTorch. The UNIMAX algorithm ["UniMax: Fairer and more Effective Language Sampling for Large-Scale Multilingual Pretraining" by HW Chung et al. (ICLR 2023)](https://arxiv.org/abs/2304.09151) is used to generate a sampling distribution of languages based on their character counts, a total character budget, and a specified number of epochs per language. This can be useful for training language models on datasets with imbalanced language distribution.
+
+## Contents
+
+1. `unimax_sampler.py`: This Python file contains the `UnimaxSampler` class, a PyTorch `Sampler` that uses the UNIMAX algorithm.
+
+2. `test_unimax_sampler.py`: This Python file contains a unit test for the `UnimaxSampler` class to ensure its correct functionality.
+
+## Usage
+
+```python
+from torch.utils.data import Dataset, DataLoader
+from unimax_sampler import UnimaxSampler
+
+# Define your parameters
+language_character_counts = [100, 200, 300, 400, 500]
+total_character_budget = 1000
+num_epochs = 2
+
+# Create the UnimaxSampler
+unimax_sampler = UnimaxSampler(language_character_counts, total_character_budget, num_epochs)
+```
+
+Then, use the sampler as the sampler argument when creating a DataLoader.
+
+```python
+# Disable shuffle when using custom sampler...
+data_loader = DataLoader(my_dataset, batch_size=2, shuffle=None, sampler=unimax_sampler)
+```
+
+For DDP,
+```python
+if torch.distributed.is_initialized():
+    sampler = DistributedUnimaxSampler(...)
+else:
+    return unimax_sampler(...)
+```
+
+## Note
+The initial version of this code was created by [Chat GPT-4](https://chat.openai.com/), based on the pseudocode provided in the [UNIMAX](https://arxiv.org/abs/2304.09151) paper. Subsequently, the code was manually revised for `PyTorch` Distributed Data Parallel ([DDP](https://pytorch.org/docs/stable/notes/ddp.html)) framework. The DistributedSamplerWrapper implementation is derived from an earlier version found in the [Catalyst](https://github.com/catalyst-team/catalyst) project.
+
+## License
+This project is licensed under the MIT License.

extras/unimax_sampler/demo.py

@@ -0,0 +1,15 @@
+from utils.unimax_sampler.unimax_sampler import UnimaxSampler
+
+language_character_counts = [100, 200, 300, 400, 500]
+total_character_budget = 1000
+num_epochs = 2
+
+# Create the UnimaxSampler.
+sampler = UnimaxSampler(language_character_counts, total_character_budget, num_epochs)
+
+# Define the expected output. This will depend on your specific implementation of Unimax.
+expected_output = torch.tensor([0.1, 0.2, 0.3, 0.2, 0.2])
+
+# Use PyTorch's allclose function to compare the computed and expected outputs.
+# The absolute tolerance parameter atol specifies the maximum difference allowed for the test to pass.
+self.assertTrue(torch.allclose(sampler.p, expected_output, atol=1e-6))

extras/unimax_sampler/unimax_sampler.py

@@ -0,0 +1,168 @@
+import torch
+from torch.utils.data import DistributedSampler
+from torch.utils.data import Dataset, Sampler
+from torch.utils.data import RandomSampler
+from operator import itemgetter
+from typing import List, Union, Iterator, Optional
+
+
+class DatasetFromSampler(Dataset):
+    """Dataset to create indexes from `Sampler`. From catalyst library.
+
+    Args:
+        sampler: PyTorch sampler
+    """
+
+    def __init__(self, sampler: Sampler):
+        """Initialisation for DatasetFromSampler."""
+        self.sampler = sampler
+        self.sampler_list = None
+
+    def __getitem__(self, index: int):
+        """Gets element of the dataset.
+
+        Args:
+            index: index of the element in the dataset
+
+        Returns:
+            Single element by index
+        """
+        if self.sampler_list is None:
+            self.sampler_list = list(self.sampler)
+        return self.sampler_list[index]
+
+    def __len__(self) -> int:
+        """
+        Returns:
+            int: length of the dataset
+        """
+        return len(self.sampler)
+
+
+class DistributedSamplerWrapper(DistributedSampler):
+    """
+    Wrapper over `Sampler` for distributed training.
+    Allows you to use any sampler in distributed mode.
+    From https://github.com/catalyst-team/catalyst/blob/master/catalyst/data/sampler.py
+
+    It is especially useful in conjunction with
+    `torch.nn.parallel.DistributedDataParallel`. In such case, each
+    process can pass a DistributedSamplerWrapper instance as a DataLoader
+    sampler, and load a subset of subsampled data of the original dataset
+    that is exclusive to it.
+
+    .. note::
+        Sampler is assumed to be of constant size.
+    """
+
+    def __init__(
+        self,
+        sampler,
+        num_replicas: Optional[int] = None,
+        rank: Optional[int] = None,
+        shuffle: bool = True,
+    ):
+        """
+
+        Args:
+            sampler: Sampler used for subsampling
+            num_replicas (int, optional): Number of processes participating in
+                distributed training
+            rank (int, optional): Rank of the current process
+                within ``num_replicas``
+            shuffle (bool, optional): If true (default),
+                sampler will shuffle the indices
+        """
+        super(DistributedSamplerWrapper, self).__init__(
+            DatasetFromSampler(sampler),
+            num_replicas=num_replicas,
+            rank=rank,
+            shuffle=shuffle,
+        )
+        self.sampler = sampler
+
+    def __iter__(self) -> Iterator[int]:
+        """Iterate over sampler.
+
+        Returns:
+            python iterator
+        """
+        self.dataset = DatasetFromSampler(self.sampler)
+        indexes_of_indexes = super().__iter__()
+        subsampler_indexes = self.dataset
+        return iter(itemgetter(*indexes_of_indexes)(subsampler_indexes))
+
+
+class UnimaxSampler(Sampler):
+    # Initialize the sampler with the character counts for each language,
+    # the total character budget, and the number of epochs per language.
+    def __init__(self, language_character_counts: List[int], total_character_budget: int,
+                 num_epochs: int) -> None:
+        self.language_character_counts = torch.tensor(language_character_counts)
+        self.total_character_budget = total_character_budget
+        self.num_epochs = num_epochs
+        # Compute the sampling distribution p.
+        self.p = self._unimax()
+
+    # Define how to iterate over the data. We'll use PyTorch's multinomial
+    # function to generate indices according to the distribution p.
+    def __iter__(self) -> iter:
+        return iter(torch.multinomial(self.p, len(self.p), replacement=True).tolist())
+
+    # Define the length of the sampler as the number of languages.
+    def __len__(self) -> int:
+        return len(self.p)
+
+    # Implement the UNIMAX algorithm to compute the sampling distribution p.
+    def _unimax(self) -> torch.Tensor:
+        # Sort languages by character count.
+        L, indices = torch.sort(self.language_character_counts)
+        # Initialize the remaining budget to the total character budget.
+        B = float(self.total_character_budget)
+        i = 0
+        # Initialize the budget per language.
+        U = torch.zeros_like(L)
+        # For each language...
+        for idx in indices:
+            # Compute the remaining budget per-language.
+            bl = B / (len(L) - i)
+            cl = L[idx]
+            # If per-language budget exceeds N epochs of the language, use N epochs.
+            if bl > cl * self.num_epochs:
+                Ul = cl * self.num_epochs
+            # Otherwise use uniform per-language budget.
+            else:
+                Ul = bl
+            # Store the computed budget.
+            U[idx] = Ul
+            # Update the remaining budget.
+            B -= Ul
+            # Move to the next language.
+            i += 1
+        # Normalize the budget to create a distribution.
+        p = U / U.sum()
+        # Return the computed distribution.
+        return p
+
+
+class DistributedUnimaxSampler(UnimaxSampler):
+
+    def __init__(self,
+                 language_character_counts: List[int],
+                 total_character_budget: int,
+                 num_epochs: int,
+                 num_replicas: Optional[int] = None,
+                 rank: Optional[int] = None,
+                 shuffle: bool = True) -> None:
+
+        super().__init__(language_character_counts, total_character_budget, num_epochs)
+        self.distributed_sampler = DistributedSamplerWrapper(self, num_replicas, rank, shuffle)
+
+    def __iter__(self):
+        return iter(self.distributed_sampler)
+
+    def __len__(self):
+        return len(self.distributed_sampler)
+
+    def set_epoch(self, epoch):
+        self.distributed_sampler.set_epoch(epoch)

model/conformer_helper.py

@@ -0,0 +1,169 @@
+# Copyright 2024 The YourMT3 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
+#
+# Please see the details in the LICENSE file.
+import math
+from typing import Optional, Union
+
+from torch import nn
+from transformers.configuration_utils import PretrainedConfig
+from transformers.modeling_utils import PreTrainedModel
+
+
+class ConformerYMT3Config(PretrainedConfig):
+    r"""
+    This is the configuration class to store the configuration of a [`ConformerYMT3Encoder`]. It is used to
+    instantiate an ConformerYMT3Encoder according to the specified arguments, defining the model architecture.
+    Instantiating a configuration with the defaults will yield a similar configuration to that of the Wav2Vec2Conformer
+    [facebook/wav2vec2-conformer-rel-pos-large](https://huggingface.co/facebook/wav2vec2-conformer-rel-pos-large)
+    architecture.
+
+    Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
+    documentation from [`PretrainedConfig`] for more information.
+
+
+    Args:
+        d_model (`int`, *optional*, defaults to 512):
+            Dimensionality of the encoder layers and the pooler layer.
+        num_layers (`int`, *optional*, defaults to 12):
+            Number of hidden layers in the Transformer encoder.
+        num_heads (`int`, *optional*, defaults to 12):
+            Number of attention heads for each attention layer in the Transformer encoder.
+        intermediate_size (`int`, *optional*, defaults to 2048):
+            Dimensionality of the "intermediate" (i.e., feed-forward) layer in the Transformer encoder.
+        hidden_act (`str` or `function`, *optional*, defaults to `"gelu"`):
+            The non-linear activation function (function or string) in the encoder and pooler. If string, `"gelu"`,
+            `"relu"`, `"selu"` and `"gelu_new"` are supported.
+        dropout_rate (`float`, *optional*, defaults to 0.05):
+            The dropout probability for all fully connected layers in the embeddings, encoder, and pooler.
+        layerdrop (`float`, *optional*, defaults to 0.1):
+            The LayerDrop probability. See the [LayerDrop paper](see https://arxiv.org/abs/1909.11556) for more
+            details.
+        initializer_range (`float`, *optional*, defaults to 0.02):
+            The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
+        layer_norm_eps (`float`, *optional*, defaults to 1e-12):
+            The epsilon used by the layer normalization layers.
+        conv_dim (`Tuple[int]` or `List[int]`, *optional*, defaults to `(512, 512, 512, 512, 512, 512, 512)`):
+            A tuple of integers defining the number of input and output channels of each 1D convolutional layer in the
+            feature encoder. The length of *conv_dim* defines the number of 1D convolutional layers.
+        conv_stride (`Tuple[int]` or `List[int]`, *optional*, defaults to `(5, 2, 2, 2, 2, 2, 2)`):
+            A tuple of integers defining the stride of each 1D convolutional layer in the feature encoder. The length
+            of *conv_stride* defines the number of convolutional layers and has to match the length of *conv_dim*.
+        conv_kernel (`Tuple[int]` or `List[int]`, *optional*, defaults to `(10, 3, 3, 3, 3, 3, 3)`):
+            A tuple of integers defining the kernel size of each 1D convolutional layer in the feature encoder. The
+            length of *conv_kernel* defines the number of convolutional layers and has to match the length of
+            *conv_dim*.
+        conv_bias (`bool`, *optional*, defaults to `False`):
+            Whether the 1D convolutional layers have a bias.
+        output_hidden_size (`int`, *optional*):
+            Dimensionality of the encoder output layer. If not defined, this defaults to *hidden-size*. Only relevant
+            if `add_adapter is True`.
+        position_encoding_type (`str`, *optional*, defaults to `"relative"`):
+            Can be specified to `relative` or `rotary` for relative or rotary position embeddings respectively. If left
+            `None` no relative position embedding is applied.
+        rotary_embedding_base (`int`, *optional*, defaults to 10000):
+            If `"rotary"` position embeddings are used, defines the size of the embedding base.
+        num_max_positions (`int`, *optional*, defaults to 5000):
+            if `"relative"` position embeddings are used, defines the maximum source input positions.
+        conv_depthwise_kernel_size (`int`, defaults to 31):
+            Kernel size of convolutional depthwise 1D layer in Conformer blocks.
+
+    Example:
+
+    ```python
+    >>> from transformers import ConformerYMT3Config, ConformerYMT3Encoder
+
+    >>> # Initializing a ConformerYMT3Encoder configuration
+    >>> configuration = ConformerYMT3Config()
+
+    >>> # Initializing a model (with random weights) from the facebook/wav2vec2-conformer-rel-pos-large style configuration
+    >>> model = ConformerYMT3Encoder(configuration)
+
+    >>> # Accessing the model configuration
+    >>> configuration = model.config
+    ```"""
+    model_type = "conformer-ymt3"
+
+    def __init__(
+        self,
+        d_model=512,  # 768
+        num_layers=8,  # ConformerYMT3Encoder
+        num_heads=8,  # ConformerYMT3SelfAttention
+        intermediate_size=2048,  # 3072,# used in intermediate_dense of ConformerYMT3FeedForward
+        hidden_act="gelu",  # used in intermediate_act_fn of ConformerYMT3FeedForward
+        dropout_rate=0.1,
+        layerdrop=0.1,
+        initializer_range=0.02,
+        layer_norm_eps=1e-5,
+        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, 3, 3),
+        conv_bias=False,
+        position_encoding_type="rotary",
+        rotary_embedding_base=10000,
+        num_max_positions=1024,
+        conv_depthwise_kernel_size=31,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.d_model = d_model
+        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_layers = num_layers
+        self.intermediate_size = intermediate_size
+        self.hidden_act = hidden_act
+        self.num_heads = num_heads
+        self.dropout_rate = dropout_rate
+
+        self.layerdrop = layerdrop
+        self.layer_norm_eps = layer_norm_eps
+        self.initializer_range = initializer_range
+        self.num_max_positions = num_max_positions
+        self.position_encoding_type = position_encoding_type
+        self.rotary_embedding_base = rotary_embedding_base
+
+        # Conformer-block related
+        self.conv_depthwise_kernel_size = conv_depthwise_kernel_size
+
+
+class ConformerYMT3PreTrainedModel(PreTrainedModel):
+    """
+    An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
+    models.
+    """
+
+    config_class = ConformerYMT3Config
+    base_model_prefix = "wav2vec2_conformer"
+    main_input_name = "input_values"
+    supports_gradient_checkpointing = True
+
+    def _init_weights(self, module):
+        """Initialize the weights"""
+        if module.__class__.__name__ == "ConformerYMT3SelfAttention":
+            if hasattr(module, "pos_bias_u"):
+                nn.init.xavier_uniform_(module.pos_bias_u)
+            if hasattr(module, "pos_bias_v"):
+                nn.init.xavier_uniform_(module.pos_bias_v)
+        elif isinstance(module, nn.Linear):
+            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
+            if module.bias is not None:
+                module.bias.data.zero_()
+        elif isinstance(module, (nn.LayerNorm, nn.GroupNorm)):
+            module.bias.data.zero_()
+            module.weight.data.fill_(1.0)
+        elif isinstance(module, nn.Conv1d):
+            nn.init.kaiming_normal_(module.weight)
+            if module.bias is not None:
+                k = math.sqrt(module.groups / (module.in_channels * module.kernel_size[0]))
+                nn.init.uniform_(module.bias, a=-k, b=k)
+
+    def _set_gradient_checkpointing(self, module, value=False):
+        if module.__class__.__name__ == "ConformerYMT3Encoder":
+            module.gradient_checkpointing = value

model/conformer_mod.py

@@ -0,0 +1,439 @@
+# Copyright 2024 The YourMT3 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
+#
+# Please see the details in the LICENSE file.
+from typing import Tuple, Literal, Any, Optional
+import math
+
+import torch
+from torch import nn
+from transformers.activations import ACT2FN
+from transformers.modeling_outputs import BaseModelOutput
+
+from model.conformer_helper import ConformerYMT3Config, ConformerYMT3PreTrainedModel
+from model.positional_encoding import (Wav2Vec2ConformerRelPositionalEmbedding,
+                                       Wav2Vec2ConformerRotaryPositionalEmbedding)
+
+
+class ConformerYMT3FeedForward(nn.Module):
+
+    def __init__(self, config):
+        super().__init__()
+        self.intermediate_dropout = nn.Dropout(config.dropout_rate)
+
+        self.intermediate_dense = nn.Linear(config.d_model, config.intermediate_size)
+        if isinstance(config.hidden_act, str):
+            self.intermediate_act_fn = ACT2FN[config.hidden_act]
+        else:
+            self.intermediate_act_fn = config.hidden_act
+
+        self.output_dense = nn.Linear(config.intermediate_size, config.d_model)
+        self.output_dropout = nn.Dropout(config.dropout_rate)
+
+    def forward(self, hidden_states):
+        hidden_states = self.intermediate_dense(hidden_states)
+        hidden_states = self.intermediate_act_fn(hidden_states)
+        hidden_states = self.intermediate_dropout(hidden_states)
+
+        hidden_states = self.output_dense(hidden_states)
+        hidden_states = self.output_dropout(hidden_states)
+        return hidden_states
+
+
+class ConformerYMT3ConvolutionModule(nn.Module):
+    """Convolution block used in the conformer block"""
+
+    def __init__(self, config):
+        super().__init__()
+        if (config.conv_depthwise_kernel_size - 1) % 2 == 1:
+            raise ValueError("`config.conv_depthwise_kernel_size` should be a odd number for 'SAME' padding")
+        self.layer_norm = nn.LayerNorm(config.d_model)
+        self.pointwise_conv1 = torch.nn.Conv1d(
+            config.d_model,
+            2 * config.d_model,
+            kernel_size=1,
+            stride=1,
+            padding=0,
+            bias=False,
+        )
+        self.glu = torch.nn.GLU(dim=1)
+        self.depthwise_conv = torch.nn.Conv1d(
+            config.d_model,
+            config.d_model,
+            config.conv_depthwise_kernel_size,
+            stride=1,
+            padding=(config.conv_depthwise_kernel_size - 1) // 2,
+            groups=config.d_model,
+            bias=False,
+        )
+        self.batch_norm = torch.nn.BatchNorm1d(config.d_model)
+        self.activation = ACT2FN[config.hidden_act]
+        self.pointwise_conv2 = torch.nn.Conv1d(
+            config.d_model,
+            config.d_model,
+            kernel_size=1,
+            stride=1,
+            padding=0,
+            bias=False,
+        )
+        self.dropout = torch.nn.Dropout(config.dropout_rate)
+
+    def forward(self, hidden_states):
+        hidden_states = self.layer_norm(hidden_states)
+        # exchange the temporal dimension and the feature dimension
+        hidden_states = hidden_states.transpose(1, 2)
+
+        # GLU mechanism
+        # => (batch, 2*channel, dim)
+        hidden_states = self.pointwise_conv1(hidden_states)
+        # => (batch, channel, dim)
+        hidden_states = self.glu(hidden_states)
+
+        # 1D Depthwise Conv
+        hidden_states = self.depthwise_conv(hidden_states)
+        hidden_states = self.batch_norm(hidden_states)
+        hidden_states = self.activation(hidden_states)
+
+        hidden_states = self.pointwise_conv2(hidden_states)
+        hidden_states = self.dropout(hidden_states)
+        hidden_states = hidden_states.transpose(1, 2)
+        return hidden_states
+
+
+class ConformerYMT3SelfAttention(nn.Module):
+    """Construct a ConformerSelfAttention object.
+    Can be enhanced with rotary or relative position embeddings.
+    """
+
+    def __init__(self, config):
+        super().__init__()
+
+        self.head_size = config.d_model // config.num_heads
+        self.num_heads = config.num_heads
+        self.position_encoding_type = config.position_encoding_type
+
+        self.linear_q = nn.Linear(config.d_model, config.d_model)
+        self.linear_k = nn.Linear(config.d_model, config.d_model)
+        self.linear_v = nn.Linear(config.d_model, config.d_model)
+        self.linear_out = nn.Linear(config.d_model, config.d_model)
+
+        self.dropout = nn.Dropout(p=config.dropout_rate)
+
+        if self.position_encoding_type == "relative":
+            # linear transformation for positional encoding
+            self.linear_pos = nn.Linear(config.d_model, config.d_model, bias=False)
+            # these two learnable bias are used in matrix c and matrix d
+            # as described in https://arxiv.org/abs/1901.02860 Section 3.3
+            self.pos_bias_u = nn.Parameter(torch.zeros(self.num_heads, self.head_size))
+            self.pos_bias_v = nn.Parameter(torch.zeros(self.num_heads, self.head_size))
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: Optional[torch.Tensor] = None,
+        relative_position_embeddings: Optional[torch.Tensor] = None,
+        output_attentions: bool = False,
+    ) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[Tuple[torch.Tensor]]]:
+        # self-attention mechanism
+        batch_size, sequence_length, d_model = hidden_states.size()
+
+        # make sure query/key states can be != value states
+        query_key_states = hidden_states
+        value_states = hidden_states
+
+        if self.position_encoding_type == "rotary":
+            if relative_position_embeddings is None:
+                raise ValueError(
+                    "`relative_position_embeddings` has to be defined when `self.position_encoding_type == 'rotary'")
+            query_key_states = self._apply_rotary_embedding(query_key_states, relative_position_embeddings)
+
+        # project query_key_states and value_states
+        query = self.linear_q(query_key_states).view(batch_size, -1, self.num_heads, self.head_size)
+        key = self.linear_k(query_key_states).view(batch_size, -1, self.num_heads, self.head_size)
+        value = self.linear_v(value_states).view(batch_size, -1, self.num_heads, self.head_size)
+
+        # => (batch, head, time1, d_k)
+        query = query.transpose(1, 2)
+        key = key.transpose(1, 2)
+        value = value.transpose(1, 2)
+
+        if self.position_encoding_type == "relative":
+            if relative_position_embeddings is None:
+                raise ValueError("`relative_position_embeddings` has to be defined when `self.position_encoding_type =="
+                                 " 'relative'")
+            # apply relative_position_embeddings to qk scores
+            # as proposed in Transformer_XL: https://arxiv.org/abs/1901.02860
+            scores = self._apply_relative_embeddings(query=query,
+                                                     key=key,
+                                                     relative_position_embeddings=relative_position_embeddings)
+        else:
+            scores = torch.matmul(query, key.transpose(-2, -1)) / math.sqrt(self.head_size)
+
+        # apply attention_mask if necessary
+        if attention_mask is not None:
+            scores = scores + attention_mask
+
+        # => (batch, head, time1, time2)
+        probs = torch.softmax(scores, dim=-1)
+        probs = self.dropout(probs)
+
+        # => (batch, head, time1, d_k)
+        hidden_states = torch.matmul(probs, value)
+
+        # => (batch, time1, d_model)
+        hidden_states = hidden_states.transpose(1, 2).reshape(batch_size, -1, self.num_heads * self.head_size)
+        hidden_states = self.linear_out(hidden_states)
+
+        return hidden_states, probs
+
+    def _apply_rotary_embedding(self, hidden_states, relative_position_embeddings):
+        batch_size, sequence_length, d_model = hidden_states.size()
+        hidden_states = hidden_states.view(batch_size, sequence_length, self.num_heads, self.head_size)
+
+        cos = relative_position_embeddings[0, :sequence_length, ...]
+        sin = relative_position_embeddings[1, :sequence_length, ...]
+
+        # rotate hidden_states with rotary embeddings
+        hidden_states = hidden_states.transpose(0, 1)
+        rotated_states_begin = hidden_states[..., :self.head_size // 2]
+        rotated_states_end = hidden_states[..., self.head_size // 2:]
+        rotated_states = torch.cat((-rotated_states_end, rotated_states_begin), dim=rotated_states_begin.ndim - 1)
+        hidden_states = (hidden_states * cos) + (rotated_states * sin)
+        hidden_states = hidden_states.transpose(0, 1)
+
+        hidden_states = hidden_states.view(batch_size, sequence_length, self.num_heads * self.head_size)
+
+        return hidden_states
+
+    def _apply_relative_embeddings(self, query, key, relative_position_embeddings):
+        # 1. project positional embeddings
+        # => (batch, head, 2*time1-1, d_k)
+        proj_relative_position_embeddings = self.linear_pos(relative_position_embeddings)
+        proj_relative_position_embeddings = proj_relative_position_embeddings.view(relative_position_embeddings.size(0),
+                                                                                   -1, self.num_heads, self.head_size)
+        proj_relative_position_embeddings = proj_relative_position_embeddings.transpose(1, 2)
+        proj_relative_position_embeddings = proj_relative_position_embeddings.transpose(2, 3)
+
+        # 2. Add bias to query
+        # => (batch, head, time1, d_k)
+        query = query.transpose(1, 2)
+        q_with_bias_u = (query + self.pos_bias_u).transpose(1, 2)
+        q_with_bias_v = (query + self.pos_bias_v).transpose(1, 2)
+
+        # 3. attention score: first compute matrix a and matrix c
+        # as described in https://arxiv.org/abs/1901.02860 Section 3.3
+        # => (batch, head, time1, time2)
+        scores_ac = torch.matmul(q_with_bias_u, key.transpose(-2, -1))
+
+        # 4. then compute matrix b and matrix d
+        # => (batch, head, time1, 2*time1-1)
+        scores_bd = torch.matmul(q_with_bias_v, proj_relative_position_embeddings)
+
+        # 5. shift matrix b and matrix d
+        zero_pad = torch.zeros((*scores_bd.size()[:3], 1), device=scores_bd.device, dtype=scores_bd.dtype)
+        scores_bd_padded = torch.cat([zero_pad, scores_bd], dim=-1)
+        scores_bd_padded_shape = scores_bd.size()[:2] + (scores_bd.shape[3] + 1, scores_bd.shape[2])
+        scores_bd_padded = scores_bd_padded.view(*scores_bd_padded_shape)
+        scores_bd = scores_bd_padded[:, :, 1:].view_as(scores_bd)
+        scores_bd = scores_bd[:, :, :, :scores_bd.size(-1) // 2 + 1]
+
+        # 6. sum matrices
+        # => (batch, head, time1, time2)
+        scores = (scores_ac + scores_bd) / math.sqrt(self.head_size)
+
+        return scores
+
+
+class ConformerYMT3EncoderLayer(nn.Module):
+    """Conformer block based on https://arxiv.org/abs/2005.08100."""
+
+    def __init__(self, config):
+        super().__init__()
+        embed_dim = config.d_model
+        dropout = config.dropout_rate
+
+        # Feed-forward 1
+        self.ffn1_layer_norm = nn.LayerNorm(embed_dim)
+        self.ffn1 = ConformerYMT3FeedForward(config)
+
+        # Self-Attention
+        self.self_attn_layer_norm = nn.LayerNorm(embed_dim)
+        self.self_attn_dropout = torch.nn.Dropout(dropout)
+        self.self_attn = ConformerYMT3SelfAttention(config)
+
+        # Conformer Convolution
+        self.conv_module = ConformerYMT3ConvolutionModule(config)
+
+        # Feed-forward 2
+        self.ffn2_layer_norm = nn.LayerNorm(embed_dim)
+        self.ffn2 = ConformerYMT3FeedForward(config)
+        self.final_layer_norm = nn.LayerNorm(embed_dim)
+
+    def forward(
+        self,
+        hidden_states,
+        attention_mask: Optional[torch.Tensor] = None,
+        relative_position_embeddings: Optional[torch.Tensor] = None,
+        output_attentions: bool = False,
+    ):
+        hidden_states = hidden_states
+
+        # 1. Feed-Forward 1 layer
+        residual = hidden_states
+        hidden_states = self.ffn1_layer_norm(hidden_states)
+        hidden_states = self.ffn1(hidden_states)
+        hidden_states = hidden_states * 0.5 + residual
+        residual = hidden_states
+
+        # 2. Self-Attention layer
+        hidden_states = self.self_attn_layer_norm(hidden_states)
+        hidden_states, attn_weigts = self.self_attn(
+            hidden_states=hidden_states,
+            attention_mask=attention_mask,
+            relative_position_embeddings=relative_position_embeddings,
+            output_attentions=output_attentions,
+        )
+        hidden_states = self.self_attn_dropout(hidden_states)
+        hidden_states = hidden_states + residual
+
+        # 3. Convolutional Layer
+        residual = hidden_states
+        hidden_states = self.conv_module(hidden_states)
+        hidden_states = residual + hidden_states
+
+        # 4. Feed-Forward 2 Layer
+        residual = hidden_states
+        hidden_states = self.ffn2_layer_norm(hidden_states)
+        hidden_states = self.ffn2(hidden_states)
+        hidden_states = hidden_states * 0.5 + residual
+        hidden_states = self.final_layer_norm(hidden_states)
+
+        return hidden_states, attn_weigts
+
+
+class ConformerYMT3Encoder(nn.Module):
+
+    def __init__(self, config):
+        super().__init__()
+        self.config = config
+
+        if config.position_encoding_type == "relative":
+            self.embed_positions = Wav2Vec2ConformerRelPositionalEmbedding(config)
+        elif config.position_encoding_type == "rotary":
+            self.embed_positions = Wav2Vec2ConformerRotaryPositionalEmbedding(config)
+        else:
+            self.embed_positions = None
+
+        # self.pos_conv_embed = Wav2Vec2ConformerPositionalConvEmbedding(config)
+        self.layer_norm = nn.LayerNorm(config.d_model, eps=config.layer_norm_eps)
+        self.dropout = nn.Dropout(config.dropout_rate)
+        self.layers = nn.ModuleList([ConformerYMT3EncoderLayer(config) for _ in range(config.num_layers)])
+        self.gradient_checkpointing = False
+
+    def forward(
+        self,
+        inputs_embeds: torch.FloatTensor,  # (B, T, D) 
+        attention_mask: Optional[torch.FloatTensor] = None,
+        output_attentions: Optional[bool] = False,
+        output_hidden_states: Optional[bool] = False,
+        return_dict: Optional[bool] = True,
+    ):
+        if output_attentions is None:
+            output_attentions = self.config.output_attentions
+        if output_hidden_states is None:
+            output_hidden_states = self.config.output_hidden_states
+        if return_dict is None:
+            return_dict = self.config.use_return_dict
+        all_hidden_states = () if output_hidden_states else None
+        all_self_attentions = () if output_attentions else None
+
+        # inputs_embeds as hidden_states
+        hidden_states = inputs_embeds
+
+        if attention_mask is not None:
+            # make sure padded tokens output 0
+            hidden_states[~attention_mask] = 0.0
+
+            # extend attention_mask
+            attention_mask = 1.0 - attention_mask[:, None, None, :].to(dtype=hidden_states.dtype)
+            attention_mask = attention_mask * torch.finfo(hidden_states.dtype).min
+            attention_mask = attention_mask.expand(attention_mask.shape[0], 1, attention_mask.shape[-1],
+                                                   attention_mask.shape[-1])
+
+        hidden_states = self.dropout(hidden_states)
+
+        if self.embed_positions is not None:
+            relative_position_embeddings = self.embed_positions(hidden_states)
+        else:
+            relative_position_embeddings = None
+
+        for i, layer in enumerate(self.layers):
+            if output_hidden_states:
+                all_hidden_states = all_hidden_states + (hidden_states,)
+
+            # add LayerDrop (see https://arxiv.org/abs/1909.11556 for description)
+            dropout_probability = torch.rand([])
+
+            skip_the_layer = True if self.training and (dropout_probability < self.config.layerdrop) else False
+            if not skip_the_layer:
+                # under deepspeed zero3 all gpus must run in sync
+                if self.gradient_checkpointing and self.training:
+                    # create gradient checkpointing function
+                    def create_custom_forward(module):
+
+                        def custom_forward(*inputs):
+                            return module(*inputs, output_attentions)
+
+                        return custom_forward
+
+                    layer_outputs = torch.utils.checkpoint.checkpoint(
+                        create_custom_forward(layer),
+                        hidden_states,
+                        attention_mask,
+                        relative_position_embeddings,
+                    )
+                else:
+                    layer_outputs = layer(
+                        hidden_states,
+                        attention_mask=attention_mask,
+                        relative_position_embeddings=relative_position_embeddings,
+                        output_attentions=output_attentions,
+                    )
+                hidden_states = layer_outputs[0]
+
+            if skip_the_layer:
+                layer_outputs = (None, None)
+
+            if output_attentions:
+                all_self_attentions = all_self_attentions + (layer_outputs[1],)
+
+        hidden_states = self.layer_norm(hidden_states)
+        if output_hidden_states:
+            all_hidden_states = all_hidden_states + (hidden_states,)
+
+        if not return_dict:
+            return tuple(v for v in [hidden_states, all_hidden_states, all_self_attentions] if v is not None)
+        return BaseModelOutput(
+            last_hidden_state=hidden_states,
+            hidden_states=all_hidden_states,
+            attentions=all_self_attentions,
+        )
+
+
+def test():
+    import torch
+    from model.conformer_mod import ConformerYMT3Encoder
+    from model.conformer_helper import ConformerYMT3Config
+    from model.ops import count_parameters
+    config = ConformerYMT3Config()
+    encoder = ConformerYMT3Encoder(config)
+    encoder.eval()
+    # num params: 48,468,992 w/ intermediate_size=2048
+    # num params: 23,278,592 w/ intermediate_size=512
+    x = torch.randn(2, 256, 512)  # (B, T, D)
+    enc_hs = encoder.forward(inputs_embeds=x)['last_hidden_state']  # (B, T, D)

model/ff_layer.py

@@ -0,0 +1,238 @@
+# Copyright 2024 The YourMT3 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
+#
+# Please see the details in the LICENSE file.
+"""ff_layer.py
+
+This module contains the implementation of the feedforward layers.
+
+    Supported ff_layer_type:
+        'mlp': Multi-Layer Perceptron
+        'gmlp': Gated Multi-Layer Perceptron, simplified version of Mixtral Expert with num_experts=1 and top_k=1.
+                This is not the spatial gating MLP (https://arxiv.org/abs/2105.08050).
+        'moe': Mixtral of Experts, modified from the original source code:
+            https://github.com/huggingface/transformers/blob/v4.38.2/src/transformers/models/mixtral/modeling_mixtral.py
+
+    Usage:
+        from model.ff_layer import get_ff_layer
+
+        config = PerceiverTFConfig() # or any type of PretrainedConfig()
+        config.ff_layer_type = 'moe' # or 'mlp'
+        config.moe_num_experts = 4
+        config.moe_topk = 2
+        config.hidden_act = 'gelu' # or any type of activation function, e.g., 'silu'
+
+        ff_layer = get_ff_layer(config, input_size, widening_factor)
+
+    What ff_layer returns:
+        - It returns (hidden_states, router_logits) for MoE and (hidden_states, None) for MLP.
+        - router_logits has the shape of (batch_size * sequence_length, n_experts) for MoE.
+
+   
+"""
+from typing import Any, Tuple
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from transformers.configuration_utils import PretrainedConfig
+from transformers.activations import ACT2FN
+from model.ops import get_layer_norm
+from model.ops import optional_compiler_disable, optional_compiler_dynamic
+
+
+class MixtralBlockSparseTop2MLP(nn.Module):
+    """
+    The Gated Multilayer Perceptron (GMLP) used in Mixtral of Experts (MoE).
+
+    """
+
+    def __init__(self, config: PretrainedConfig, input_size: int, widening_factor: int):
+        super().__init__()
+        self.hidden_dim = input_size
+        self.ffn_dim = int(input_size * widening_factor)
+
+        self.w1 = nn.Linear(self.hidden_dim, self.ffn_dim, bias=False)
+        self.w2 = nn.Linear(self.ffn_dim, self.hidden_dim, bias=False)
+        self.gate = nn.Linear(self.hidden_dim, self.ffn_dim, bias=False)
+        self.act_fn = ACT2FN[config.hidden_act]
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        current_hidden_states = self.act_fn(self.w1(hidden_states)) * self.gate(hidden_states)
+        current_hidden_states = self.w2(current_hidden_states)
+        return current_hidden_states
+
+
+class MixtralSparseMoeBlock(nn.Module):
+    """
+    This implementation is
+    strictly equivalent to standard MoE with full capacity (no
+    dropped tokens). It's faster since it formulates MoE operations
+    in terms of block-sparse operations to accomodate imbalanced
+    assignments of tokens to experts, whereas standard MoE either
+    (1) drop tokens at the cost of reduced performance or (2) set
+    capacity factor to number of experts and thus waste computation
+    and memory on padding.
+    """
+
+    def __init__(self, config, input_size: int, widening_factor: int):
+        super().__init__()
+        self.hidden_dim = input_size
+        self.widening_factor = widening_factor
+        self.num_experts = config.moe_num_experts
+        self.top_k = config.moe_topk
+
+        # gating
+        self.gate = nn.Linear(self.hidden_dim, self.num_experts, bias=False)
+        self.experts = nn.ModuleList(
+            [MixtralBlockSparseTop2MLP(config, self.hidden_dim, self.widening_factor) for _ in range(self.num_experts)])
+
+    @optional_compiler_disable
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        """ """
+        batch_size, sequence_length, hidden_dim = hidden_states.shape
+        hidden_states = hidden_states.view(-1, hidden_dim)
+        # router_logits: (batch * sequence_length, n_experts)
+        router_logits = self.gate(hidden_states)
+
+        routing_weights = F.softmax(router_logits, dim=1, dtype=torch.float)
+        routing_weights, selected_experts = torch.topk(routing_weights, self.top_k, dim=-1)
+        routing_weights /= routing_weights.sum(dim=-1, keepdim=True)
+        # we cast back to the input dtype
+        routing_weights = routing_weights.to(hidden_states.dtype)
+
+        final_hidden_states = torch.zeros((batch_size * sequence_length, hidden_dim),
+                                          dtype=hidden_states.dtype,
+                                          device=hidden_states.device)
+
+        # One hot encode the selected experts to create an expert mask
+        # this will be used to easily index which expert is going to be sollicitated
+        expert_mask = torch.nn.functional.one_hot(selected_experts, num_classes=self.num_experts).permute(2, 1, 0)
+
+        # Loop over all available experts in the model and perform the computation on each expert
+        for expert_idx in range(self.num_experts):
+            expert_layer = self.experts[expert_idx]
+            idx, top_x = torch.where(expert_mask[expert_idx])
+
+            if top_x.shape[0] == 0:
+                continue
+
+            # in torch it is faster to index using lists than torch tensors
+            top_x_list = top_x.tolist()
+            idx_list = idx.tolist()
+
+            # Index the correct hidden states and compute the expert hidden state for
+            # the current expert. We need to make sure to multiply the output hidden
+            # states by `routing_weights` on the corresponding tokens (top-1 and top-2)
+            current_state = hidden_states[None, top_x_list].reshape(-1, hidden_dim)
+            current_hidden_states = expert_layer(current_state) * routing_weights[top_x_list, idx_list, None]
+
+            # However `index_add_` only support torch tensors for indexing so we'll use
+            # the `top_x` tensor here.
+            final_hidden_states.index_add_(0, top_x, current_hidden_states.to(hidden_states.dtype))
+        final_hidden_states = final_hidden_states.reshape(batch_size, sequence_length, hidden_dim)
+        return final_hidden_states, router_logits
+
+
+class MLP(nn.Module):
+    """A Standard Transformer-style dense module to follow attention."""
+
+    def __init__(self, config: PretrainedConfig, input_size: int, widening_factor: int):
+        super().__init__()
+        self.dense1 = nn.Linear(input_size, widening_factor * input_size)
+        self.dense2 = nn.Linear(widening_factor * input_size, input_size)
+
+        if isinstance(config.hidden_act, str):
+            self.intermediate_act_fn = ACT2FN[config.hidden_act]
+        else:
+            self.intermediate_act_fn = config.hidden_act
+
+    def forward(self, hidden_states: torch.Tensor) -> Tuple[torch.Tensor, Any]:
+        hidden_states = self.dense1(hidden_states)
+        hidden_states = self.intermediate_act_fn(hidden_states)
+        hidden_states = self.dense2(hidden_states)
+        return hidden_states, None
+
+
+class SimpleGMLP(nn.Module):
+    """A Simple Gated Multilayer Perceptron (aka. 'gmlp'), without the spatial gating mechanism.
+    
+    Note that this is not the spatial gating MLP (https://arxiv.org/abs/2105.08050).
+    - A simplified MLP w/ gating mechanism adapted from Mixtral Expert, as when
+    the number of experts and top_k are both set to 1.)
+    - Added a dropout layer. 
+    - This was also used in T5 v1.1.
+    """
+
+    def __init__(self, config: PretrainedConfig, input_size: int, widening_factor: int):
+        super().__init__()
+        self.hidden_dim = input_size
+        self.ffn_dim = int(input_size * widening_factor)
+
+        self.w1 = nn.Linear(self.hidden_dim, self.ffn_dim, bias=False)
+        self.w2 = nn.Linear(self.ffn_dim, self.hidden_dim, bias=False)
+        self.gate = nn.Linear(self.hidden_dim, self.ffn_dim, bias=False)
+        self.act_fn = ACT2FN[config.hidden_act]
+        self.dropout1 = nn.Dropout(config.dropout_rate)
+        self.dropout2 = nn.Dropout(config.dropout_rate)
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        current_hidden_states = self.act_fn(self.w1(hidden_states)) * self.gate(hidden_states)
+        current_hidden_states = self.dropout1(current_hidden_states)
+        current_hidden_states = self.w2(current_hidden_states)
+        current_hidden_states = self.dropout2(
+            current_hidden_states)  # Residual connection is applied outside of this module.
+        return current_hidden_states, None
+
+
+def get_ff_layer(config: PretrainedConfig, input_size: int, widening_factor: int):
+    if config.ff_layer_type == 'moe':
+        assert hasattr(config, 'moe_num_experts') and hasattr(config, 'moe_topk') and hasattr(config, 'hidden_act')
+        return MixtralSparseMoeBlock(config, input_size, widening_factor)
+    elif config.ff_layer_type == 'mlp':
+        assert hasattr(config, 'hidden_act')
+        return MLP(config, input_size, widening_factor)
+    elif config.ff_layer_type == 'gmlp':
+        assert hasattr(config, 'hidden_act')
+        return SimpleGMLP(config, input_size, widening_factor)
+    else:
+        raise ValueError(
+            f"Unsupported ff_layer_type: {config.ff_layer_type}. Supported types are 'moe', 'mlp' and 'gmlp'.")
+
+
+def test_get_ff_layer():
+    from model.ff_layer import get_ff_layer
+    from model.perceiver_helper import PerceiverTFConfig
+    input_size = 32
+    widening_factor = 1
+
+    # Test for MoE
+    config = PerceiverTFConfig()  # or any type of PretrainedConfig()
+    config.ff_layer_type = 'moe'
+    config.moe_num_experts = 4
+    config.moe_topk = 2
+    config.hidden_act = 'silu'
+
+    ff_layer = get_ff_layer(config, input_size, widening_factor)
+    x = torch.rand(2, 8, input_size)
+    hidden_states, router_logits = ff_layer(x)
+    print(hidden_states.shape, router_logits.shape)  # (2, 8, 32), (2*8, 4)
+
+    # Test for MLP
+    config.ff_layer_type = 'mlp'
+    config.hidden_act = 'gelu'
+
+    ff_layer = get_ff_layer(config, input_size, widening_factor)
+    hidden_states, _ = ff_layer(x)
+    print(hidden_states.shape)  # (2, 8, 32)
+
+    # Test for (simple)gMLP
+    config.ff_layer_type = 'gmlp'
+    config.hidden_act = 'silu'
+    ff_layer = get_ff_layer(config, input_size, widening_factor)
+    hidden_states, _ = ff_layer(x)
+    print(hidden_states.shape)  # (2, 8, 32)

model/init_train.py

@@ -0,0 +1,281 @@
+# Copyright 2024 The YourMT3 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
+#
+# Please see the details in the LICENSE file.
+"""init_train.py"""
+from typing import Tuple, Literal, Any
+from copy import deepcopy
+import os
+import argparse
+import pytorch_lightning as pl
+from pytorch_lightning.loggers import WandbLogger
+from pytorch_lightning.callbacks import ModelCheckpoint
+from pytorch_lightning.callbacks import LearningRateMonitor
+from pytorch_lightning.utilities import rank_zero_only
+from config.config import shared_cfg as default_shared_cfg
+from config.config import audio_cfg as default_audio_cfg
+from config.config import model_cfg as default_model_cfg
+from config.config import DEEPSPEED_CFG
+
+
+def initialize_trainer(args: argparse.Namespace,
+                       stage: Literal['train', 'test'] = 'train') -> Tuple[pl.Trainer, WandbLogger, dict]:
+    """Initialize trainer and logger"""
+    shared_cfg = deepcopy(default_shared_cfg)
+
+    # create save dir
+    os.makedirs(shared_cfg["WANDB"]["save_dir"], exist_ok=True)
+
+    # collecting specific checkpoint from exp_id with extension (@xxx where xxx is checkpoint name)
+    if "@" in args.exp_id:
+        args.exp_id, checkpoint_name = args.exp_id.split("@")
+    else:
+        checkpoint_name = "last.ckpt"
+
+    # checkpoint dir
+    lightning_dir = os.path.join(shared_cfg["WANDB"]["save_dir"], args.project, args.exp_id)
+
+    # create logger
+    if args.wandb_mode is not None:
+        shared_cfg["WANDB"]["mode"] = str(args.wandb_mode)
+    if shared_cfg["WANDB"].get("cache_dir", None) is not None:
+        os.environ["WANDB_CACHE_DIR"] = shared_cfg["WANDB"].get("cache_dir")
+        del shared_cfg["WANDB"]["cache_dir"]  # remove cache_dir from shared_cfg
+    wandb_logger = WandbLogger(log_model="all",
+                               project=args.project,
+                               id=args.exp_id,
+                               allow_val_change=True,
+                               **shared_cfg['WANDB'])
+
+    # check if any checkpoint exists
+    last_ckpt_path = os.path.join(lightning_dir, "checkpoints", checkpoint_name)
+    if os.path.exists(os.path.join(last_ckpt_path)):
+        print(f'Resuming from {last_ckpt_path}')
+    elif stage == 'train':
+        print(f'No checkpoint found in {last_ckpt_path}. Starting from scratch')
+        last_ckpt_path = None
+    else:
+        raise ValueError(f'No checkpoint found in {last_ckpt_path}. Quit...')
+
+    # add info
+    dir_info = dict(lightning_dir=lightning_dir, last_ckpt_path=last_ckpt_path)
+
+    # define checkpoint callback
+    checkpoint_callback = ModelCheckpoint(**shared_cfg["CHECKPOINT"],)
+
+    # define lr scheduler monitor callback
+    lr_monitor = LearningRateMonitor(logging_interval='step')
+
+    # deepspeed strategy
+    if args.strategy == 'deepspeed':
+        strategy = pl.strategies.DeepSpeedStrategy(config=DEEPSPEED_CFG)
+
+    # validation interval
+    if stage == 'train' and args.val_interval is not None:
+        shared_cfg["TRAINER"]["check_val_every_n_epoch"] = None
+        shared_cfg["TRAINER"]["val_check_interval"] = int(args.val_interval)
+
+    # define trainer
+    sync_batchnorm = False
+    if stage == 'train':
+        # train batch size
+        if args.train_batch_size is not None:
+            train_sub_bsz = int(args.train_batch_size[0])
+            train_local_bsz = int(args.train_batch_size[1])
+            if train_local_bsz % train_sub_bsz == 0:
+                shared_cfg["BSZ"]["train_sub"] = train_sub_bsz
+                shared_cfg["BSZ"]["train_local"] = train_local_bsz
+            else:
+                raise ValueError(
+                    f'Local batch size {train_local_bsz} must be divisible by sub batch size {train_sub_bsz}')
+
+        # ddp strategy
+        if args.strategy == 'ddp':
+            args.strategy = 'ddp_find_unused_parameters_true'  # fix for conformer or pitchshifter having unused parameter issue
+
+            # sync-batchnorm
+            if args.sync_batchnorm is True:
+                sync_batchnorm = True
+
+    train_params = dict(**shared_cfg["TRAINER"],
+                        devices=args.num_gpus if args.num_gpus == 'auto' else int(args.num_gpus),
+                        num_nodes=int(args.num_nodes),
+                        strategy=strategy if args.strategy == 'deepspeed' else args.strategy,
+                        precision=args.precision,
+                        max_epochs=args.max_epochs if stage == 'train' else None,
+                        max_steps=args.max_steps if stage == 'train' else -1,
+                        logger=wandb_logger,
+                        callbacks=[checkpoint_callback, lr_monitor],
+                        sync_batchnorm=sync_batchnorm)
+    trainer = pl.trainer.trainer.Trainer(**train_params)
+
+    # Update wandb logger (for DDP)
+    if trainer.global_rank == 0:
+        wandb_logger.experiment.config.update(args, allow_val_change=True)
+
+    return trainer, wandb_logger, dir_info, shared_cfg
+
+
+def update_config(args, shared_cfg, stage: Literal['train', 'test'] = 'train'):
+    """Update audio/model/shared configurations with args"""
+    audio_cfg = default_audio_cfg
+    model_cfg = default_model_cfg
+
+    # Only update config when training
+    if stage == 'train':
+        # Augmentation parameters
+        if args.random_amp_range is not None:
+            shared_cfg["AUGMENTATION"]["train_random_amp_range"] = list(
+                (float(args.random_amp_range[0]), float(args.random_amp_range[1])))
+        if args.stem_iaug_prob is not None:
+            shared_cfg["AUGMENTATION"]["train_stem_iaug_prob"] = float(args.stem_iaug_prob)
+
+        if args.xaug_max_k is not None:
+            shared_cfg["AUGMENTATION"]["train_stem_xaug_policy"]["max_k"] = int(args.xaug_max_k)
+        if args.xaug_tau is not None:
+            shared_cfg["AUGMENTATION"]["train_stem_xaug_policy"]["tau"] = float(args.xaug_tau)
+        if args.xaug_alpha is not None:
+            shared_cfg["AUGMENTATION"]["train_stem_xaug_policy"]["alpha"] = float(args.xaug_alpha)
+        if args.xaug_no_instr_overlap is not None:
+            shared_cfg["AUGMENTATION"]["train_stem_xaug_policy"]["no_instr_overlap"] = bool(args.xaug_no_instr_overlap)
+        if args.xaug_no_drum_overlap is not None:
+            shared_cfg["AUGMENTATION"]["train_stem_xaug_policy"]["no_drum_overlap"] = bool(args.xaug_no_drum_overlap)
+        if args.uhat_intra_stem_augment is not None:
+            shared_cfg["AUGMENTATION"]["train_stem_xaug_policy"]["uhat_intra_stem_augment"] = bool(
+                args.uhat_intra_stem_augment)
+
+        if args.pitch_shift_range is not None:
+            if args.pitch_shift_range in [["0", "0"], [0, 0]]:
+                shared_cfg["AUGMENTATION"]["train_pitch_shift_range"] = None
+            else:
+                shared_cfg["AUGMENTATION"]["train_pitch_shift_range"] = list(
+                    (int(args.pitch_shift_range[0]), int(args.pitch_shift_range[1])))
+
+        train_stem_iaug_prob = shared_cfg["AUGMENTATION"]["train_stem_iaug_prob"]
+        random_amp_range = shared_cfg["AUGMENTATION"]["train_random_amp_range"]
+        train_stem_xaug_policy = shared_cfg["AUGMENTATION"]["train_stem_xaug_policy"]
+        print(f'Random amp range: {random_amp_range}\n' +
+              f'Intra-stem augmentation probability: {train_stem_iaug_prob}\n' +
+              f'Stem augmentation policy: {train_stem_xaug_policy}\n' +
+              f'Pitch shift range: {shared_cfg["AUGMENTATION"]["train_pitch_shift_range"]}\n')
+
+    # Update audio config
+    if args.audio_codec != None:
+        assert args.audio_codec in ['spec', 'melspec']
+        audio_cfg["codec"] = str(args.audio_codec)
+    if args.hop_length != None:
+        audio_cfg["hop_length"] = int(args.hop_length)
+    if args.n_mels != None:
+        audio_cfg["n_mels"] = int(args.n_mels)
+    if args.input_frames != None:
+        audio_cfg["input_frames"] = int(args.input_frames)
+
+    # Update shared config
+    if shared_cfg["TOKENIZER"]["max_shift_steps"] == "auto":
+        shift_steps_ms = shared_cfg["TOKENIZER"]["shift_step_ms"]
+        input_frames = audio_cfg["input_frames"]
+        fs = audio_cfg["sample_rate"]
+        max_shift_steps = (input_frames / fs) // (shift_steps_ms / 1000) + 2  # 206 by default
+        shared_cfg["TOKENIZER"]["max_shift_steps"] = int(max_shift_steps)
+
+    # Update model config
+    if args.encoder_type != None:
+        model_cfg["encoder_type"] = str(args.encoder_type)
+    if args.decoder_type != None:
+        model_cfg["decoder_type"] = str(args.decoder_type)
+    if args.pre_encoder_type != "default":
+        model_cfg["pre_encoder_type"] = str(args.pre_encoder_type)
+    if args.pre_decoder_type != 'default':
+        model_cfg["pre_decoder_type"] = str(args.pre_decoder_type)
+    if args.conv_out_channels != None:
+        model_cfg["conv_out_channels"] = int(args.conv_out_channels)
+    assert isinstance(args.task_cond_decoder, bool) and isinstance(args.task_cond_encoder, bool)
+    model_cfg["use_task_conditional_encoder"] = args.task_cond_encoder
+    model_cfg["use_task_conditional_decoder"] = args.task_cond_decoder
+
+    if args.encoder_position_encoding_type != 'default':
+        if args.encoder_position_encoding_type in ['None', 'none', '0']:
+            model_cfg["encoder"][model_cfg["encoder_type"]]["position_encoding_type"] = None
+        elif args.encoder_position_encoding_type in [
+                'sinusoidal', 'rope', 'trainable', 'alibi', 'alibit', 'tkd', 'td', 'tk', 'kdt'
+        ]:
+            model_cfg["encoder"][model_cfg["encoder_type"]]["position_encoding_type"] = str(
+                args.encoder_position_encoding_type)
+        else:
+            raise ValueError(f'Encoder PE type {args.encoder_position_encoding_type} not supported')
+    if args.decoder_position_encoding_type != 'default':
+        if args.decoder_position_encoding_type in ['None', 'none', '0']:
+            raise ValueError('Decoder PE type cannot be None')
+        elif args.decoder_position_encoding_type in ['sinusoidal', 'trainable']:
+            model_cfg["decoder"][model_cfg["decoder_type"]]["position_encoding_type"] = str(
+                args.decoder_position_encoding_type)
+        else:
+            raise ValueError(f'Decoder PE {args.decoder_position_encoding_type} not supported')
+
+    if args.tie_word_embedding is not None:
+        model_cfg["tie_word_embedding"] = bool(args.tie_word_embedding)
+
+    if args.d_feat != None:
+        model_cfg["d_feat"] = int(args.d_feat)
+    if args.d_latent != None:
+        model_cfg['encoder']['perceiver-tf']["d_latent"] = int(args.d_latent)
+    if args.num_latents != None:
+        model_cfg['encoder']['perceiver-tf']['num_latents'] = int(args.num_latents)
+    if args.perceiver_tf_d_model != None:
+        model_cfg['encoder']['perceiver-tf']['d_model'] = int(args.perceiver_tf_d_model)
+    if args.num_perceiver_tf_blocks != None:
+        model_cfg["encoder"]["perceiver-tf"]["num_blocks"] = int(args.num_perceiver_tf_blocks)
+    if args.num_perceiver_tf_local_transformers_per_block != None:
+        model_cfg["encoder"]["perceiver-tf"]["num_local_transformers_per_block"] = int(
+            args.num_perceiver_tf_local_transformers_per_block)
+    if args.num_perceiver_tf_temporal_transformers_per_block != None:
+        model_cfg["encoder"]["perceiver-tf"]["num_temporal_transformers_per_block"] = int(
+            args.num_perceiver_tf_temporal_transformers_per_block)
+    if args.attention_to_channel != None:
+        model_cfg["encoder"]["perceiver-tf"]["attention_to_channel"] = bool(args.attention_to_channel)
+    if args.sca_use_query_residual != None:
+        model_cfg["encoder"]["perceiver-tf"]["sca_use_query_residual"] = bool(args.sca_use_query_residual)
+    if args.layer_norm_type != None:
+        model_cfg["encoder"]["perceiver-tf"]["layer_norm"] = str(args.layer_norm_type)
+    if args.ff_layer_type != None:
+        model_cfg["encoder"]["perceiver-tf"]["ff_layer_type"] = str(args.ff_layer_type)
+    if args.ff_widening_factor != None:
+        model_cfg["encoder"]["perceiver-tf"]["ff_widening_factor"] = int(args.ff_widening_factor)
+    if args.moe_num_experts != None:
+        model_cfg["encoder"]["perceiver-tf"]["moe_num_experts"] = int(args.moe_num_experts)
+    if args.moe_topk != None:
+        model_cfg["encoder"]["perceiver-tf"]["moe_topk"] = int(args.moe_topk)
+    if args.hidden_act != None:
+        model_cfg["encoder"]["perceiver-tf"]["hidden_act"] = str(args.hidden_act)
+    if args.rotary_type != None:
+        assert len(
+            args.rotary_type
+        ) == 3, "rotary_type must be a 3-letter string (e.g. 'ppl': 'pixel' for SCA, 'pixel' for latent, 'lang' for temporal transformer)"
+        model_cfg["encoder"]["perceiver-tf"]["rotary_type_sca"] = str(args.rotary_type)[0]
+        model_cfg["encoder"]["perceiver-tf"]["rotary_type_latent"] = str(args.rotary_type)[1]
+        model_cfg["encoder"]["perceiver-tf"]["rotary_type_temporal"] = str(args.rotary_type)[2]
+    if args.rope_apply_to_keys != None:
+        model_cfg["encoder"]["perceiver-tf"]["rope_apply_to_keys"] = bool(args.rope_apply_to_keys)
+    if args.rope_partial_pe != None:
+        model_cfg["encoder"]["perceiver-tf"]["rope_partial_pe"] = bool(args.rope_partial_pe)
+
+    if args.decoder_ff_layer_type != None:
+        model_cfg["decoder"][model_cfg["decoder_type"]]["ff_layer_type"] = str(args.decoder_ff_layer_type)
+    if args.decoder_ff_widening_factor != None:
+        model_cfg["decoder"][model_cfg["decoder_type"]]["ff_widening_factor"] = int(args.decoder_ff_widening_factor)
+
+    if args.event_length != None:
+        model_cfg["event_length"] = int(args.event_length)
+
+    if stage == 'train':
+        if args.encoder_dropout_rate != None:
+            model_cfg["encoder"][model_cfg["encoder_type"]]["dropout_rate"] = float(args.encoder_dropout_rate)
+        if args.decoder_dropout_rate != None:
+            model_cfg["decoder"][model_cfg["decoder_type"]]["dropout_rate"] = float(args.decoder_dropout_rate)
+
+    return shared_cfg, audio_cfg, model_cfg  # return updated configs

model/lm_head.py

@@ -0,0 +1,40 @@
+# Copyright 2024 The YourMT3 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
+#
+# Please see the details in the LICENSE file.
+"""lm_head.py"""
+import torch
+from torch import nn
+from typing import Optional, Dict
+
+
+class LMHead(nn.Module):
+    """Language Model Head with tied weights."""
+
+    def __init__(self, decoder_config: Dict, init_factor: float = 1.0, tie_word_embeddings: bool = True):
+
+        super().__init__()
+        self.d_model = decoder_config["d_model"]
+        self.init_factor = init_factor
+        self.tie_word_embeddings = tie_word_embeddings
+
+        self.lm_head = nn.Linear(decoder_config["d_model"], decoder_config["vocab_size"], bias=False)
+        self._init_weights()
+
+    def _init_weights(self):
+        if self.tie_word_embeddings is False:
+            self.lm_head.weight.data.normal_(mean=0.0, std=self.init_factor * 1.0)
+
+    def forward(self, decoder_hs: torch.FloatTensor) -> torch.FloatTensor:
+        if self.tie_word_embeddings is True:
+            # Rescale output before projecting on vocab
+            # See https://github.com/tensorflow/mesh/blob/fa19d69eafc9a482aff0b59ddd96b025c0cb207d/mesh_tensorflow/transformer/transformer.py#L586
+            decoder_hs = decoder_hs * (self.d_model**-0.5)
+
+        lm_logits = self.lm_head(decoder_hs)
+        return lm_logits

model/ops.py

@@ -0,0 +1,111 @@
+# Copyright 2024 The YourMT3 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
+#
+# Please see the details in the LICENSE file.
+""" op.py """
+import math
+from packaging.version import parse as VersionParse
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from einops import rearrange
+from transformers.models.t5.modeling_t5 import T5LayerNorm as RMSNorm
+
+
+def get_layer_norm(dim: int, layer_norm_type: str = "layer_norm", layer_norm_eps: float = 1e-5):
+    """Get layer normalization layer.
+    Args:
+        dim (int): Feature dimension
+        layer_norm_type (str): "layer_norm" or "rms_norm"
+        layer_norm_eps (float): Epsilon value for numerical stability
+
+    Returns:
+        nn.Module: Layer normalization layer
+    """
+    if layer_norm_type == "rms_norm":
+        # T5LayerNorm is equivalent to RMSNorm. https://arxiv.org/abs/1910.07467
+        return RMSNorm(hidden_size=dim, eps=layer_norm_eps)
+    else:
+        return nn.LayerNorm(normalized_shape=dim, eps=layer_norm_eps)
+
+
+def check_all_elements_equal(x: torch.Tensor) -> bool:
+    return x.eq(x[0]).all().item()
+
+
+def minmax_normalize(x: torch.Tensor, eps: float = 0.008) -> torch.FloatTensor:
+    """Min-max normalization:
+
+    x_norm = (x - x_min) / (x_max - x_min + eps)
+
+    Args:
+        x (torch.Tensor): (B, T, F)
+    Returns:
+        torch.Tensor: (B, T, F) with output range of [0, 1]
+    """
+    x_max = rearrange(x, "b t f -> b (t f)").max(1, keepdim=True)[0]
+    x_min = rearrange(x, "b t f -> b (f t)").min(1, keepdim=True)[0]
+    x_max = x_max[:, None, :]  # (B,1,1)
+    x_min = x_min[:, None, :]  # (B,1,1)
+    return (x - x_min) / (x_max - x_min + eps)
+
+
+def count_parameters(model):
+    num_trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    num_params = sum(p.numel() for p in model.parameters())
+    return num_trainable_params, num_params
+
+
+def adjust_b_to_gcd(a, b, min_gcd=16):
+    """
+    Adjust the value of b to ensure the GCD(a, b) is at least min_gcd with minimum change to b.
+    
+    Parameters:
+    - a (int): A positive integer
+    - b (int): A positive integer
+    - min_gcd (int): The minimum desired GCD
+    
+    Returns:
+    - int: The adjusted value of b
+    """
+    current_gcd = math.gcd(a, b)
+
+    # If current GCD is already greater than or equal to min_gcd, return b as it is.
+    if current_gcd >= min_gcd:
+        return b
+
+    # If a is less than min_gcd, then it's impossible to get a GCD of at least min_gcd.
+    if a < min_gcd:
+        raise ValueError("a must be at least as large as min_gcd.")
+
+    # Adjust b by trying increments and decrements, preferring the smallest absolute change.
+    adjusted_b_up = b
+    adjusted_b_down = b
+
+    while True:
+        adjusted_b_up += 1
+        adjusted_b_down -= 1
+
+        if math.gcd(a, adjusted_b_up) >= min_gcd:
+            return adjusted_b_up
+        elif math.gcd(a, adjusted_b_down) >= min_gcd:
+            return adjusted_b_down
+
+
+def optional_compiler_disable(func):
+    if VersionParse(torch.__version__) >= VersionParse("2.1"):
+        # If the version is 2.1 or higher, apply the torch.compiler.disable decorator.
+        return torch.compiler.disable(func)
+    else:
+        # If the version is below 2.1, return the original function.
+        return func
+
+
+def optional_compiler_dynamic(func):
+    return torch.compile(func, dynamic=True)

model/perceiver_helper.py

@@ -0,0 +1,290 @@
+# Copyright 2024 The YourMT3 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
+#
+# Please see the details in the LICENSE file.
+from dataclasses import dataclass
+from typing import Optional, Tuple
+import torch
+from torch import nn
+from transformers.utils import ModelOutput
+from transformers.configuration_utils import PretrainedConfig
+from transformers.modeling_utils import PreTrainedModel
+# from transformers.models.perceiver.modeling_perceiver import (PerceiverAbstractPositionEncoding,
+#                                                               PerceiverTrainablePositionEncoding,
+#                                                               PerceiverFourierPositionEncoding)
+
+
+class PerceiverTFConfig(PretrainedConfig):
+    r"""
+    This is the configuration class to store the configuration of a [`PerceiverTF`]. It is used to instantiate an
+    Perceiver model according to the specified arguments, defining the model architecture. Instantiating a
+    configuration with the defaults will yield a similar configuration to that of the Perceiver
+    [deepmind/language-perceiver](https://huggingface.co/deepmind/language-perceiver) architecture.
+
+    Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
+    documentation from [`PretrainedConfig`] for more information.
+
+    Args:
+        num_latents (`int`, *optional*, defaults to 256):
+            The number of latents.
+        d_latents (`int`, *optional*, defaults to 1280):
+            Dimension of the latent embeddings.
+        d_model (`int`, *optional*, defaults to 768):
+            Dimension of the inputs. Should only be provided in case [*PerceiverTextPreprocessor*] is used or no
+            preprocessor is provided.
+        kv_dim (`int`, *optional*, defaults to 128):
+        num_blocks (`int`, *optional*, defaults to 1):
+            Number of blocks in the Transformer encoder.
+        num_self_attention_heads (`int`, *optional*, defaults to 8):
+            Number of attention heads for each self-attention layer in the Transformer encoder.
+        num_cross_attention_heads (`int`, *optional*, defaults to 8):
+            Number of attention heads for each cross-attention layer in the Transformer encoder.
+        num_local_transformers_per_block (`int`, *optional*, defaults to 2):
+            Number of local Transformer layers per Transformer block in the Transformer encoder.
+        num_temporal_transformers_per_block (`int`, *optional*, defaults to 2):
+            Number of temporal Transformer layers per Transformer block in the Transformer encoder.
+        shared_parallel_temporal_transformers (`bool`, *optional*, defaults to `False`):
+            Whether to share the parameters across the K parallel temporal Transformers in each block.
+        qk_channels (`int`, *optional*):
+            Dimension to project the queries + keys before applying attention in the cross-attention and self-attention
+            layers of the encoder. Will default to preserving the dimension of the queries if not specified.
+        v_channels (`int`, *optional*):
+            Dimension to project the values before applying attention in the cross-attention and self-attention layers
+            of the encoder. Will default to preserving the dimension of the queries if not specified.
+        ** DEPRECATED ** cross_attention_shape_for_attention (`str`, *optional*, defaults to `'kv'`):
+            Dimension to use when downsampling the queries and keys in the cross-attention layer of the encoder.
+        ** DEPRECATED ** self_attention_widening_factor (`int`, *optional*, defaults to 1):
+            Dimension of the feed-forward layer in the cross-attention layer of the Transformer encoder.
+        cross_attention_widening_factor (`int`, *optional*, defaults to 1):
+            Dimension of the feed-forward layer in the self-attention layers of the Transformer encoder.
+        hidden_act (`str` or `function`, *optional*, defaults to `"gelu"`):
+            The non-linear activation function (function or string) in the encoder and pooler. If string, `"gelu"`,
+            `"relu"`, `"selu"` and `"gelu_new"` are supported.
+        dropout_rate (`float`, *optional*, defaults to 0.1):
+            The dropout ratio for the attention probabilities.
+        initializer_range (`float`, *optional*, defaults to 0.02):
+            The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
+        layer_norm_type (`str`, *optional*, defaults to `'layer_norm'`):
+            The type of layer normalization to use. Can be one of {'layer_norm', 'rms_norm'}.
+        layer_norm_eps (`float`, *optional*, defaults to 1e-5):
+            The epsilon used by the layer normalization layers.
+        sca_use_query_residual (`bool`, *optional*, defaults to `True`):
+            Whether to add a query residual in the spectral cross attention (SCA) layer of the encoder.
+        use_query_residual (`float`, *optional*, defaults to `True`):
+            Whether to add a query residual in the cross-attention layer of the encoder.
+        position_encoding_type (`str`, *optional*, defaults to `'trainable'`):
+            Type of position encoding to use. Can be one of {'trainable', 'alibi', 'alibit', 'rope', None}.
+        num_max_positions (`int`, *optional*, defaults to 331):
+            Maximum number of positions to use for the position encoding.
+        vocab_size (`int`, *optional*, defaults to 262):
+            Vocabulary size for the masked language modeling model.
+        attention_to_channel (`bool`, defaults to `False`):
+            Whether SCA should attend to the channel dimension. If False, attention to frequency bin dimension.
+        ff_layer_type (`str`, *optional*, defaults to `'mlp'`):
+            Type of feed-forward layer to use. Can be one of {'mlp', 'moe'}.
+        ff_widening_factor (`int`, *optional*, defaults to 1):
+            Widening factor for the feed-forward layers in the MLP/MoE.
+        moe_num_experts (`int`, *optional*, defaults to 4):
+            Number of experts to use in the mixture of experts (MoE) feed-forward layer. 
+            Only used if `ff_layer_type` is set to `'moe'`.
+        moe_topk (`int`, *optional*, defaults to 2):
+            Number of top experts to use in the mixture of experts (MoE) feed-forward layer.
+            Only used if `ff_layer_type` is set to `'moe'`.
+        rope_type_sca (`str`, *optional*, defaults to `pixel`): Can be one of {'l'|lang', 'p'|'pixel', None}. 
+            RoPE index type for SCA. Only used if `position_encoding_type` is set to `rope`.
+        rope_type_latent (`str`, *optional*, defaults to `pixel`): Can be one of {'l'|'lang', 'p'|'pixel', None}.
+            RoPE index type for Latent Transformer. Only used if `position_encoding_type` is set to `'rope'`.
+        rope_type_temporal (`str`, *optional*, defaults to `lang`): Can be one of {'l'|'lang', 'p'|'pixel', None}.
+            RoPE index type for Temporal Transformer. Only used if `position_encoding_type` is set to `'rope'`.     
+        rope_apply_to_keys (`bool`, *optional*, defaults to `False`): Whether to apply RoPE to the keys in the
+            self/cross-attention layers. Only used if `position_encoding_type` is set to `'rope'`.
+        rope_partial_pe (`bool`, *optional*, defaults to `False`): Whether to use partial RoPE in the self/cross-attention.
+            Only used if `position_encoding_type` is set to `'rope'`.
+        rope_trainable (`bool`, *optional*, defaults to `False`): Whether to make the RoPE trainable. Only used if
+    
+    Example:
+
+    ```python
+    >>> from model.perceiver_mod import PerceiverTFEncodel, PerceiverTFConfig
+
+    >>> # Initializing a Perceiver deepmind/language-perceiver style configuration
+    >>> configuration = PerceiverTFConfig()
+
+    >>> # Initializing a model from the deepmind/language-perceiver style configuration
+    >>> model = PerceiverTFEncoder(configuration)
+
+    >>> # Accessing the model configuration
+    >>> configuration = model.config
+    ```"""
+    model_type = "perceivertf"
+
+    def __init__(
+        self,
+        num_latents=24,
+        d_latents=128,
+        d_model=128,
+        kv_dim=128,
+        num_blocks=3,
+        num_self_attention_heads=8,
+        num_cross_attention_heads=8,
+        num_local_transformers_per_block=2,
+        num_temporal_transformers_per_block=2,
+        qk_channels=128,
+        v_channels=128,
+        cross_attention_shape_for_attention="q",
+        # self_attention_widening_factor=1, ** DEPRECATED **
+        # cross_attention_widening_factor=1, ** DEPRECATED **
+        hidden_act="gelu",
+        dropout_rate=0.1,
+        initializer_range=0.02,
+        layer_norm_type="layer_norm",
+        layer_norm_eps=1e-5,
+        sca_use_query_residual=True,
+        use_query_residual=True,
+        position_encoding_type="trainable",
+        num_max_positions=330,
+        vocab_size=1391,
+        attention_to_channel=False,
+        ff_layer_type="mlp",
+        ff_widening_factor=1,
+        moe_num_experts=4,
+        moe_topk=2,
+        rope_type_sca="pixel",
+        rope_type_latent="pixel",
+        rope_type_temporal="lang",
+        rope_apply_to_keys=False,
+        rope_partial_pe=False,
+        rope_trainable=False,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+
+        self.num_latents = num_latents
+        self.d_latents = d_latents
+        self.d_model = d_model
+        self.kv_dim = kv_dim
+        self.qk_channels = qk_channels
+        self.v_channels = v_channels
+
+        self.num_blocks = num_blocks
+        self.num_self_attention_heads = num_self_attention_heads
+        self.num_cross_attention_heads = num_cross_attention_heads
+        self.num_local_transformers_per_block = num_local_transformers_per_block
+        self.num_temporal_transformers_per_block = num_temporal_transformers_per_block
+        self.sca_use_query_residual = sca_use_query_residual
+        self.use_query_residual = use_query_residual
+        self.position_encoding_type = position_encoding_type
+        self.num_max_positions = num_max_positions
+        # self.self_attention_widening_factor = self_attention_widening_factor
+        # self.cross_attention_widening_factor = cross_attention_widening_factor
+        self.cross_attention_shape_for_attention = cross_attention_shape_for_attention
+        self.attention_to_channel = attention_to_channel
+        self.ff_layer_type = ff_layer_type
+        self.ff_widening_factor = ff_widening_factor
+        self.moe_num_experts = moe_num_experts
+        self.moe_topk = moe_topk
+        self.rope_type_sca = rope_type_sca
+        self.rope_type_latent = rope_type_latent
+        self.rope_type_temporal = rope_type_temporal
+        self.rope_apply_to_keys = rope_apply_to_keys
+        self.rope_partial_pe = rope_partial_pe
+        self.rope_trainable = rope_trainable
+
+        self.hidden_act = hidden_act
+        self.dropout_rate = dropout_rate
+        self.initializer_range = initializer_range
+        self.layer_norm_type = layer_norm_type
+        self.layer_norm_eps = layer_norm_eps
+
+        # masked language modeling attributes
+        self.vocab_size = vocab_size
+
+
+class PerceiverTFPreTrainedModel(PreTrainedModel):
+    """
+    An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
+    models.
+    """
+
+    config_class = PerceiverTFConfig
+    base_model_prefix = "perceivertf"
+    main_input_name = "inputs"
+
+    def _init_weights(self, module):
+        """Initialize the weights"""
+        if isinstance(module, (nn.Linear, nn.Conv2d)):
+            # Slightly different from the TF version which uses truncated_normal for initialization
+            # cf https://github.com/pytorch/pytorch/pull/5617
+            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
+            if module.bias is not None:
+                module.bias.data.zero_()
+        elif hasattr(module, "latents"):
+            module.latents.data.normal_(mean=0.0, std=self.config.initializer_range)
+        elif hasattr(module, "_pos_emb") and isinstance(module._pos_emb, nn.Parameter):
+            # initialize PerceiverTFTrainablePE
+            module._pos_emb.data.normal_(mean=0.0, std=self.config.initializer_range)
+        elif hasattr(module, "_pos_emb_temporal"):
+            # initialize PerceiverTFTrainablePE
+            module._pos_emb_temporal.data.normal_(mean=0.0, std=self.config.initializer_range)
+        elif hasattr(module, "slopes") and isinstance(module.slopes, nn.Parameter):
+            # initialize AlibiPositionalBias
+            module.reset_parameters()
+        elif isinstance(module, nn.ParameterDict):
+            for modality in module.keys():
+                module[modality].data.normal_(mean=0.0, std=self.config.initializer_range)
+        elif isinstance(module, nn.Embedding):
+            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
+            if module.padding_idx is not None:
+                module.weight.data[module.padding_idx].zero_()
+        elif isinstance(module, nn.LayerNorm):
+            module.bias.data.zero_()
+            module.weight.data.fill_(1.0)
+        # elif hasattr(module, "position_embeddings") and isinstance(
+        #         module, PerceiverTrainablePositionEncoding):
+        #     module.position_embeddings.data.normal_(mean=0.0, std=self.config.initializer_range)
+
+
+# Replace the 'ModelOutputWithCrossAttentions' with 'MoEModelOutputWithCrossAttentions' for MoE
+@dataclass
+class MoEModelOutputWithCrossAttentions(ModelOutput):
+    """
+    Base class for model's outputs, with potential hidden states and attentions.
+    Plus, router_probs for Mixture of Experts models.
+
+    Args:
+        last_hidden_state (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`):
+            Sequence of hidden-states at the output of the last layer of the model.
+        hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
+            Tuple of `torch.FloatTensor` (one for the output of the embeddings, if the model has an embedding layer, +
+            one for the output of each layer) of shape `(batch_size, sequence_length, hidden_size)`.
+
+            Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.
+        attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`):
+            Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length,
+            sequence_length)`.
+
+            Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
+            heads.
+        cross_attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` and `config.add_cross_attention=True` is passed or when `config.output_attentions=True`):
+            Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length,
+            sequence_length)`.
+
+            Attentions weights of the decoder's cross-attention layer, after the attention softmax, used to compute the
+            weighted average in the cross-attention heads.
+        router_probs (`tuple(torch.FloatTensor)`, *optional*, returned when `output_router_probs=True` and `config.add_router_probs=True` is passed or when `config.output_router_probs=True`):
+            Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, sequence_length, num_experts)`.
+
+            Raw router probabilities that are computed by MoE routers, these terms are used to compute the auxiliary
+            loss and the z_loss for Mixture of Experts models.
+    """
+
+    last_hidden_state: torch.FloatTensor = None
+    hidden_states: Optional[Tuple[torch.FloatTensor]] = None
+    attentions: Optional[Tuple[torch.FloatTensor]] = None
+    cross_attentions: Optional[Tuple[torch.FloatTensor]] = None
+    router_logits: Optional[Tuple[torch.FloatTensor]] = None

model/perceiver_mod.py

@@ -0,0 +1,912 @@
+# Copyright 2024 The YourMT3 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
+#
+# Please see the details in the LICENSE file.
+"""perceiver_mod.py
+
+    Implementation of the PerceiverTF encoder with:
+    - AliBi positional bias
+    - Mixtral of Experts (MoE) feedforward layer
+
+"""
+import math
+from einops import rearrange
+from typing import Optional, Tuple, Union, List, Dict, Literal
+
+import torch
+from torch import nn
+from transformers.models.perceiver.modeling_perceiver import PerceiverSelfOutput
+from transformers.pytorch_utils import (apply_chunking_to_forward, find_pruneable_heads_and_indices, prune_linear_layer)
+from model.perceiver_helper import MoEModelOutputWithCrossAttentions
+from model.perceiver_helper import PerceiverTFPreTrainedModel, PerceiverTFConfig
+from model.positional_encoding import AlibiPositionalBias, get_rotary_emb
+from model.ops import get_layer_norm
+from model.ff_layer import get_ff_layer
+
+
+class PerceiverEmbeddings(nn.Module):
+    """Construct the latent embeddings sharable with token embeddings in the decoder."""
+
+    def __init__(self, config, shared_emb: Optional[nn.Parameter] = None):
+        super().__init__()
+        if shared_emb is not None:
+            self.latents = shared_emb
+            assert self.latents.shape == (config.num_latents, config.d_latents)
+        else:
+            self.latents = nn.Parameter(torch.randn(config.num_latents, config.d_latents))
+
+    def forward(self, batch_size: int):
+        return self.latents.expand(batch_size, -1, -1)
+
+
+class PerceiverTFTrainablePE(nn.Module):
+    """Construct the trainable absolute positional embeddings."""
+
+    def __init__(self, position_encoding_type: Literal['trainable', 'tkd', 'td', 'tk', 'kdt'], max_t: int, k: int,
+                 d: int) -> None:
+        super().__init__()
+        self.position_encoding_type = position_encoding_type
+        self.max_t = max_t
+        self.k = k
+        self.d = d
+
+        if position_encoding_type in ['trainable', 'tkd']:
+            self._pos_emb = nn.Parameter(torch.randn(max_t, k, d))
+        elif position_encoding_type == 'td':
+            self._pos_emb = nn.Parameter(torch.randn(max_t, d))
+        elif position_encoding_type == 'tk':
+            self._pos_emb = nn.Parameter(torch.randn(max_t, k))
+        elif position_encoding_type == 'kdt':
+            self._pos_emb = nn.Parameter(torch.randn(k, d))
+            self._pos_emb_temporal = nn.Parameter(torch.randn(max_t, d))
+        else:
+            raise ValueError(f'unknown position encoding type {position_encoding_type}')
+
+    def forward(self):
+        pos_emb_temporal = None
+
+        if self.position_encoding_type in ['trainable', 'tkd']:
+            pos_emb = self._pos_emb
+        elif self.position_encoding_type == 'td':
+            pos_emb = self._pos_emb.unsqueeze(1).expand(-1, self.k, -1)
+        elif self.position_encoding_type == 'tk':
+            pos_emb = self._pos_emb.unsqueeze(-1).expand(-1, -1, self.d)
+        elif self.position_encoding_type == 'kdt':
+            pos_emb = self._pos_emb.unsqueeze(0).expand(self.max_t, -1, -1)
+            pos_emb_temporal = self._pos_emb_temporal
+
+        return pos_emb, pos_emb_temporal
+
+
+class PerceiverAlibiSelfAttention(nn.Module):
+    """
+    Multi-headed {cross, self}-attention + Alibi/Rotary positional bias/emb:
+    - Can be used both in the encoder as well as in the decoder.
+    - Modified from PerceiverSelfAttention in modeling_perceiver.py to support Alibi positional bias
+    
+    """
+
+    def __init__(
+        self,
+        config,
+        is_cross_attention=False,
+        qk_channels=None,
+        v_channels=None,
+        num_heads=1,
+        q_dim=None,
+        kv_dim=None,
+        rotary_emb=None,
+    ):
+        super().__init__()
+        self.num_heads = num_heads
+        # Q and K must have the same number of channels.
+        # Default to preserving Q's input's shape.
+        if qk_channels is None:
+            qk_channels = q_dim
+        # V's num_channels determines the shape of the output of QKV-attention.
+        # Default to the same number of channels used in the key-query operation.
+        if v_channels is None:
+            v_channels = qk_channels
+        if qk_channels % num_heads != 0:
+            raise ValueError(f"qk_channels ({qk_channels}) must be divisible by num_heads ({num_heads}).")
+        if v_channels % num_heads != 0:
+            raise ValueError(f"v_channels ({v_channels}) must be divisible by num_heads ({num_heads}).")
+
+        self.qk_channels = qk_channels
+        self.v_channels = v_channels
+        self.qk_channels_per_head = self.qk_channels // num_heads
+        self.v_channels_per_head = self.v_channels // num_heads
+
+        # Layer normalization
+        self.layernorm1 = get_layer_norm(q_dim, config.layer_norm_type, config.layer_norm_eps)
+        if is_cross_attention:
+            self.layernorm2 = get_layer_norm(kv_dim, config.layer_norm_type, config.layer_norm_eps)
+        else:
+            self.layernorm2 = nn.Identity()
+        # self.layernorm1 = nn.LayerNorm(q_dim)
+        # self.layernorm2 = nn.LayerNorm(kv_dim) if is_cross_attention else nn.Identity()
+
+        # Projection matrices
+        self.query = nn.Linear(q_dim, qk_channels)
+        self.key = nn.Linear(kv_dim, qk_channels)
+        self.value = nn.Linear(kv_dim, v_channels)
+
+        self.dropout = nn.Dropout(config.dropout_rate)
+
+        # (Modified) Alibi positional bias
+        if config.position_encoding_type == 'alibi':
+            self.alibi_bias = AlibiPositionalBias(heads=num_heads, total_heads=num_heads, trainable_slope=False)
+        elif config.position_encoding_type == 'alibit':
+            self.alibi_bias = AlibiPositionalBias(heads=num_heads, total_heads=num_heads, trainable_slope=True)
+        else:
+            self.alibi_bias = None
+        # (Modified) RoPE
+        if config.position_encoding_type == 'rope':
+            assert rotary_emb is not None, "rotary_emb must be provided for RoPE."
+            self.rotary_emb = rotary_emb
+        else:
+            self.rotary_emb = None
+        self.rope_apply_to_keys = config.rope_apply_to_keys  # False by default
+
+    def transpose_for_scores(self, x, channels_per_head):
+        new_x_shape = x.size()[:-1] + (self.num_heads, channels_per_head)
+        x = x.view(*new_x_shape)
+        return x.permute(0, 2, 1, 3)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: Optional[torch.FloatTensor] = None,
+        head_mask: Optional[torch.FloatTensor] = None,
+        inputs: Optional[torch.FloatTensor] = None,
+        inputs_mask: Optional[torch.FloatTensor] = None,
+        output_attentions: Optional[bool] = False,
+    ) -> Tuple[torch.Tensor]:
+        hidden_states = self.layernorm1(hidden_states)
+        inputs = self.layernorm2(inputs)
+
+        # Project queries, keys and values to a common feature dimension. If this is instantiated as a cross-attention module,
+        # the keys and values come from the inputs; the attention mask needs to be such that the inputs's non-relevant tokens are not attended to.
+        is_cross_attention = inputs is not None
+        queries = self.query(hidden_states)
+
+        if is_cross_attention:
+            keys = self.key(inputs)
+            values = self.value(inputs)
+            attention_mask = inputs_mask
+        else:
+            keys = self.key(hidden_states)
+            values = self.value(hidden_states)
+
+        # Reshape channels for multi-head attention.
+        # We reshape from (batch_size, time, channels) to (batch_size, num_heads, time, channels per head)
+        queries = self.transpose_for_scores(queries, self.qk_channels_per_head)
+        keys = self.transpose_for_scores(keys, self.qk_channels_per_head)
+        values = self.transpose_for_scores(values, self.v_channels_per_head)
+
+        # (Modified) RoPE
+        if self.rotary_emb is not None:
+            queries = self.rotary_emb.apply_rotary_custom(queries)
+            if self.rope_apply_to_keys is True:
+                keys = self.rotary_emb.apply_rotary_custom(keys)
+
+        # Take the dot product between the queries and keys to get the raw attention scores.
+        attention_scores = torch.matmul(queries, keys.transpose(-1, -2))
+
+        # (Modified) Alibi positional bias
+        if self.alibi_bias is not None:
+            batch_size, num_heads, q_seq_len, k_seq_len = attention_scores.shape
+            attention_scores += self.alibi_bias(q_seq_len,
+                                                k_seq_len)  # auto-broadcasting to (b, num_heads, q_seq_len, k_seq_len)
+
+        _, _, _, q_head_dim = queries.shape
+        _, _, _, v_head_dim = values.shape
+        hiddens = self.num_heads * v_head_dim
+
+        attention_scores = attention_scores / math.sqrt(q_head_dim)
+
+        if attention_mask is not None:
+            # Apply the attention mask (precomputed for all layers in PerceiverModel forward() function)
+            attention_scores = attention_scores + attention_mask
+
+        # Normalize the attention scores to probabilities.
+        attention_probs = nn.Softmax(dim=-1)(attention_scores)
+
+        # This is actually dropping out entire tokens to attend to, which might
+        # seem a bit unusual, but is taken from the original Transformer paper.
+        attention_probs = self.dropout(attention_probs)
+
+        # Mask heads if we want to
+        if head_mask is not None:
+            attention_probs = attention_probs * head_mask
+
+        context_layer = torch.matmul(attention_probs, values)
+
+        context_layer = context_layer.permute(0, 2, 1, 3).contiguous()
+        new_context_layer_shape = context_layer.size()[:-2] + (hiddens,)
+        context_layer = context_layer.view(*new_context_layer_shape)
+
+        outputs = (context_layer, attention_probs) if output_attentions else (context_layer,)
+
+        return outputs
+
+
+class PerceiverAlibiAttention(nn.Module):
+    """
+    Attention module, including a dense block + Alibi
+    : modified from PerceiverAttention in modeling_perceiver.py to support Alibi positional bias
+    """
+
+    def __init__(
+        self,
+        config,
+        is_cross_attention=False,
+        qk_channels=None,
+        v_channels=None,
+        num_heads=1,
+        q_dim=None,
+        kv_dim=None,
+        use_query_residual=True,
+        rotary_emb=None,
+    ):
+        super().__init__()
+        # MultiHead attention
+        if is_cross_attention and qk_channels is None:
+            if config.cross_attention_shape_for_attention == "q":
+                qk_channels = q_dim
+            elif config.cross_attention_shape_for_attention == "kv":
+                qk_channels = kv_dim
+            else:
+                raise ValueError(f"Unknown value {config.cross_attention_shape_for_attention} for "
+                                 "cross_attention_shape_for_attention.")
+        else:
+            if qk_channels is None:
+                qk_channels = q_dim
+            if v_channels is None:
+                v_channels = qk_channels
+        self.self = PerceiverAlibiSelfAttention(config,
+                                                is_cross_attention=is_cross_attention,
+                                                qk_channels=qk_channels,
+                                                v_channels=v_channels,
+                                                num_heads=num_heads,
+                                                q_dim=q_dim,
+                                                kv_dim=kv_dim,
+                                                rotary_emb=rotary_emb)
+        # dense block
+        output_channels = None
+        if is_cross_attention:
+            output_channels = q_dim
+        else:
+            if output_channels is None:
+                output_channels = v_channels
+        self.output = PerceiverSelfOutput(config, input_channels=self.self.v_channels, output_channels=output_channels)
+        self.use_query_residual = use_query_residual
+        self.pruned_heads = set()
+
+    def prune_heads(self, heads):
+        if len(heads) == 0:
+            return
+        heads, index = find_pruneable_heads_and_indices(heads, self.self.num_attention_heads,
+                                                        self.self.attention_head_size, self.pruned_heads)
+
+        # Prune linear layers
+        self.self.query = prune_linear_layer(self.self.query, index)
+        self.self.key = prune_linear_layer(self.self.key, index)
+        self.self.value = prune_linear_layer(self.self.value, index)
+        self.output.dense = prune_linear_layer(self.output.dense, index, dim=1)
+
+        # Update hyper params and store pruned heads
+        self.self.num_attention_heads = self.self.num_attention_heads - len(heads)
+        self.self.all_head_size = self.self.attention_head_size * self.self.num_attention_heads
+        self.pruned_heads = self.pruned_heads.union(heads)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: Optional[torch.FloatTensor] = None,
+        head_mask: Optional[torch.FloatTensor] = None,
+        inputs: Optional[torch.FloatTensor] = None,
+        inputs_mask: Optional[torch.FloatTensor] = None,
+        output_attentions: Optional[bool] = False,
+    ) -> Tuple[torch.Tensor]:
+        self_outputs = self.self(
+            hidden_states,
+            attention_mask,
+            head_mask,
+            inputs,
+            inputs_mask,
+            output_attentions,
+        )
+
+        # Output projection
+        attention_output = self.output(self_outputs[0])
+
+        # Optionally include a residual to the original queries.
+        # Consider omitting the residual if the semantics of query and output
+        # are different, e.g. if queries are positions and outputs are pixels.
+        if self.use_query_residual:
+            attention_output = attention_output + hidden_states
+
+        outputs = (attention_output,) + self_outputs[1:]  # add attentions if we output them
+        return outputs
+
+
+class PerceiverAlibiLayer(nn.Module):
+    """Construct a single PerceiverTF layer with:
+        - Alibi positional bias
+        - RoPE
+        - Mixtral of Experts (MoE) feedforward layer
+
+    """
+
+    def __init__(
+        self,
+        config,
+        is_cross_attention=False,
+        qk_channels=None,
+        v_channels=None,
+        num_heads=1,
+        q_dim=None,
+        kv_dim=None,
+        widening_factor=1,
+        use_query_residual=True,
+        rotary_emb=None,
+    ):
+        super().__init__()
+        self.chunk_size_feed_forward = config.chunk_size_feed_forward
+        self.seq_len_dim = 1
+        self.attention = PerceiverAlibiAttention(config,
+                                                 is_cross_attention=is_cross_attention,
+                                                 qk_channels=qk_channels,
+                                                 v_channels=v_channels,
+                                                 num_heads=num_heads,
+                                                 q_dim=q_dim,
+                                                 kv_dim=kv_dim,
+                                                 use_query_residual=use_query_residual,
+                                                 rotary_emb=rotary_emb)
+        self.layernorm = get_layer_norm(q_dim, config.layer_norm_type, config.layer_norm_eps)
+        # self.layernorm = nn.LayerNorm(q_dim)
+        self.mlp = get_ff_layer(config, input_size=q_dim, widening_factor=widening_factor)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: Optional[torch.FloatTensor] = None,
+        head_mask: Optional[torch.FloatTensor] = None,
+        inputs: Optional[torch.FloatTensor] = None,
+        inputs_mask: Optional[torch.FloatTensor] = None,
+        output_attentions: Optional[bool] = False,
+    ) -> Tuple[torch.Tensor]:
+        attention_outputs = self.attention(
+            hidden_states,
+            attention_mask,
+            head_mask,
+            inputs,
+            inputs_mask,
+            output_attentions,
+        )
+        attention_output = attention_outputs[0]
+
+        outputs = attention_outputs[1:]  # add attentions if we output attention weights
+        """apply_chunking_to_forward: 
+        This function chunks the input_tensors into smaller input tensor parts of size
+        chunk_size over the dimension chunk_dim. It then applies a layer forward_fn to 
+        each chunk independently to save memory.If the forward_fn is independent across
+        the chunk_dim this function will yield the same result as not applying it.
+        """
+        layer_output, router_logits = apply_chunking_to_forward(self.feed_forward_chunk, self.chunk_size_feed_forward,
+                                                                self.seq_len_dim, attention_output)
+
+        layer_output = layer_output + attention_output  # residual connection
+        outputs = (layer_output,) + outputs + (router_logits,)  # add router_logits to outputs
+        return outputs
+
+    def feed_forward_chunk(self, attention_output):
+        layer_output = self.layernorm(attention_output)
+        layer_output, router_logits = self.mlp(layer_output)  # router_logits is returned only when using MoE.
+        return layer_output, router_logits
+
+
+class PerceiverTFEncoderBlock(nn.Module):
+    """Construct a single block of PerceiverTF encoder:
+        - Spectral Cross Attention (SCA)
+        - Local latent transformer layers
+        - Temporal transformer layers
+        - added Alibi positional bias, RoPE, gMLP and MoE feedforward layer
+    """
+
+    def __init__(self,
+                 config: PerceiverTFConfig,
+                 kv_dim: Optional[int] = None,
+                 sca_use_query_residual: bool = True,
+                 rotary_emb_sca: Optional[nn.Module] = None,
+                 rotary_emb_latent: Optional[nn.Module] = None,
+                 rotary_emb_temporal: Optional[nn.Module] = None):
+        super().__init__()
+        self.config = config
+
+        # Check that we can use multihead-attention with these shapes.
+        if config.d_latents % config.num_self_attention_heads != 0:
+            raise ValueError(f"num_z_channels ({config.d_latents}) must be divisible by"
+                             f" num_self_attend_heads ({config.num_self_attention_heads}).")
+        if config.d_latents % config.num_cross_attention_heads != 0:
+            raise ValueError(f"num_z_channels ({config.d_latents}) must be divisible by"
+                             f" num_cross_attend_heads ({config.num_cross_attention_heads}).")
+
+        if kv_dim is None:
+            kv_dim = config.kv_dim
+        if sca_use_query_residual is None:
+            sca_use_query_residual = config.sca_use_query_residual
+
+        # Spectral Cross Attention (SCA) layer.
+        self.sca_attention_to_channel = config.attention_to_channel
+        self.spectral_cross_attention = PerceiverAlibiAttention(config,
+                                                                is_cross_attention=True,
+                                                                qk_channels=config.qk_channels,
+                                                                v_channels=config.v_channels,
+                                                                num_heads=config.num_cross_attention_heads,
+                                                                q_dim=config.d_latents,
+                                                                kv_dim=kv_dim,
+                                                                use_query_residual=sca_use_query_residual,
+                                                                rotary_emb=rotary_emb_sca)  # (Modified) RoPE
+
+        # Local latent trasformer layers.
+        local_transformer_layers = []
+        for _ in range(config.num_local_transformers_per_block):
+            layer = PerceiverAlibiLayer(
+                config,
+                is_cross_attention=False,
+                qk_channels=config.qk_channels,  # projection dim for q and k. 
+                v_channels=config.v_channels,  # projection dim for v.
+                num_heads=config.num_self_attention_heads,
+                q_dim=config.d_model,
+                kv_dim=config.d_model,
+                widening_factor=config.ff_widening_factor,
+                use_query_residual=config.use_query_residual,
+                rotary_emb=rotary_emb_latent  # (Modified) RoPE
+            )
+            local_transformer_layers.append(layer)
+        self.local_transformer = nn.ModuleList(local_transformer_layers)
+
+        # Temporal transformer layers.
+        temporal_transformer_layers = []
+        for _ in range(config.num_temporal_transformers_per_block):
+            layer = PerceiverAlibiLayer(
+                config,
+                is_cross_attention=False,
+                qk_channels=config.qk_channels,  # projection dim for q and k. 
+                v_channels=config.v_channels,  # projection dim for v.
+                num_heads=config.num_self_attention_heads,
+                q_dim=config.d_model,
+                kv_dim=config.d_model,
+                widening_factor=config.ff_widening_factor,
+                use_query_residual=config.use_query_residual,
+                rotary_emb=rotary_emb_temporal  # (Modified) RoPE
+            )
+            temporal_transformer_layers.append(layer)
+        self.temporal_transformer = nn.ModuleList(temporal_transformer_layers)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        inputs: Optional[torch.FloatTensor] = None,
+        inputs_mask: Optional[torch.FloatTensor] = None,
+        local_attention_mask: Optional[torch.FloatTensor] = None,
+        temporal_attention_mask: Optional[torch.FloatTensor] = None,
+        local_head_mask: Optional[torch.FloatTensor] = None,
+        temporal_head_mask: Optional[torch.FloatTensor] = None,
+        pos_emb_temporal: Optional[torch.FloatTensor] = None,
+        output_attentions: Optional[bool] = False,
+        output_hidden_states: Optional[bool] = False,
+        output_router_logits: Optional[bool] = False,  # Only used for MoE.
+        return_dict: Optional[bool] = True,
+    ) -> Union[Tuple, MoEModelOutputWithCrossAttentions]:
+        """
+        Inputs:
+            hidden_states: (B, T, K, D)
+            inputs: (B, T, F, C)
+        Returns:
+            hidden_states: (B, T, K, D)
+
+        Args:
+            hidden_states:
+                latent_array (B, T, num_latents, d_latents) for SCA. The latent array 
+                with shape (B, K, D) is expanded by t, and positional embeddings are 
+                added to it.
+            inputs: torch.FloatTensor
+                The input sequence of shape (B, T, F, C).
+            inputs_mask: torch.FloatTensor
+                Only used for SCA. By default, None.
+            local_attention_mask:
+                Used for local self-attention. By default, None.
+            temporal_attention_mask:
+                Used for temporal self-attention. By default, None.
+            local_head_mask:
+                By default, None.
+            temporal_head_mask:
+                By default, None.
+            pos_emb_temporal:
+                Optioanl. Used for temporal self-attention. By default, None. (max_t, num_latents, d_latents)
+            output_attentions: bool
+                Whether to return attentions weights.
+            output_hidden_states: bool
+                Whether to return all hidden states. If False, only last hidden 
+                state is returned.
+            output_router_logits: bool
+                Whether to return router logits for MoE. If False, only last hidden 
+                state is returned.
+            return_dict: bool
+                Whether to return a MoEModelOutputWithCrossAttentions instead of a tuple.
+        """
+
+        all_hidden_states = () if output_hidden_states else None
+        all_self_attentions = () if output_attentions else None
+        all_cross_attentions = () if output_attentions else None
+        all_router_logits = () if output_router_logits else None
+
+        # Collect dimension info
+        batch_size, t, num_latents, d_latents = hidden_states.size()  # (B, T, K, D)
+
+        # if self.sca_attention_to_channel:
+        #     _, _, _, f = inputs.size()  # (B, T, C, F)
+        #     assert d_latents == f, "d_latents must be equal to kv_dim, which is input frequency dim."
+        # else:
+        #     _, _, _, c = inputs.size()  # (B, T, F, C)
+        #     assert d_latents == c, "d_latents must be equal to kv_dim, which is input channels."
+
+        # Reshape (B, T, _, _) to (B*T, _, _) for SCA and local transformer.
+        hidden_states = rearrange(hidden_states, "b t k d -> (b t) k d")
+        inputs = rearrange(inputs, "b t f c -> (b t) f c")
+
+        # Apply the SCA between the latents (hidden_states) and inputs:
+        layer_outputs = self.spectral_cross_attention(
+            hidden_states,
+            attention_mask=None,  # Input_mask is used instead for cross-attention
+            inputs=inputs,
+            inputs_mask=inputs_mask,
+            output_attentions=output_attentions,
+        )
+        hidden_states = layer_outputs[0]  # (B*T, K, D)
+
+        if output_attentions:
+            all_cross_attentions = all_cross_attentions + (layer_outputs[1],)
+
+        # Apply the block of local latent transformer layers.
+        for i, layer_module in enumerate(self.local_transformer):
+            if output_hidden_states:
+                all_hidden_states = all_hidden_states + (hidden_states,)
+
+            layer_head_mask = local_head_mask[i] if local_head_mask is not None else None
+            layer_outputs = layer_module(
+                hidden_states,
+                attention_mask=local_attention_mask,
+                head_mask=layer_head_mask,
+                output_attentions=output_attentions,
+            )
+            hidden_states = layer_outputs[0]  # (B*T, K, D)
+            if output_attentions:
+                all_self_attentions = all_self_attentions + (layer_outputs[1],)
+            if output_router_logits:
+                all_router_logits = all_router_logits + (layer_outputs[2],)
+
+        if output_hidden_states:
+            all_hidden_states = all_hidden_states + (hidden_states,)
+
+        # Reshape (B*T, K, D) to (B*K, T, D) for the temporal transformer.
+        hidden_states = rearrange(hidden_states, "(b t) k d -> (b k) t d", b=batch_size)
+
+        # Apply the block of temporal transformer layers.
+        for i, layer_module in enumerate(self.temporal_transformer):
+            if output_hidden_states:
+                all_hidden_states = all_hidden_states + (hidden_states,)
+
+            layer_head_mask = temporal_head_mask[i] if temporal_head_mask is not None else None
+
+            if i == 0 and pos_emb_temporal is not None:
+                # Add temporal positional embeddings to the hidden_states.
+                hidden_states = hidden_states + pos_emb_temporal[:t]  # pos_emb_temporal: (T, D)
+
+            layer_outputs = layer_module(
+                hidden_states,
+                attention_mask=temporal_attention_mask,
+                head_mask=layer_head_mask,
+                output_attentions=output_attentions,
+            )
+            hidden_states = layer_outputs[0]
+            if output_attentions:
+                all_self_attentions = all_self_attentions + (layer_outputs[1],)
+            if output_router_logits:
+                all_router_logits = all_router_logits + (layer_outputs[2],)
+
+        if output_hidden_states:
+            all_hidden_states = all_hidden_states + (hidden_states,)
+
+        last_hideen_state = hidden_states
+        # Reshape (B*K, T, D) to (B, T, K, D) for the next block.
+        last_hideen_state = rearrange(last_hideen_state, "(b k) t d -> b t k d", b=batch_size)
+
+        # Prepare the outputs.
+        if not return_dict:
+            return tuple(
+                v for v in
+                [last_hideen_state, all_hidden_states, all_self_attentions, all_cross_attentions, all_router_logits]
+                if v is not None)
+        return MoEModelOutputWithCrossAttentions(
+            last_hidden_state=last_hideen_state,
+            hidden_states=all_hidden_states,
+            attentions=all_self_attentions,
+            cross_attentions=all_cross_attentions,
+            router_logits=all_router_logits,
+        )
+
+
+class PerceiverTFEncoder(PerceiverTFPreTrainedModel):
+    """PerceiverTFEncoder is an encoder model based on the Perceiver and Spectral Cross Attention (SCA).
+    
+    position_encoding_type: str
+        The type of positional encoding to use. One of the following:
+        - 'trainable': trainable positional embeddings
+        - 'alibi': AlibiNet positional embeddings
+        - 'alibit': AlibiNet positional embeddings with trainable slopes for each head
+        - 'rope': RoPE (Rotary Positional Encoding)
+        (experimental w/ 'trainable')
+        - 'tkd': trainable PE (T,K,D) on latent (default for 'trainable')
+        - 'td': trainable PE (T,D) on latent
+        - 'tk': trainable PE (T,K) on latent
+        - 'kdt': trainable PE (K,D) on latent, and (T,) on temporal transformer 
+    
+    """
+
+    def __init__(self,
+                 config: PerceiverTFConfig,
+                 sca_use_query_residual: Optional[bool] = None,
+                 shared_emb: Optional[nn.Embedding] = None):
+        super().__init__(config)
+        self.config = config
+
+        if sca_use_query_residual is None:
+            self.sca_use_query_residual = config.sca_use_query_residual  # True by default
+        self.position_encoding_type = config.position_encoding_type
+        self.sca_attention_to_channel = config.attention_to_channel
+
+        # Construct a latent array.
+        self.latent_array = PerceiverEmbeddings(config)  # (num_latents, d_latents)
+
+        # Positional embeddings for the latent array.
+        if self.position_encoding_type == 'rope':
+            # (Modified) RoPE
+            self.rotary_emb_sca = get_rotary_emb(config.num_cross_attention_heads, config.rope_type_sca,
+                                                 config.rope_partial_pe, config.rope_trainable)
+            self.rotary_emb_latent = get_rotary_emb(config.num_cross_attention_heads, config.rope_type_latent,
+                                                    config.rope_partial_pe, config.rope_trainable)
+            self.rotary_emb_temporal = get_rotary_emb(config.num_cross_attention_heads, config.rope_type_temporal,
+                                                      config.rope_partial_pe, config.rope_trainable)
+        else:
+            self.rotary_emb_sca = None
+            self.rotary_emb_latent = None
+            self.rotary_emb_temporal = None
+
+        if self.position_encoding_type in ['alibi', 'alibit', 'rope', None]:
+            # alibi is imeplemented within PerceiverAlibiSelfAttention, and activated by config.
+            # RoPE is implemented without using self.pos_emb.
+            self.pos_emb = None
+        else:
+            k, d = self.latent_array.latents.size()
+            max_t = int(config.num_max_positions) + 10  # 10 is headroom for future task tokens...
+            self.pos_emb = PerceiverTFTrainablePE(self.position_encoding_type, max_t, k, d)
+            """
+            self.pos_emb() returns:
+                pos_emb: (max_t, K, D)
+                pos_emb_temporal: (max_t, K, D)
+            """
+
+        # Construct the encoder blocks.
+        blocks = []
+        for _ in range(config.num_blocks):
+            block = PerceiverTFEncoderBlock(
+                config,
+                kv_dim=config.kv_dim,
+                sca_use_query_residual=sca_use_query_residual,
+                rotary_emb_sca=self.rotary_emb_sca,  # (Modified) RoPE
+                rotary_emb_latent=self.rotary_emb_latent,
+                rotary_emb_temporal=self.rotary_emb_temporal)
+            blocks.append(block)
+        self.blocks = nn.ModuleList(blocks)
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def get_input_embeddings(self):
+        return self.latent_array.latents
+
+    def set_input_embeddings(self, value):
+        self.latent_array.latents = value
+
+    """temporary fix for torch.compile issue"""
+
+    def forward(self, **kwargs):
+        if self.training is True:
+            return self._forward_compile(**kwargs)
+        else:
+            return self._forward_no_compile(**kwargs)
+
+    def _forward_no_compile(self, **kwargs):
+        return self._forward(**kwargs)
+
+    @torch.compile
+    def _forward_compile(self, **kwargs):
+        return self._forward(**kwargs)
+
+    def _forward(
+        self,
+        inputs: Optional[torch.FloatTensor] = None,  # (B, T, F, kv_dim)
+        inputs_embeds: Optional[torch.FloatTensor] = None,  # (B, T, F, kv_dim) 
+        inputs_mask: Optional[torch.FloatTensor] = None,  # (B, F) Mask freq. of inputs in SCA.
+        local_attention_mask: Optional[torch.FloatTensor] = None,  # (B, K)
+        temporal_attention_mask: Optional[torch.FloatTensor] = None,  # (B, T)
+        local_head_mask: Optional[torch.FloatTensor] = None,
+        temporal_head_mask: Optional[torch.FloatTensor] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        output_router_logits: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple, MoEModelOutputWithCrossAttentions]:
+        # Inputs and inputs_embeds are tied, and actually the same. (following T5 convention)
+        # Inputs are from convoulutional features from audio.
+        # Don't be confused with latent embeddings, which is `self.latent_array.latents`, and
+        # used as hidden_state of block.
+        if inputs is None and inputs_embeds is not None:
+            inputs = inputs_embeds
+        elif inputs is None and inputs_embeds is None:
+            raise ValueError("You must provide 'inputs' or 'inputs_embeds' argument.")
+
+        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
+
+        batch_size, t, _f, _c = inputs.size()
+        device = inputs.device
+
+        # SCA attention to channels of inputs, instead of frequency bins.
+        if self.sca_attention_to_channel is True:
+            inputs = rearrange(inputs, "b t f c -> b t c f")
+
+        # Prepare head mask if needed
+        # 1.0 in head_mask indicate we keep the head
+        # attention_probs has shape bsz x n_heads x N x N
+        # input head_mask has shape [num_heads] or [num_blocks x num_heads]
+        # and head_mask is converted to shape [num_blocks x batch x num_heads x N x N]
+        local_head_mask = self.get_head_mask(local_head_mask,
+                                             self.config.num_blocks * self.config.num_local_transformers_per_block)
+        temporal_head_mask = self.get_head_mask(
+            temporal_head_mask, self.config.num_blocks * self.config.num_temporal_transformers_per_block)
+
+        # Prepare attention mask: not implemented
+
+        # Expand the latent embeddings by t: (B, K, D) --> (B, T, K, D)
+        latent_embeddings = self.latent_array(batch_size=batch_size)  # (B, num_latents, d_latents)
+        expanded_latent_embeddings = latent_embeddings.unsqueeze(1).expand(-1, t, -1, -1)
+
+        # Add positional embeddings to the expanded latent embeddings: (B, T, K, D)
+        if self.pos_emb is not None:
+            pos_emb_latent, pos_emb_temporal = self.pos_emb.forward()
+            expanded_latent_embeddings = expanded_latent_embeddings + pos_emb_latent[:t]
+            # (max_t, K, D) -> (T, K, D) -> (B, T, K, D) auto-broadcasting
+        else:
+            pos_emb_temporal = None
+
+        # Lists to store intermediate outputs if required
+        all_hidden_states = []
+        all_attentions = []
+        all_cross_attentions = []
+        all_router_logits = []
+
+        hidden_states = expanded_latent_embeddings
+
+        # Forward-pass
+        for i, block in enumerate(self.blocks):
+            block_output = block(hidden_states=hidden_states,
+                                 inputs=inputs,
+                                 inputs_mask=inputs_mask,
+                                 local_attention_mask=local_attention_mask,
+                                 temporal_attention_mask=temporal_attention_mask,
+                                 local_head_mask=local_head_mask,
+                                 temporal_head_mask=temporal_head_mask,
+                                 pos_emb_temporal=pos_emb_temporal if i == 0 else None,
+                                 output_attentions=output_attentions,
+                                 output_hidden_states=output_hidden_states,
+                                 output_router_logits=output_router_logits,
+                                 return_dict=True)
+
+            # Update the hidden_states for the next block
+            hidden_states = block_output.last_hidden_state
+
+            # Append to lists if required
+            if output_hidden_states:
+                all_hidden_states.append(hidden_states)
+            if output_attentions:
+                all_attentions.append(block_output.attentions)
+                all_cross_attentions.append(block_output.cross_attentions)
+            if output_router_logits:
+                all_router_logits.append(block_output.router_logits)
+        last_hidden_states = hidden_states
+
+        # Prepare outputs
+        if not return_dict:
+            # Convert lists to tuples
+            return (last_hidden_states, tuple(all_hidden_states) if all_hidden_states else None,
+                    tuple(all_attentions) if all_attentions else None,
+                    tuple(all_cross_attentions) if all_cross_attentions else None,
+                    tuple(all_router_logits) if all_router_logits else None)
+
+        return MoEModelOutputWithCrossAttentions(
+            last_hidden_state=last_hidden_states,
+            hidden_states=tuple(all_hidden_states) if all_hidden_states else None,
+            attentions=tuple(all_attentions) if all_attentions else None,
+            cross_attentions=tuple(all_cross_attentions) if all_cross_attentions else None,
+            router_logits=tuple(all_router_logits) if all_router_logits else None)
+
+
+def test():
+    # In HuggingFace's Perceiver implementation:
+    # `q_dim` is the latent array dimension d_latents of ((B), num_latents, d_latents).
+    # `kv_dim`os the actual input dimension D of (B, T, D)
+    # `qk_channels`, `v_channels`: are projection dimensions for attention, (B, T, C)
+    #                              (B, T, D) --> projection --> (B, T, C)
+    # However, PerceiverTF does not require projection:
+    # It takes as input a latent tensor (B, num_latents, d_latents) and a conv_feat tensor (T, B, F, C)
+    # The `spectral-cross-attention` and `local-self-attention-transformer` takes as input (B*T, F, C),
+    # and C=D=d_latents.
+    from model.ops import count_parameters
+
+    # Test input
+    b = 2  # batch
+    t = 10  # time steps (330 for 6s in paper)
+    f = 128  # freq of conv_feat
+    c = 128  # channels of conv_feat
+    k = 24  # num_latents
+    d = 128  # d_latents
+    conv_feat = torch.randn(b, t, f, c)
+
+    # construct PerceiverTFEncoder
+    config = PerceiverTFConfig()
+    pe_types = ['alibi', 'alibit', 'trainable', 'tkd', 'td', 'tk', 'kdt', None]
+    config.ff_layer_type = 'moe'
+    config.moe_num_experts = 4
+    config.moe_topk = 2
+
+    for pe_type in pe_types:
+        config.position_encoding_type = pe_type  # 'alibi', 'alibit', 'trainable', 'tkd', 'td', 'tk', 'kdt', None
+        config.num_latents = k
+        config.d_latents = d
+        config.kv_dim = c
+        config.qk_channels = d
+        config.v_channels = d
+        encoder = PerceiverTFEncoder(config)
+        encoder.eval()
+        assert encoder.latent_array.latents.size() == (k, d)
+        # forward
+        enc_hidden_state = encoder.forward(inputs_embeds=conv_feat).last_hidden_state
+        # print(enc_hidden_state.shape)  # [2, 10, 24, 128] = [B, T, K, D]
+        n_param = count_parameters(encoder)[1] // 1000
+        print(config.position_encoding_type, f'num_param: {n_param}K')
+    """
+    PE type | num. param.
+    None | 1397K
+    alibi | 1397K
+    alibit (train slope) | 1397K
+    tkd | 2442K
+    td | 1441K
+    tk | 1405K
+    kdt | 1444K 
+
+    MLP | 2637K
+    MoE (4 experts) | 4411K
+    MoE (6 experts) | 5594K
+    """

model/projection_layer.py

@@ -0,0 +1,331 @@
+# Copyright 2024 The YourMT3 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
+#
+# Please see the details in the LICENSE file.
+""" projection_layer.py """
+from typing import Tuple
+
+import math
+import torch
+from torch import nn
+import torch.nn.functional as F
+from torch.nn import Linear, LayerNorm
+
+from einops import rearrange
+from model.ops import count_parameters
+
+
+class GroupLinearFlatten(nn.Module):
+    """
+    Implements a grouped linear layer with a flattened output.
+
+    This module applies individual linear transformations for each group in the input tensor 
+    and then flattens the group dimension to produce the final output. It's useful when you 
+    have distinct groups in the input tensor and you want separate linear transformations for 
+    each of these groups.
+
+    Args:
+    - in_features (int): The number of input features per group.
+    - flatten_out_features (int): The total number of flattened output features. This value must 
+                                  be divisible by num_groups. The actual number of output features 
+                                  per group is computed as flatten_out_features/num_groups.
+    - num_groups (int): The number of distinct groups in the input tensor.
+    - use_bmm (bool, optional): Whether to use batch matrix multiplication for computation. 
+                                Default is True.
+    
+    Shape:
+    - Input: (batch_size, sequence_length, num_groups, in_features)
+    - Output: (batch_size, sequence_length, flatten_out_features)
+    
+    Examples:
+    >>> m = GroupLinearFlatten(128, 512, 24) #  
+    >>> input = torch.randn(16, 10, 24, 128) # (B, T, C, F)
+    >>> output = m(input)
+    >>> output.size()
+    torch.Size([16, 10, 512]) # (B, T, D)
+    """
+
+    def __init__(self, in_features, flatten_out_features, num_groups, use_bmm=True):
+        super().__init__()
+        self.in_features = in_features
+        self.flatten_out_features = flatten_out_features
+        self.num_groups = num_groups
+        self.use_bmm = use_bmm
+
+        # Assuming flatten_out_features is divisible by num_groups
+        self.out_features_per_group = self.flatten_out_features // self.num_groups
+
+        # Each group gets its own weights
+        self.weight = nn.Parameter(torch.Tensor(num_groups, self.out_features_per_group, in_features))
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        nn.init.kaiming_uniform_(self.weight, a=math.sqrt(5))
+
+    def forward(self, input):
+        # input shape: (batch, seq_length, groups, in_features)
+        # weight shape: (groups, out_features_per_group, in_features)
+
+        batch_size, t, k, source_d = input.size()
+
+        if self.use_bmm:
+            # Reshape input for bmm operation
+            input_reshaped = rearrange(input, 'b t k d -> k d (b t)')
+
+            # Matrix multiplication: dot((k, out_features_per_group, d), (k, d, b*t)) -> (k, out_features_per_group, b*t)
+            output_bmm = torch.bmm(self.weight, input_reshaped)
+
+            # Reshape back to original shape and flatten the group dimension
+            output = rearrange(output_bmm, 'k d_out (b t) -> b t (k d_out)', b=batch_size, t=t, k=k)
+        else:
+            output = torch.einsum('bsgi,goi->bsgo', input, self.weight)
+            output = rearrange(output, 'b t k d_out -> b t (k d_out)')
+
+        return output
+
+
+# class MultiChannelGroupLinear(nn.Module):
+#     """ Not Implemented Yet """
+#     def __init__(self, in_ch=26, in_dim=128, out_ch=13, out_dim=512):
+#         super().__init__()
+
+#         self.in_ch = in_ch
+#         self.in_dim = in_dim
+#         self.out_ch = out_ch
+#         self.out_dim = out_dim
+#         self.in_ch_per_group = in_ch // out_ch
+
+#         self.layer = GroupLinearFlatten(in_features=)
+
+
+class MultiChannelLinearProjection(nn.Module):
+
+    def __init__(self, in_ch=26, in_dim=128, out_ch=13, out_dim=512):
+        super().__init__()
+        self.in_ch = in_ch
+        self.in_dim = in_dim
+        self.out_ch = out_ch
+        self.out_dim = out_dim
+
+        self.in_ch_per_group = in_ch // out_ch
+        self.linear_in_ch = in_ch // self.in_ch_per_group
+        self.linear_in_dim = in_dim * self.in_ch_per_group
+
+        # Reshaped Input shape: (b, t, in_dim//in_ch_per_group, in_dim*in_ch_per_group)
+        # Output shape: (b, t, out_ch, out_dim)
+        if in_dim * self.in_ch_per_group == out_dim:
+            self.linear = nn.Identity()
+        else:
+            self.linear = nn.Linear(in_features=self.linear_in_dim, out_features=out_dim, bias=False)
+
+    def forward(self, x):
+        """
+        Args:
+            x: (B, T, C, D)
+        
+        Returns:
+            x: (B, C_target, T, D_target)
+        """
+        x = rearrange(x, 'b t (c1 c2) d -> b c1 t (c2 d)', c1=self.linear_in_ch, c2=self.in_ch_per_group)
+        return self.linear(x)
+
+
+def get_multi_channel_projection_layer(input_shape: Tuple[int], output_shape: Tuple[int], proj_type: str) -> nn.Module:
+    """ This function returns one of the projection layers for multi-channel models."""
+    in_ch = input_shape[-2]
+    in_dim = input_shape[-1]
+    out_ch = output_shape[-2]
+    out_dim = output_shape[-1]
+
+    if proj_type == 'mc_shared_linear':
+        return MultiChannelLinearProjection(in_ch, in_dim, out_ch, out_dim)
+
+
+def test_multi_channel_linear_projection():
+    x = torch.randn(2, 10, 26, 128)  # (b, t, c, d)
+    mclp = MultiChannelLinearProjection(in_ch=26, in_dim=128, out_ch=13, out_dim=256)  # actually nn.Identity()
+    assert type(nn.Identity()) == type(mclp.linear)
+    assert mclp(x).shape == (2, 13, 10, 256)  # (b, _c, t, _d)
+
+    x = torch.randn(2, 10, 26, 128)  # (b, t, c, d)
+    mclp = MultiChannelLinearProjection(in_ch=26, in_dim=128, out_ch=13, out_dim=512)  # actually nn.Identity()
+    assert torch.nn.modules.linear.Linear == type(mclp.linear)
+    assert mclp(x).shape == (2, 13, 10, 512)  # (b, _c, t, _d)
+
+
+class FlattenMLP(nn.Module):
+
+    def __init__(self, in_features, flatten_out_features, num_groups, hidden_dim=None, activation=None):
+        super().__init__()
+
+        self.in_features = in_features
+        self.num_groups = num_groups
+
+        # Calculate flattened input dimension
+        self.flat_in_dim = in_features * num_groups
+        if hidden_dim is None:
+            hidden_dim = self.flat_in_dim // 2
+        self.hidden_dim = hidden_dim
+
+        # Check if flatten_out_features is divisible by in_features
+        assert flatten_out_features % in_features == 0, "flatten_out_features should be divisible by in_features."
+
+        # Define layers
+        self.layers = nn.Sequential(nn.Flatten(2, 3), nn.Linear(self.flat_in_dim, hidden_dim), nn.LayerNorm(hidden_dim),
+                                    activation() if activation else nn.Identity(), nn.Linear(hidden_dim, hidden_dim),
+                                    nn.LayerNorm(hidden_dim),
+                                    activation() if activation else nn.Identity(),
+                                    nn.Linear(hidden_dim, flatten_out_features))
+
+    def forward(self, x):
+        # x shape: (batch, seq, num_groups, in_features)
+        return self.layers(x)
+
+
+class LinearProjection(nn.Module):
+
+    def __init__(self, in_features, flatten_out_features, num_groups):
+        super().__init__()
+
+        # Calculate flattened input dimension
+        self.flat_in_dim = in_features * num_groups
+        self.projection_layer = nn.Linear(in_features=self.flat_in_dim, out_features=flatten_out_features, bias=False)
+
+    def forward(self, x):
+        # x shape: (batch, seq, num_groups, in_features)
+        batch_size, t, _, _ = x.size()
+        x_flattened = x.reshape(batch_size, t, -1)  # Flattening num_groups and in_features
+        return self.projection_layer(x_flattened)
+
+
+class DepthwiseConvProjection(nn.Module):
+
+    def __init__(self, in_features, flatten_out_features, num_groups, depth):
+        super().__init__()
+        d_out = flatten_out_features // in_features
+
+        self.conv = nn.Conv2d(in_channels=num_groups,
+                              out_channels=num_groups * d_out,
+                              kernel_size=(1, depth),
+                              groups=num_groups)
+
+        self.fc = nn.Linear(num_groups * d_out * (in_features - depth + 1), flatten_out_features)
+
+    def forward(self, x):
+        # Swap the dimensions of k and t to match expected input for depthwise convolution
+        x = x.permute(0, 2, 1, 3)  # shape: (b, k, t, d)
+
+        # Convolutional layer
+        x = self.conv(x)  # shape: (b, k*d_out, t, d-depth+1)
+
+        # Reshape the tensor for the Linear layer
+        batch_size, _, t, _ = x.size()
+        x = x.reshape(batch_size, t, -1)
+        return self.fc(x)
+
+
+def get_projection_layer(input_shape: Tuple[int], output_shape: Tuple[int], proj_type: str) -> nn.Module:
+    """ This function returns one of the projection layers defined below. """
+    if len(input_shape) == 2:
+        _, d_source = input_shape
+    elif len(input_shape) == 3:
+        _, k_source, d_source = input_shape
+    if len(output_shape) == 2:
+        _, d_target = output_shape
+    elif len(output_shape) == 3:
+        _, k_target, d_target = output_shape
+
+    if 'linear' == proj_type:
+        return LinearProjection(in_features=d_source, flatten_out_features=d_target, num_groups=k_source)
+    elif 'mlp' in proj_type:
+        if 'gelu' in proj_type:
+            return FlattenMLP(in_features=d_source,
+                              flatten_out_features=d_target,
+                              num_groups=k_source,
+                              activation=nn.GELU)
+        elif 'relu' in proj_type:
+            return FlattenMLP(in_features=d_source,
+                              flatten_out_features=d_target,
+                              num_groups=k_source,
+                              activation=nn.ReLU)
+        else:
+            return FlattenMLP(in_features=d_source, flatten_out_features=d_target, num_groups=k_source, activation=None)
+    elif 'conv' in proj_type:
+        if 'conv4' == proj_type:
+            return DepthwiseConvProjection(in_features=d_source,
+                                           flatten_out_features=d_target,
+                                           num_groups=k_source,
+                                           depth=4)
+        elif 'conv16' == proj_type:
+            return DepthwiseConvProjection(in_features=d_source,
+                                           flatten_out_features=d_target,
+                                           num_groups=k_source,
+                                           depth=16)
+        elif 'conv32' == proj_type:
+            return DepthwiseConvProjection(in_features=d_source,
+                                           flatten_out_features=d_target,
+                                           num_groups=k_source,
+                                           depth=32)
+        elif 'conv64' == proj_type:
+            return DepthwiseConvProjection(in_features=d_source,
+                                           flatten_out_features=d_target,
+                                           num_groups=k_source,
+                                           depth=64)
+        else:  # conv depth 1
+            return DepthwiseConvProjection(in_features=d_source,
+                                           flatten_out_features=d_target,
+                                           num_groups=k_source,
+                                           depth=1)
+    elif 'group_linear' == proj_type:
+        assert d_source % k_source == 0, "d_source and k_source must be divisible for group_linear projection."
+        return GroupLinearFlatten(in_features=d_source,
+                                  flatten_out_features=d_target,
+                                  num_groups=k_source,
+                                  use_bmm=True)
+    else:
+        raise ValueError(f"Invalid projection type: {proj_type}")
+
+
+def test_projection_layers():
+    # encoder hidden states: (B, T, K, D)
+    b = 2
+    t = 110  #10
+    k = 24  #16
+    d = 128
+    enc_hs = torch.randn(b, t, k, d)
+
+    # target shape: (B, T, K, D//4)
+    target_flatten_d = 512
+
+    # GroupLinear
+    gl = GroupLinearFlatten(in_features=d, flatten_out_features=target_flatten_d, num_groups=k, use_bmm=True)
+    enc_hs_hat = gl(enc_hs)
+    assert enc_hs_hat.shape == (b, t, target_flatten_d)
+    print('GroupLinear: ', f'{count_parameters(gl)//1000}k')  # 65k
+
+    # FlattenMLP
+    fm = FlattenMLP(in_features=d,
+                    flatten_out_features=target_flatten_d,
+                    num_groups=k,
+                    hidden_dim=None,
+                    activation=nn.GELU)
+    enc_hs_hat = fm(enc_hs)
+    assert enc_hs_hat.shape == (b, t, target_flatten_d)
+    print('FlattenMLP: ', f'{count_parameters(fm)//1000}k')  # 3.6M
+
+    # LinearProjection
+    lp = LinearProjection(in_features=d, flatten_out_features=target_flatten_d, num_groups=k)
+    enc_hs_hat = lp(enc_hs)
+    assert enc_hs_hat.shape == (b, t, target_flatten_d)
+    print('LinearProjection: ', f'{count_parameters(lp)//1000}k')  # 1M
+
+    # DepthwiseConvProjection
+    dc = DepthwiseConvProjection(in_features=d, flatten_out_features=target_flatten_d, num_groups=k, depth=16)
+    enc_hs_hat = dc(enc_hs)
+    assert enc_hs_hat.shape == (b, t, target_flatten_d)
+    print('DepthwiseConvProjection: ', f'{count_parameters(dc)//1000}k')  # 4M

model/ymt3.py

@@ -0,0 +1,967 @@
+# Copyright 2024 The YourMT3 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
+#
+# Please see the details in the LICENSE file.
+"""ymt3.py"""
+import os
+from typing import Union, Optional, Tuple, Dict, List, Any
+from collections import Counter
+
+import torch
+import torch.nn as nn
+from torch.nn import CrossEntropyLoss
+import torchaudio  # for debugging audio
+import pytorch_lightning as pl
+import numpy as np
+import wandb
+from einops import rearrange
+
+from transformers import T5Config
+from model.t5mod import T5EncoderYMT3, T5DecoderYMT3, MultiChannelT5Decoder
+from model.t5mod_helper import task_cond_dec_generate
+from model.perceiver_mod import PerceiverTFEncoder
+from model.perceiver_helper import PerceiverTFConfig
+from model.conformer_mod import ConformerYMT3Encoder
+from model.conformer_helper import ConformerYMT3Config
+from model.lm_head import LMHead
+from model.pitchshift_layer import PitchShiftLayer
+from model.spectrogram import get_spectrogram_layer_from_audio_cfg
+from model.conv_block import PreEncoderBlockRes3B
+from model.conv_block import PreEncoderBlockHFTT, PreEncoderBlockRes3BHFTT  # added for hFTT-like pre-encoder
+from model.projection_layer import get_projection_layer, get_multi_channel_projection_layer
+from model.optimizers import get_optimizer
+from model.lr_scheduler import get_lr_scheduler
+
+from utils.note_event_dataclasses import Note
+from utils.note2event import mix_notes
+from utils.event2note import merge_zipped_note_events_and_ties_to_notes, DECODING_ERR_TYPES
+from utils.metrics import compute_track_metrics
+from utils.metrics import AMTMetrics
+# from utils.utils import write_model_output_as_npy
+from utils.utils import write_model_output_as_midi, create_inverse_vocab, write_err_cnt_as_json
+from utils.utils import Timer
+from utils.task_manager import TaskManager
+
+from config.config import audio_cfg as default_audio_cfg
+from config.config import model_cfg as default_model_cfg
+from config.config import shared_cfg as default_shared_cfg
+from config.config import T5_BASE_CFG
+
+
+class YourMT3(pl.LightningModule):
+    """YourMT3:
+    
+    Lightning wrapper for multi-task music transcription Transformer.
+    
+    """
+
+    def __init__(
+            self,
+            audio_cfg: Optional[Dict] = None,
+            model_cfg: Optional[Dict] = None,
+            shared_cfg: Optional[Dict] = None,
+            pretrained: bool = False,
+            optimizer_name: str = 'adamwscale',
+            scheduler_name: str = 'cosine',
+            base_lr: float = None,  # None: 'auto' for AdaFactor, 1e-3 for constant, 1e-2 for cosine
+            max_steps: Optional[int] = None,
+            weight_decay: float = 0.0,
+            init_factor: Optional[Union[str, float]] = None,
+            task_manager: TaskManager = TaskManager(),
+            eval_subtask_key: Optional[str] = "default",
+            eval_vocab: Optional[Dict] = None,
+            eval_drum_vocab: Optional[Dict] = None,
+            write_output_dir: Optional[str] = None,
+            write_output_vocab: Optional[Dict] = None,
+            onset_tolerance: float = 0.05,
+            add_pitch_class_metric: Optional[List[str]] = None,
+            add_melody_metric_to_singing: bool = True,
+            test_optimal_octave_shift: bool = False,
+            test_pitch_shift_layer: Optional[str] = None,
+            **kwargs: Any) -> None:
+        super().__init__()
+        if pretrained is True:
+            raise NotImplementedError("Pretrained model is not supported in this version.")
+        self.test_pitch_shift_layer = test_pitch_shift_layer  # debug only
+
+        # Config
+        if model_cfg is None:
+            model_cfg = default_model_cfg  # default config, not overwritten by args of trainer
+        if audio_cfg is None:
+            audio_cfg = default_audio_cfg  # default config, not overwritten by args of trainer
+        if shared_cfg is None:
+            shared_cfg = default_shared_cfg  # default config, not overwritten by args of trainer
+
+        # Spec Layer (need to define here to infer max token length)
+        self.spectrogram, spec_output_shape = get_spectrogram_layer_from_audio_cfg(
+            audio_cfg)  # can be spec or melspec; output_shape is (T, F)
+        model_cfg["feat_length"] = spec_output_shape[0]  # T of (T, F)
+
+        # Task manger and Tokens
+        self.task_manager = task_manager
+        self.max_total_token_length = self.task_manager.max_total_token_length
+
+        # Task Conditioning
+        self.use_task_cond_encoder = bool(model_cfg["use_task_conditional_encoder"])
+        self.use_task_cond_decoder = bool(model_cfg["use_task_conditional_decoder"])
+
+        # Select Encoder type, Model-specific Config
+        assert model_cfg["encoder_type"] in ["t5", "perceiver-tf", "conformer"]
+        assert model_cfg["decoder_type"] in ["t5", "multi-t5"]
+        self.encoder_type = model_cfg["encoder_type"]  # {"t5", "perceiver-tf", "conformer"}
+        self.decoder_type = model_cfg["decoder_type"]  # {"t5", "multi-t5"}
+        encoder_config = model_cfg["encoder"][self.encoder_type]  # mutable
+        decoder_config = model_cfg["decoder"][self.decoder_type]  # mutable
+
+        # Positional Encoding
+        if isinstance(model_cfg["num_max_positions"], str) and model_cfg["num_max_positions"] == 'auto':
+            encoder_config["num_max_positions"] = int(model_cfg["feat_length"] +
+                                                      self.task_manager.max_task_token_length + 10)
+            decoder_config["num_max_positions"] = int(self.max_total_token_length + 10)
+        else:
+            assert isinstance(model_cfg["num_max_positions"], int)
+            encoder_config["num_max_positions"] = model_cfg["num_max_positions"]
+            decoder_config["num_max_positions"] = model_cfg["num_max_positions"]
+
+        # Select Pre-Encoder and Pre-Decoder type
+        if model_cfg["pre_encoder_type"] == "default":
+            model_cfg["pre_encoder_type"] = model_cfg["pre_encoder_type_default"].get(model_cfg["encoder_type"], None)
+        elif model_cfg["pre_encoder_type"] in [None, "none", "None", "0"]:
+            model_cfg["pre_encoder_type"] = None
+        if model_cfg["pre_decoder_type"] == "default":
+            model_cfg["pre_decoder_type"] = model_cfg["pre_decoder_type_default"].get(model_cfg["encoder_type"]).get(
+                model_cfg["decoder_type"], None)
+        elif model_cfg["pre_decoder_type"] in [None, "none", "None", "0"]:
+            model_cfg["pre_decoder_type"] = None
+        self.pre_encoder_type = model_cfg["pre_encoder_type"]
+        self.pre_decoder_type = model_cfg["pre_decoder_type"]
+
+        # Pre-encoder
+        self.pre_encoder = nn.Sequential()
+        if self.pre_encoder_type in ["conv", "conv1d_t", "conv1d_f"]:
+            kernel_size = (3, 3)
+            avp_kernel_size = (1, 2)
+            if self.pre_encoder_type == "conv1d_t":
+                kernel_size = (3, 1)
+            elif self.pre_encoder_type == "conv1d_f":
+                kernel_size = (1, 3)
+            self.pre_encoder.append(
+                PreEncoderBlockRes3B(1,
+                                     model_cfg["conv_out_channels"],
+                                     kernel_size=kernel_size,
+                                     avp_kernerl_size=avp_kernel_size,
+                                     activation="relu"))
+            pre_enc_output_shape = (spec_output_shape[0], spec_output_shape[1] // 2**3, model_cfg["conv_out_channels"]
+                                   )  # (T, F, C) excluding batch dim
+        elif self.pre_encoder_type == "hftt":
+            self.pre_encoder.append(PreEncoderBlockHFTT())
+            pre_enc_output_shape = (spec_output_shape[0], spec_output_shape[1], 128)  # (T, F, C) excluding batch dim
+        elif self.pre_encoder_type == "res3b_hftt":
+            self.pre_encoder.append(PreEncoderBlockRes3BHFTT())
+            pre_enc_output_shape = (spec_output_shape[0], spec_output_shape[1] // 2**3, 128)
+        else:
+            pre_enc_output_shape = spec_output_shape  # (T, F) excluding batch dim
+
+        # Auto-infer `d_feat` and `d_model`, `vocab_size`, and `num_max_positions`
+        if isinstance(model_cfg["d_feat"], str) and model_cfg["d_feat"] == 'auto':
+            if self.encoder_type == "perceiver-tf" and encoder_config["attention_to_channel"] is True:
+                model_cfg["d_feat"] = pre_enc_output_shape[-2]  # TODO: better readablity
+            else:
+                model_cfg["d_feat"] = pre_enc_output_shape[-1]  # C of (T, F, C) or F or (T, F)
+
+        if self.encoder_type == "perceiver-tf" and isinstance(encoder_config["d_model"], str):
+            if encoder_config["d_model"] == 'q':
+                encoder_config["d_model"] = encoder_config["d_latent"]
+            elif encoder_config["d_model"] == 'kv':
+                encoder_config["d_model"] = model_cfg["d_feat"]
+            else:
+                raise ValueError(f"Unknown d_model: {encoder_config['d_model']}")
+
+        # # required for PerceiverTF with attention_to_channel option
+        # if self.encoder_type == "perceiver-tf":
+        #     if encoder_config["attention_to_channel"] is True:
+        #         encoder_config["kv_dim"] = model_cfg["d_feat"]  # TODO: better readablity
+        #     else:
+        #         encoder_config["kv_dim"] = model_cfg["conv_out_channels"]
+
+        if isinstance(model_cfg["vocab_size"], str) and model_cfg["vocab_size"] == 'auto':
+            model_cfg["vocab_size"] = task_manager.num_tokens
+
+        if isinstance(model_cfg["num_max_positions"], str) and model_cfg["num_max_positions"] == 'auto':
+            model_cfg["num_max_positions"] = int(
+                max(model_cfg["feat_length"], model_cfg["event_length"]) + self.task_manager.max_task_token_length + 10)
+
+        # Pre-decoder
+        self.pre_decoder = nn.Sequential()
+        if self.encoder_type == "perceiver-tf" and self.decoder_type == "t5":
+            t, f, c = pre_enc_output_shape  # perceiver-tf: (110, 128, 128) for 2s
+            encoder_output_shape = (t, encoder_config["num_latents"], encoder_config["d_latent"])  # (T, K, D_source)
+            decoder_input_shape = (t, decoder_config["d_model"])  # (T, D_target)
+            proj_layer = get_projection_layer(input_shape=encoder_output_shape,
+                                              output_shape=decoder_input_shape,
+                                              proj_type=self.pre_decoder_type)
+            self.pre_encoder_output_shape = pre_enc_output_shape
+            self.encoder_output_shape = encoder_output_shape
+            self.decoder_input_shape = decoder_input_shape
+            self.pre_decoder.append(proj_layer)
+        elif self.encoder_type in ["t5", "conformer"] and self.decoder_type == "t5":
+            pass
+        elif self.encoder_type == "perceiver-tf" and self.decoder_type == "multi-t5":
+            # NOTE: this is experiemental, only for multi-channel decoding with 13 classes
+            assert encoder_config["num_latents"] % decoder_config["num_channels"] == 0
+            encoder_output_shape = (encoder_config["num_latents"], encoder_config["d_model"])
+            decoder_input_shape = (decoder_config["num_channels"], decoder_config["d_model"])
+            proj_layer = get_multi_channel_projection_layer(input_shape=encoder_output_shape,
+                                                            output_shape=decoder_input_shape,
+                                                            proj_type=self.pre_decoder_type)
+            self.pre_decoder.append(proj_layer)
+        else:
+            raise NotImplementedError(
+                f"Encoder type {self.encoder_type} and decoder type {self.decoder_type} is not implemented yet.")
+
+        # Positional Encoding, Vocab, etc.
+        if self.encoder_type in ["t5", "conformer"]:
+            encoder_config["num_max_positions"] = decoder_config["num_max_positions"] = model_cfg["num_max_positions"]
+        else:  # perceiver-tf uses separate positional encoding
+            encoder_config["num_max_positions"] = model_cfg["feat_length"]
+            decoder_config["num_max_positions"] = model_cfg["num_max_positions"]
+        encoder_config["vocab_size"] = decoder_config["vocab_size"] = model_cfg["vocab_size"]
+
+        # Print and save updated configs
+        self.audio_cfg = audio_cfg
+        self.model_cfg = model_cfg
+        self.shared_cfg = shared_cfg
+        self.save_hyperparameters()
+        if self.global_rank == 0:
+            print(self.hparams)
+
+        # Encoder and Decoder and LM-head
+        self.encoder = None
+        self.decoder = None
+        self.lm_head = LMHead(decoder_config, 1.0, model_cfg["tie_word_embeddings"])
+        self.embed_tokens = nn.Embedding(decoder_config["vocab_size"], decoder_config["d_model"])
+        self.embed_tokens.weight.data.normal_(mean=0.0, std=1.0)
+        self.shift_right_fn = None
+        self.set_encoder_decoder()  # shift_right_fn is also set here
+
+        # Model as ModuleDict
+        # self.model = nn.ModuleDict({
+        #     "pitchshift": self.pitchshift,   # no grad; created in setup() only for training,
+        #                                        and called by training_step()
+        #     "spectrogram": self.spectrogram,  # no grad
+        #     "pre_encoder": self.pre_encoder,
+        #     "encoder": self.encoder,
+        #     "pre_decoder": self.pre_decoder,
+        #     "decoder": self.decoder,
+        #     "embed_tokens": self.embed_tokens,
+        #     "lm_head": self.lm_head,
+        # })
+
+        # Tables (for logging)
+        columns = ['Ep', 'Track ID', 'Pred Events', 'Actual Events', 'Pred Notes', 'Actual Notes']
+        self.sample_table = wandb.Table(columns=columns)
+
+        # Output MIDI
+        if write_output_dir is not None:
+            if write_output_vocab is None:
+                from config.vocabulary import program_vocab_presets
+                self.midi_output_vocab = program_vocab_presets["gm_ext_plus"]
+            else:
+                self.midi_output_vocab = write_output_vocab
+            self.midi_output_inverse_vocab = create_inverse_vocab(self.midi_output_vocab)
+
+    def set_encoder_decoder(self) -> None:
+        """Set encoder, decoder, lm_head and emb_tokens from self.model_cfg"""
+
+        # Generate and update T5Config
+        t5_basename = self.model_cfg["t5_basename"]
+        if t5_basename in T5_BASE_CFG.keys():
+            # Load from pre-defined config in config.py
+            t5_config = T5Config(**T5_BASE_CFG[t5_basename])
+        else:
+            # Load from HuggingFace hub
+            t5_config = T5Config.from_pretrained(t5_basename)
+
+        # Create encoder, decoder, lm_head and embed_tokens
+        if self.encoder_type == "t5":
+            self.encoder = T5EncoderYMT3(self.model_cfg["encoder"]["t5"], t5_config)
+        elif self.encoder_type == "perceiver-tf":
+            perceivertf_config = PerceiverTFConfig()
+            perceivertf_config.update(self.model_cfg["encoder"]["perceiver-tf"])
+            self.encoder = PerceiverTFEncoder(perceivertf_config)
+        elif self.encoder_type == "conformer":
+            conformer_config = ConformerYMT3Config()
+            conformer_config.update(self.model_cfg["encoder"]["conformer"])
+            self.encoder = ConformerYMT3Encoder(conformer_config)
+
+        if self.decoder_type == "t5":
+            self.decoder = T5DecoderYMT3(self.model_cfg["decoder"]["t5"], t5_config)
+        elif self.decoder_type == "multi-t5":
+            self.decoder = MultiChannelT5Decoder(self.model_cfg["decoder"]["multi-t5"], t5_config)
+
+        # `shift_right` function for decoding
+        self.shift_right_fn = self.decoder._shift_right
+
+    def setup(self, stage: str) -> None:
+        # Defining metrics
+        if self.hparams.eval_vocab is None:
+            extra_classes_per_dataset = [None]
+        else:
+            extra_classes_per_dataset = [
+                list(v.keys()) if v is not None else None for v in self.hparams.eval_vocab
+            ]  # e.g. [['Piano'], ['Guitar'], ['Piano'], ['Piano', 'Strings', 'Winds'], None]
+
+        # For direct addition of extra metrics using full metric name
+        extra_metrics = None
+        if self.hparams.add_melody_metric_to_singing is True:
+            extra_metrics = ["melody_rpa_Singing Voice", "melody_rca_Singing Voice", "melody_oa_Singing Voice"]
+
+        # Add pitch class metric
+        if self.hparams.add_pitch_class_metric is not None:
+            for sublist in extra_classes_per_dataset:
+                for name in self.hparams.add_pitch_class_metric:
+                    if sublist is not None and name in sublist:
+                        sublist += [name + "_pc"]
+
+        extra_classes_unique = list(
+            set(item for sublist in extra_classes_per_dataset if sublist is not None
+                for item in sublist))  # e.g. ['Strings', 'Winds', 'Guitar', 'Piano']
+        dm = self.trainer.datamodule
+
+        # Train/Vaidation-only
+        if stage == "fit":
+            self.val_metrics_macro = AMTMetrics(prefix=f'validation/macro_', extra_classes=extra_classes_unique)
+            self.val_metrics = nn.ModuleList()  # val_metric is a list of AMTMetrics objects
+            for i in range(dm.num_val_dataloaders):
+                self.val_metrics.append(
+                    AMTMetrics(prefix=f'validation/({dm.get_val_dataset_name(i)})',
+                               extra_classes=extra_classes_per_dataset[i],
+                               error_types=DECODING_ERR_TYPES))
+
+            # Add pitchshift layer
+            if self.shared_cfg["AUGMENTATION"]["train_pitch_shift_range"] in [None, [0, 0]]:
+                self.pitchshift = None
+            else:
+                # torchaudio pitchshifter requires a dummy input for initialization in DDP
+                input_shape = (self.shared_cfg["BSZ"]["train_local"], 1, self.audio_cfg["input_frames"])
+                self.pitchshift = PitchShiftLayer(
+                    pshift_range=self.shared_cfg["AUGMENTATION"]["train_pitch_shift_range"],
+                    expected_input_shape=input_shape,
+                    device=self.device)
+
+        # Test-only
+        elif stage == "test":
+            # self.test_metrics_macro = AMTMetrics(
+            #     prefix=f'test/macro_', extra_classes=extra_classes_unique)
+            self.test_metrics = nn.ModuleList()
+            for i in range(dm.num_test_dataloaders):
+                self.test_metrics.append(
+                    AMTMetrics(prefix=f'test/({dm.get_test_dataset_name(i)})',
+                               extra_classes=extra_classes_per_dataset[i],
+                               extra_metrics=extra_metrics,
+                               error_types=DECODING_ERR_TYPES))
+
+            # Test pitch shift layer: debug only
+            if self.test_pitch_shift_layer is not None:
+                self.test_pitch_shift_semitone = int(self.test_pitch_shift_layer)
+                self.pitchshift = PitchShiftLayer(
+                    pshift_range=[self.test_pitch_shift_semitone, self.test_pitch_shift_semitone])
+
+    def configure_optimizers(self) -> None:
+        """Configure optimizer and scheduler"""
+        optimizer, base_lr = get_optimizer(models_dict=self.named_parameters(),
+                                           optimizer_name=self.hparams.optimizer_name,
+                                           base_lr=self.hparams.base_lr,
+                                           weight_decay=self.hparams.weight_decay)
+
+        if self.hparams.optimizer_name.lower() == 'adafactor' and self.hparams.base_lr == None:
+            print("Using AdaFactor with auto learning rate and no scheduler")
+            return [optimizer]
+        if self.hparams.optimizer_name.lower() == 'dadaptadam':
+            print("Using dAdaptAdam with auto learning rate and no scheduler")
+            return [optimizer]
+        elif self.hparams.base_lr == None:
+            print(f"Using default learning rate {base_lr} of {self.hparams.optimizer_name} as base learning rate.")
+            self.hparams.base_lr = base_lr
+
+        scheduler_cfg = self.shared_cfg["LR_SCHEDULE"]
+        if self.hparams.max_steps != -1:
+            # overwrite total_steps
+            scheduler_cfg["total_steps"] = self.hparams.max_steps
+        _lr_scheduler = get_lr_scheduler(optimizer,
+                                         scheduler_name=self.hparams.scheduler_name,
+                                         base_lr=base_lr,
+                                         scheduler_cfg=scheduler_cfg)
+
+        lr_scheduler = {'scheduler': _lr_scheduler, 'interval': 'step', 'frequency': 1}
+        return [optimizer], [lr_scheduler]
+
+    def forward(
+            self,
+            x: torch.FloatTensor,
+            target_tokens: torch.LongTensor,
+            # task_tokens: Optional[torch.LongTensor] = None,
+            **kwargs) -> Dict:
+        """ Forward pass with teacher-forcing for training and validation.
+        Args:
+            x: (B, 1, T) waveform with default T=32767
+            target_tokens: (B, C, N) tokenized sequence of length N=event_length
+            task_tokens: (B, C, task_len) tokenized task
+
+        Returns:
+            {
+                'logits': (B, N + task_len + 1, vocab_size)
+                'loss': (1, )
+            }
+
+        NOTE: all the commented shapes are in the case of original MT3 setup.
+        """
+        x = self.spectrogram(x)  # mel-/spectrogram: (b, 256, 512) or (B, T, F)
+        x = self.pre_encoder(x)  # projection to d_model: (B, 256, 512)
+
+        # TODO: task_cond_encoder would not work properly because of 3-d task_tokens
+        # if task_tokens is not None and task_tokens.numel() > 0 and self.use_task_cond_encoder is True:
+        #     # append task embedding to encoder input
+        #     task_embed = self.embed_tokens(task_tokens)  # (B, task_len, 512)
+        #     x = torch.cat([task_embed, x], dim=1)  # (B, task_len + 256, 512)
+        enc_hs = self.encoder(inputs_embeds=x)["last_hidden_state"]  # (B, T', D)
+        enc_hs = self.pre_decoder(enc_hs)  # (B, T', D) or (B, K, T, D)
+
+        # if task_tokens is not None and task_tokens.numel() > 0 and self.use_task_cond_decoder is True:
+        #     # append task token to decoder input and output label
+        #     labels = torch.cat([task_tokens, target_tokens], dim=2)  # (B, C, task_len + N)
+        # else:
+        #     labels = target_tokens  # (B, C, N)
+        labels = target_tokens  # (B, C, N)
+        if labels.shape[1] == 1:  # for single-channel decoders, e.g. t5.
+            labels = labels.squeeze(1)  # (B, N)
+
+        dec_input_ids = self.shift_right_fn(labels)  # t5:(B, N), multi-t5:(B, C, N)
+        dec_inputs_embeds = self.embed_tokens(dec_input_ids)  # t5:(B, N, D), multi-t5:(B, C, N, D)
+        dec_hs, _ = self.decoder(inputs_embeds=dec_inputs_embeds, encoder_hidden_states=enc_hs, return_dict=False)
+
+        if self.model_cfg["tie_word_embeddings"] is True:
+            dec_hs = dec_hs * (self.model_cfg["decoder"][self.decoder_type]["d_model"]**-0.5)
+
+        logits = self.lm_head(dec_hs)
+
+        loss = None
+        labels = labels.masked_fill(labels == 0, value=-100)  # ignore pad tokens for loss
+        loss_fct = CrossEntropyLoss(ignore_index=-100)
+        loss = loss_fct(logits.view(-1, logits.size(-1)), labels.view(-1))
+        return {"logits": logits, "loss": loss}
+
+    def inference(self,
+                  x: torch.FloatTensor,
+                  task_tokens: Optional[torch.LongTensor] = None,
+                  max_token_length: Optional[int] = None,
+                  **kwargs: Any) -> torch.Tensor:
+        """ Inference from audio batch by cached autoregressive decoding.
+        Args:
+            x: (b, 1, t) waveform with t=32767
+            task_token: (b, c, task_len) tokenized task. If None, will not append task embeddings (from task_tokens) to input.
+            max_length: Maximum length of generated sequence. If None, self.max_total_token_length.
+            **kwargs: https://huggingface.co/docs/transformers/v4.27.2/en/main_classes/text_generation#transformers.GenerationMixin.generate
+            
+        Returns:
+            res_tokens: (b, n) resulting tokenized sequence of variable length < max_length
+        """
+        if self.test_pitch_shift_layer is not None:
+            x_ps = self.pitchshift(x, self.test_pitch_shift_semitone)
+            x = x_ps
+
+        # From spectrogram to pre-decoder is the same pipeline as in forward()
+        x = self.spectrogram(x)  # mel-/spectrogram: (b, 256, 512) or (B, T, F)
+        x = self.pre_encoder(x)  # projection to d_model: (B, 256, 512)
+        if task_tokens is not None and task_tokens.numel() > 0 and self.use_task_cond_encoder is True:
+            # append task embedding to encoder input
+            task_embed = self.embed_tokens(task_tokens)  # (B, task_len, 512)
+            x = torch.cat([task_embed, x], dim=1)  # (B, task_len + 256, 512)
+        enc_hs = self.encoder(inputs_embeds=x)["last_hidden_state"]  # (B, task_len + 256, 512)
+        enc_hs = self.pre_decoder(enc_hs)  # (B, task_len + 256, 512)
+
+        # Cached-autoregressive decoding with task token (can be None) as prefix
+        if max_token_length is None:
+            max_token_length = self.max_total_token_length
+
+        pred_ids = task_cond_dec_generate(decoder=self.decoder,
+                                          decoder_type=self.decoder_type,
+                                          embed_tokens=self.embed_tokens,
+                                          lm_head=self.lm_head,
+                                          encoder_hidden_states=enc_hs,
+                                          shift_right_fn=self.shift_right_fn,
+                                          prefix_ids=task_tokens,
+                                          max_length=max_token_length)  # (B, task_len + N) or (B, C, task_len + N)
+        if pred_ids.dim() == 2:
+            pred_ids = pred_ids.unsqueeze(1)  # (B, 1, task_len + N)
+
+        if self.test_pitch_shift_layer is None:
+            return pred_ids
+        else:
+            return pred_ids, x_ps
+
+    def inference_file(
+        self,
+        bsz: int,
+        audio_segments: torch.FloatTensor,  # (n_items, 1, segment_len): from a single file
+        note_token_array: Optional[torch.LongTensor] = None,
+        task_token_array: Optional[torch.LongTensor] = None,
+        # subtask_key: Optional[str] = "default"
+    ) -> Tuple[List[np.ndarray], Optional[torch.Tensor]]:
+        """ Inference from audio batch by autoregressive decoding:
+        Args:
+            bsz: batch size
+            audio_segments: (n_items, 1, segment_len): segmented audio from a single file
+            note_token_array: (n_items, max_token_len): Optional. If token_array is None, will not return loss.
+            subtask_key: (str): If None, not using subtask prefix. By default, using "default" defined in task manager.
+        """
+        # if subtask_key is not None:
+        #     _subtask_token = torch.LongTensor(
+        #         self.task_manager.get_eval_subtask_prefix_dict()[subtask_key]).to(self.device)
+
+        n_items = audio_segments.shape[0]
+        loss = 0.
+        pred_token_array_file = []  # each element is (B, C, L) np.ndarray
+        x_ps_concat = []
+
+        for i in range(0, n_items, bsz):
+            if i + bsz > n_items:  # last batch can be smaller
+                x = audio_segments[i:n_items].to(self.device)
+                # if subtask_key is not None:
+                #     b = n_items - i  # bsz for the last batch
+                #     task_tokens = _subtask_token.expand((b, -1))  # (b, task_len)
+                if note_token_array is not None:
+                    target_tokens = note_token_array[i:n_items].to(self.device)
+                if task_token_array is not None and task_token_array.numel() > 0:
+                    task_tokens = task_token_array[i:n_items].to(self.device)
+                else:
+                    task_tokens = None
+            else:
+                x = audio_segments[i:i + bsz].to(self.device)  # (bsz, 1, segment_len)
+                # if subtask_key is not None:
+                #     task_tokens = _subtask_token.expand((bsz, -1))  # (bsz, task_len)
+                if note_token_array is not None:
+                    target_tokens = note_token_array[i:i + bsz].to(self.device)  # (bsz, token_len)
+                if task_token_array is not None and task_token_array.numel() > 0:
+                    task_tokens = task_token_array[i:i + bsz].to(self.device)
+                else:
+                    task_tokens = None
+
+            # token prediction (fast-autoregressive decoding)
+            # if subtask_key is not None:
+            #     preds = self.inference(x, task_tokens).detach().cpu().numpy()
+            # else:
+            #     preds = self.inference(x).detach().cpu().numpy()
+
+            if self.test_pitch_shift_layer is not None:  # debug only
+                preds, x_ps = self.inference(x, task_tokens)
+                preds = preds.detach().cpu().numpy()
+                x_ps_concat.append(x_ps.detach().cpu())
+            else:
+                preds = self.inference(x, task_tokens).detach().cpu().numpy()
+            if len(preds) != len(x):
+                raise ValueError(f'preds: {len(preds)}, x: {len(x)}')
+            pred_token_array_file.append(preds)
+
+            # validation loss (by teacher forcing)
+            if note_token_array is not None:
+                loss_weight = x.shape[0] / n_items
+                loss += self(x, target_tokens)['loss'] * loss_weight
+                # loss += self(x, target_tokens, task_tokens)['loss'] * loss_weight
+            else:
+                loss = None
+
+        if self.test_pitch_shift_layer is not None:  # debug only
+            if self.hparams.write_output_dir is not None:
+                x_ps_concat = torch.cat(x_ps_concat, dim=0)
+                return pred_token_array_file, loss, x_ps_concat.flatten().unsqueeze(0)
+        else:
+            return pred_token_array_file, loss
+
+    def training_step(self, batch, batch_idx) -> torch.Tensor:
+        # batch: {
+        # 'dataset1': [Tuple[audio_segments(b, 1, t), tokens(b, max_token_len), ...]]
+        # 'dataset2': [Tuple[audio_segments(b, 1, t), tokens(b, max_token_len), ...]]
+        # 'dataset3': ...
+        # }
+        audio_segments, note_tokens, pshift_steps = [torch.cat(t, dim=0) for t in zip(*batch.values())]
+
+        if self.pitchshift is not None:
+            # Pitch shift
+            n_groups = len(batch)
+            audio_segments = torch.chunk(audio_segments, n_groups, dim=0)
+            pshift_steps = torch.chunk(pshift_steps, n_groups, dim=0)
+            for p in pshift_steps:
+                assert p.eq(p[0]).all().item()
+
+            audio_segments = torch.cat([self.pitchshift(a, p[0].item()) for a, p in zip(audio_segments, pshift_steps)],
+                                       dim=0)
+
+        loss = self(audio_segments, note_tokens)['loss']
+        self.log('train_loss',
+                 loss,
+                 on_step=True,
+                 on_epoch=True,
+                 prog_bar=True,
+                 batch_size=note_tokens.shape[0],
+                 sync_dist=True)
+        # print('lr', self.trainer.optimizers[0].param_groups[0]['lr'])
+        return loss
+
+    def validation_step(self, batch, batch_idx, dataloader_idx=0) -> Dict:
+        # File-wise validation
+        if self.task_manager.num_decoding_channels == 1:
+            bsz = self.shared_cfg["BSZ"]["validation"]
+        else:
+            bsz = self.shared_cfg["BSZ"]["validation"] // self.task_manager.num_decoding_channels * 3
+        # audio_segments, notes_dict, note_token_array, task_token_array = batch
+        audio_segments, notes_dict, note_token_array = batch
+        task_token_array = None
+
+        # Loop through the tensor in chunks of bsz (=subbsz actually)
+        n_items = audio_segments.shape[0]
+        start_secs_file = [32767 * i / 16000 for i in range(n_items)]
+        with Timer() as t:
+            pred_token_array_file, loss = self.inference_file(bsz, audio_segments, note_token_array, task_token_array)
+            """
+            notes_dict: # Ground truth notes
+                {
+                    'mtrack_id': int,
+                    'program': List[int],
+                    'is_drum': bool,
+                    'duration_sec': float,
+                    'notes': List[Note],
+                }
+            """
+            # Process a list of channel-wise token arrays for a file
+            num_channels = self.task_manager.num_decoding_channels
+            pred_notes_in_file = []
+            n_err_cnt = Counter()
+            for ch in range(num_channels):
+                pred_token_array_ch = [arr[:, ch, :] for arr in pred_token_array_file]  # (B, L)
+                zipped_note_events_and_tie, list_events, ne_err_cnt = self.task_manager.detokenize_list_batches(
+                    pred_token_array_ch, start_secs_file, return_events=True)
+                pred_notes_ch, n_err_cnt_ch = merge_zipped_note_events_and_ties_to_notes(zipped_note_events_and_tie)
+                pred_notes_in_file.append(pred_notes_ch)
+                n_err_cnt += n_err_cnt_ch
+            pred_notes = mix_notes(pred_notes_in_file)  # This is the mixed notes from all channels
+
+            if self.hparams.write_output_dir is not None:
+                track_info = [notes_dict[k] for k in notes_dict.keys() if k.endswith("_id")][0]
+                dataset_info = [k for k in notes_dict.keys() if k.endswith('_id')][0][:-3]
+                # write_model_output_as_npy(zipped_note_events_and_tie, self.hparams.write_output_dir,
+                #                           track_info)
+                write_model_output_as_midi(pred_notes,
+                                           self.hparams.write_output_dir,
+                                           track_info,
+                                           self.midi_output_inverse_vocab,
+                                           output_dir_suffix=str(dataset_info) + '_' +
+                                           str(self.hparams.eval_subtask_key))
+            # generate sample text to display in log table
+            # pred_events_text = [str([list_events[0][:200]])]
+            # pred_notes_text = [str([pred_notes[:200]])]
+
+            # this is local GPU metric per file, not global metric in DDP
+            drum_metric, non_drum_metric, instr_metric = compute_track_metrics(
+                pred_notes,
+                notes_dict['notes'],
+                eval_vocab=self.hparams.eval_vocab[dataloader_idx],
+                eval_drum_vocab=self.hparams.eval_drum_vocab,
+                onset_tolerance=self.hparams.onset_tolerance,
+                add_pitch_class_metric=self.hparams.add_pitch_class_metric)
+            self.val_metrics[dataloader_idx].bulk_update(drum_metric)
+            self.val_metrics[dataloader_idx].bulk_update(non_drum_metric)
+            self.val_metrics[dataloader_idx].bulk_update(instr_metric)
+            self.val_metrics_macro.bulk_update(drum_metric)
+            self.val_metrics_macro.bulk_update(non_drum_metric)
+            self.val_metrics_macro.bulk_update(instr_metric)
+
+        # Log sample table: predicted notes and ground truth notes
+        # if batch_idx in (0, 1) and self.global_rank == 0:
+        #     actual_notes_text = [str([notes_dict['notes'][:200]])]
+        #     actual_tokens = token_array[0, :200].detach().cpu().numpy().tolist()
+        #     actual_events_text = [str(self.tokenizer._decode(actual_tokens))]
+        #     track_info = [notes_dict[k] for k in notes_dict.keys() if k.endswith("_id")]
+        #     self.sample_table.add_data(self.current_epoch, track_info, pred_events_text,
+        #                                actual_events_text, pred_notes_text, actual_notes_text)
+        #     self.logger.log_table('Samples', self.sample_table.columns, self.sample_table.data)
+
+        decoding_time_sec = t.elapsed_time()
+        self.log('val_loss', loss, prog_bar=True, batch_size=n_items, sync_dist=True)
+        # self.val_metrics[dataloader_idx].bulk_update_errors({'decoding_time': decoding_time_sec})
+
+    def on_validation_epoch_end(self) -> None:
+        for val_metrics in self.val_metrics:
+            self.log_dict(val_metrics.bulk_compute(), sync_dist=True)
+            val_metrics.bulk_reset()
+        self.log_dict(self.val_metrics_macro.bulk_compute(), sync_dist=True)
+        self.val_metrics_macro.bulk_reset()
+
+    def test_step(self, batch, batch_idx, dataloader_idx=0) -> Dict:
+        # File-wise evaluation
+        if self.task_manager.num_decoding_channels == 1:
+            bsz = self.shared_cfg["BSZ"]["validation"]
+        else:
+            bsz = self.shared_cfg["BSZ"]["validation"] // self.task_manager.num_decoding_channels * 3
+        # audio_segments, notes_dict, note_token_array, task_token_array = batch
+        audio_segments, notes_dict, note_token_array = batch
+        task_token_array = None
+
+        # Test pitch shift layer: debug only
+        if self.test_pitch_shift_layer is not None and self.test_pitch_shift_semitone != 0:
+            for n in notes_dict['notes']:
+                if n.is_drum == False:
+                    n.pitch = n.pitch + self.test_pitch_shift_semitone
+
+        # Loop through the tensor in chunks of bsz (=subbsz actually)
+        n_items = audio_segments.shape[0]
+        start_secs_file = [32767 * i / 16000 for i in range(n_items)]
+
+        if self.test_pitch_shift_layer is not None and self.hparams.write_output_dir is not None:
+            pred_token_array_file, loss, x_ps = self.inference_file(bsz, audio_segments, None, None)
+        else:
+            pred_token_array_file, loss = self.inference_file(bsz, audio_segments, None, None)
+        if len(pred_token_array_file) > 0:
+
+            # Process a list of channel-wise token arrays for a file
+            num_channels = self.task_manager.num_decoding_channels
+            pred_notes_in_file = []
+            n_err_cnt = Counter()
+            for ch in range(num_channels):
+                pred_token_array_ch = [arr[:, ch, :] for arr in pred_token_array_file]  # (B, L)
+                zipped_note_events_and_tie, list_events, ne_err_cnt = self.task_manager.detokenize_list_batches(
+                    pred_token_array_ch, start_secs_file, return_events=True)
+                pred_notes_ch, n_err_cnt_ch = merge_zipped_note_events_and_ties_to_notes(zipped_note_events_and_tie)
+                pred_notes_in_file.append(pred_notes_ch)
+                n_err_cnt += n_err_cnt_ch
+            pred_notes = mix_notes(pred_notes_in_file)  # This is the mixed notes from all channels
+
+            if self.test_pitch_shift_layer is not None and self.hparams.write_output_dir is not None:
+                # debug only
+                wav_output_dir = os.path.join(self.hparams.write_output_dir, f"model_output_{dataset_info}")
+                os.makedirs(wav_output_dir, exist_ok=True)
+                wav_output_file = os.path.join(wav_output_dir, f"{track_info}_ps_{self.test_pitch_shift_semitone}.wav")
+                torchaudio.save(wav_output_file, x_ps.squeeze(1), 16000, bits_per_sample=16)
+
+            drum_metric, non_drum_metric, instr_metric = compute_track_metrics(
+                pred_notes,
+                notes_dict['notes'],
+                eval_vocab=self.hparams.eval_vocab[dataloader_idx],
+                eval_drum_vocab=self.hparams.eval_drum_vocab,
+                onset_tolerance=self.hparams.onset_tolerance,
+                add_pitch_class_metric=self.hparams.add_pitch_class_metric,
+                add_melody_metric=['Singing Voice'] if self.hparams.add_melody_metric_to_singing else None,
+                add_frame_metric=True,
+                add_micro_metric=True,
+                add_multi_f_metric=True)
+
+            if self.hparams.write_output_dir is not None and self.global_rank == 0:
+                # write model output to file
+                track_info = [notes_dict[k] for k in notes_dict.keys() if k.endswith("_id")][0]
+                dataset_info = [k for k in notes_dict.keys() if k.endswith('_id')][0][:-3]
+                f_score = f"OnF{non_drum_metric['onset_f']:.2f}_MulF{instr_metric['multi_f']:.2f}"
+                write_model_output_as_midi(pred_notes,
+                                           self.hparams.write_output_dir,
+                                           track_info,
+                                           self.midi_output_inverse_vocab,
+                                           output_dir_suffix=str(dataset_info) + '_' +
+                                           str(self.hparams.eval_subtask_key) + '_' + f_score)
+                write_err_cnt_as_json(track_info, self.hparams.write_output_dir,
+                                      str(dataset_info) + '_' + str(self.hparams.eval_subtask_key) + '_' + f_score,
+                                      n_err_cnt, ne_err_cnt)
+
+            # Test with optimal octave shift
+            if self.hparams.test_optimal_octave_shift:
+                track_info = [notes_dict[k] for k in notes_dict.keys() if k.endswith("_id")][0]
+                dataset_info = [k for k in notes_dict.keys() if k.endswith('_id')][0][:-3]
+                score = [instr_metric['onset_f_Bass']]
+                ref_notes_plus = []
+                ref_notes_minus = []
+                for note in notes_dict['notes']:
+                    if note.is_drum == True:
+                        ref_notes_plus.append(note)
+                        ref_notes_minus.append(note)
+                    else:
+                        ref_notes_plus.append(
+                            Note(is_drum=note.is_drum,
+                                 program=note.program,
+                                 onset=note.onset,
+                                 offset=note.offset,
+                                 pitch=note.pitch + 12,
+                                 velocity=note.velocity))
+                        ref_notes_minus.append(
+                            Note(is_drum=note.is_drum,
+                                 program=note.program,
+                                 onset=note.onset,
+                                 offset=note.offset,
+                                 pitch=note.pitch - 12,
+                                 velocity=note.velocity))
+
+                drum_metric_plus, non_drum_metric_plus, instr_metric_plus = compute_track_metrics(
+                    pred_notes,
+                    ref_notes_plus,
+                    eval_vocab=self.hparams.eval_vocab[dataloader_idx],
+                    eval_drum_vocab=self.hparams.eval_drum_vocab,
+                    onset_tolerance=self.hparams.onset_tolerance,
+                    add_pitch_class_metric=self.hparams.add_pitch_class_metric)
+                drum_metric_minus, non_drum_metric_minus, instr_metric_minus = compute_track_metrics(
+                    ref_notes_minus,
+                    notes_dict['notes'],
+                    eval_vocab=self.hparams.eval_vocab[dataloader_idx],
+                    eval_drum_vocab=self.hparams.eval_drum_vocab,
+                    onset_tolerance=self.hparams.onset_tolerance,
+                    add_pitch_class_metric=self.hparams.add_pitch_class_metric)
+
+                score.append(instr_metric_plus['onset_f_Bass'])
+                score.append(instr_metric_minus['onset_f_Bass'])
+                max_index = score.index(max(score))
+                if max_index == 0:
+                    print(f"ZERO: {track_info}, z/p/m: {score[0]:.2f}/{score[1]:.2f}/{score[2]:.2f}")
+                elif max_index == 1:
+                    # plus
+                    instr_metric['onset_f_Bass'] = instr_metric_plus['onset_f_Bass']
+                    print(f"PLUS: {track_info}, z/p/m: {score[0]:.2f}/{score[1]:.2f}/{score[2]:.2f}")
+                    write_model_output_as_midi(ref_notes_plus,
+                                               self.hparams.write_output_dir,
+                                               track_info + '_ref_octave_plus',
+                                               self.midi_output_inverse_vocab,
+                                               output_dir_suffix=str(dataset_info) + '_' +
+                                               str(self.hparams.eval_subtask_key))
+                else:
+                    # minus
+                    instr_metric['onset_f_Bass'] = instr_metric_minus['onset_f_Bass']
+                    print(f"MINUS: {track_info}, z/p/m: {score[0]:.2f}/{score[1]:.2f}/{score[2]:.2f}")
+                    write_model_output_as_midi(ref_notes_minus,
+                                               self.hparams.write_output_dir,
+                                               track_info + '_ref_octave_minus',
+                                               self.midi_output_,
+                                               output_dir_suffix=str(dataset_info) + '_' +
+                                               str(self.hparams.eval_subtask_key))
+
+            self.test_metrics[dataloader_idx].bulk_update(drum_metric)
+            self.test_metrics[dataloader_idx].bulk_update(non_drum_metric)
+            self.test_metrics[dataloader_idx].bulk_update(instr_metric)
+            # self.test_metrics_macro.bulk_update(drum_metric)
+            # self.test_metrics_macro.bulk_update(non_drum_metric)
+            # self.test_metrics_macro.bulk_update(instr_metric)
+
+    def on_test_epoch_end(self) -> None:
+        # all_gather is done seeminglesly by torchmetrics
+        for test_metrics in self.test_metrics:
+            self.log_dict(test_metrics.bulk_compute(), sync_dist=True)
+            test_metrics.bulk_reset()
+        # self.log_dict(self.test_metrics_macro.bulk_compute(), sync_dist=True)
+        # self.test_metrics_macro.bulk_reset()
+
+
+def test_case_forward_mt3():
+    import torch
+    from config.config import audio_cfg, model_cfg, shared_cfg
+    from model.ymt3 import YourMT3
+    model = YourMT3()
+    model.eval()
+    x = torch.randn(2, 1, 32767)
+    labels = torch.randint(0, 596, (2, 1, 1024), requires_grad=False)  # (B, C=1, T)
+    task_tokens = torch.LongTensor([])
+    output = model.forward(x, labels, task_tokens)
+    logits, loss = output['logits'], output['loss']
+    assert logits.shape == (2, 1024, 596)  # (B, N, vocab_size)
+
+
+def test_case_inference_mt3():
+    import torch
+    from config.config import audio_cfg, model_cfg, shared_cfg
+    from model.ymt3 import YourMT3
+    model_cfg["num_max_positions"] = 1024 + 3 + 1
+    model = YourMT3(model_cfg=model_cfg)
+    model.eval()
+    x = torch.randn(2, 1, 32767)
+    task_tokens = torch.randint(0, 596, (2, 3), requires_grad=False)
+    pred_ids = model.inference(x, task_tokens, max_token_length=10)  # (2, 3, 9) (B, C, L-task_len)
+    # TODO: need to check the length of pred_ids when task_tokens is not None
+
+
+def test_case_forward_enc_perceiver_tf_dec_t5():
+    import torch
+    from model.ymt3 import YourMT3
+    from config.config import audio_cfg, model_cfg, shared_cfg
+    model_cfg["encoder_type"] = "perceiver-tf"
+    audio_cfg["codec"] = "spec"
+    audio_cfg["hop_length"] = 300
+
+    model = YourMT3(audio_cfg=audio_cfg, model_cfg=model_cfg)
+    model.eval()
+
+    x = torch.randn(2, 1, 32767)
+    labels = torch.randint(0, 596, (2, 1, 1024), requires_grad=False)
+
+    # forward
+    output = model.forward(x, labels)
+    logits, loss = output['logits'], output['loss']  # logits: (2, 1024, 596) (B, N, vocab_size)
+
+    # inference
+    pred_ids = model.inference(x, None, max_token_length=3)  # (2, 1, 3) (B, C, L)
+
+
+def test_case_forward_enc_conformer_dec_t5():
+    import torch
+    from model.ymt3 import YourMT3
+    from config.config import audio_cfg, model_cfg, shared_cfg
+    model_cfg["encoder_type"] = "conformer"
+    audio_cfg["codec"] = "melspec"
+    audio_cfg["hop_length"] = 128
+    model = YourMT3(audio_cfg=audio_cfg, model_cfg=model_cfg)
+    model.eval()
+
+    x = torch.randn(2, 1, 32767)
+    labels = torch.randint(0, 596, (2, 1024), requires_grad=False)
+
+    # forward
+    output = model.forward(x, labels)
+    logits, loss = output['logits'], output['loss']  # logits: (2, 1024, 596) (B, N, vocab_size)
+
+    # inference
+    pred_ids = model.inference(x, None, 20)  # (2, 1, 20) (B, C, L)
+
+
+def test_case_enc_perceiver_tf_dec_multi_t5():
+    import torch
+    from model.ymt3 import YourMT3
+    from config.config import audio_cfg, model_cfg, shared_cfg
+    model_cfg["encoder_type"] = "perceiver-tf"
+    model_cfg["decoder_type"] = "multi-t5"
+    model_cfg["encoder"]["perceiver-tf"]["attention_to_channel"] = True
+    model_cfg["encoder"]["perceiver-tf"]["num_latents"] = 26
+    audio_cfg["codec"] = "spec"
+    audio_cfg["hop_length"] = 300
+    model = YourMT3(audio_cfg=audio_cfg, model_cfg=model_cfg)
+    model.eval()
+
+    x = torch.randn(2, 1, 32767)
+    labels = torch.randint(0, 596, (2, 13, 200), requires_grad=False)  # (B, C, T)
+
+    # x = model.spectrogram(x)
+    # x = model.pre_encoder(x)  # (2, 110, 128, 128) (B, T, C, D)
+    # enc_hs = model.encoder(inputs_embeds=x)["last_hidden_state"]  # (2, 110, 128, 128) (B, T, C, D)
+    # enc_hs = model.pre_decoder(enc_hs)  # (2, 13, 110, 512) (B, C, T, D)
+
+    # dec_input_ids = model.shift_right_fn(labels)  # (2, 13, 200) (B, C, T)
+    # dec_inputs_embeds = model.embed_tokens(dec_input_ids)  # (2, 13, 200, 512) (B, C, T, D)
+    # dec_hs, _ = model.decoder(
+    #     inputs_embeds=dec_inputs_embeds, encoder_hidden_states=enc_hs, return_dict=False)
+    # logits = model.lm_head(dec_hs)  # (2, 13, 200, 596) (B, C, T, vocab_size)
+
+    # forward
+    x = torch.randn(2, 1, 32767)
+    labels = torch.randint(0, 596, (2, 13, 200), requires_grad=False)  # (B, C, T)
+    output = model.forward(x, labels)
+    logits, loss = output['logits'], output['loss']  # (2, 13, 200, 596) (B, C, T, vocab_size)
+
+    # inference
+    model.max_total_token_length = 123  # to save time..
+    pred_ids = model.inference(x, None)  # (2, 13, 123) (B, C, L)

tests/model/spectrogram_test.py

@@ -0,0 +1,29 @@
+import torch
+import unittest
+from model.spectrogram import Melspectrogram
+
+
+class TestMelspectrogram(unittest.TestCase):
+
+    def test_melspectrogram(self):
+        # Create a Melspectrogram instance with default parameters
+        melspec = Melspectrogram()
+
+        # Create a random input tensor (B, C, T) with T = 32767 samples for 2048 ms
+        x = torch.randn(2, 1, 32767)
+
+        # Compute the Melspectrogram
+        y = melspec(x)
+
+        # Check the output shape
+        self.assertEqual(y.shape, (2, 256, 512))
+
+        # Check if the output contains NaN values
+        self.assertFalse(torch.isnan(y).any())
+
+        # Check if the output contains infinite values
+        self.assertFalse(torch.isinf(y).any())
+
+
+if __name__ == "__main__":
+    unittest.main()

utils/README.md

@@ -0,0 +1,22 @@
+# YourMT3: Utils
+
+
+## CachedAudioDataset
+
+```mermaid
+graph TB
+    A[Call __getitem__]:::main --> B1(Update cache):::process
+    A --> B2(Get segments from cache):::process
+    B1 --> C1[Load & cut audio]:::subprocess
+    C1 --> C2[Load & cut note events]:::subprocess
+    C2 --> C3[Augment data]:::subprocess
+    C3 --> C4[Tokenize & pad events]:::subprocess
+    C4 --> C5[Save to cache]:::subprocess
+    B2 --> D1[Return audio segments]:::output
+    B2 --> D2[Return tokens]:::output
+
+    classDef main fill:#FED7E2,stroke:#000000;
+    classDef process fill:#FEE2E2,stroke:#000000;
+    classDef subprocess fill:#E0F0F4,stroke:#000000;
+    classDef output fill:#F0E6EF,stroke:#000000;
+```

utils/audio.py

@@ -0,0 +1,309 @@
+# Copyright 2024 The YourMT3 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
+#
+# Please see the details in the LICENSE file.
+"""audio.py"""
+import os
+import subprocess
+import numpy as np
+import wave
+import math
+from typing import Tuple, List
+from numpy.lib.stride_tricks import as_strided
+
+
+def load_audio_file(filename: str,
+                    seg_start_sec: float = 0.,
+                    seg_length_sec: float = 0.,
+                    fs: int = 16000,
+                    dtype: np.dtype = np.float64) -> np.ndarray:
+    """Load audio file and return the segment of audio."""
+    start_frame_idx = int(np.floor(seg_start_sec * fs))
+    seg_length_frame = int(np.floor(seg_length_sec * fs))
+    end_frame_idx = start_frame_idx + seg_length_frame
+
+    file_ext = filename[-3:]
+
+    if file_ext == 'wav':
+        with wave.open(filename, 'r') as f:
+            f.setpos(start_frame_idx)
+            if seg_length_sec == 0:
+                x = f.readframes(f.getnframes())
+            else:
+                x = f.readframes(end_frame_idx - start_frame_idx)
+
+            if dtype == np.float64:
+                x = np.frombuffer(x, dtype=np.int16) / 2**15
+            elif dtype == np.float32:
+                x = np.frombuffer(x, dtype=np.int16) / 2**15
+                x = x.astype(np.float32)
+            elif dtype == np.int16:
+                x = np.frombuffer(x, dtype=np.int16)
+            elif dtype is None:
+                pass
+            else:
+                raise NotImplementedError(f"Unsupported dtype: {dtype}")
+    else:
+        raise NotImplementedError(f"Unsupported file extension: {file_ext}")
+
+    return x
+
+
+def get_audio_file_info(filename: str) -> Tuple[int, int, int]:
+    """Get audio file info.
+    
+    Args:
+        filename: path to the audio file
+    Returns:
+        fs: sampling rate
+        n_frames: number of frames
+        n_channels: number of channels
+        
+    """
+    file_ext = filename[-3:]
+
+    if file_ext == 'wav':
+        with wave.open(filename, 'r') as f:
+            fs = f.getframerate()
+            n_frames = f.getnframes()
+            n_channels = f.getnchannels()
+    else:
+        raise NotImplementedError(f"Unsupported file extension: {file_ext}")
+
+    return fs, n_frames, n_channels
+
+
+def get_segments_from_numpy_array(arr: np.ndarray,
+                                  slice_length: int,
+                                  start_frame_indices: List[int],
+                                  dtype: np.dtype = np.float32) -> np.ndarray:
+    """Get random audio slices from numpy array.
+    
+    Args:
+        arr: numpy array of shape (c, n_frames)
+        slice_length: length of the slice
+        start_frame_indices: list of m start frames
+    Returns:
+        slices: numpy array of shape (m, c, slice_length)
+    """
+    c, max_length = arr.shape
+    max_length = arr.shape[1]
+    m = len(start_frame_indices)
+
+    slices = np.zeros((m, c, slice_length), dtype=dtype)
+    for i, start_frame in enumerate(start_frame_indices):
+        end_frame = start_frame + slice_length
+        assert (end_frame <= max_length - 1)
+        slices[i, :, :] = arr[:, start_frame:end_frame].astype(dtype)
+    return slices
+
+
+def slice_padded_array(x: np.ndarray, slice_length: int, slice_hop: int, pad: bool = True) -> np.ndarray:
+    """
+    Slices the input array into overlapping windows based on the given slice length and slice hop.
+
+    Args:
+        x: The input array to be sliced.
+        slice_length: The length of each slice.
+        slice_hop: The number of elements between the start of each slice.
+        pad: If True, the last slice will be padded with zeros if necessary.
+
+    Returns:
+        A numpy array with shape (n_slices, slice_length) containing the slices.
+    """
+    num_slices = (x.shape[1] - slice_length) // slice_hop + 1
+    remaining = (x.shape[1] - slice_length) % slice_hop
+
+    if pad and remaining > 0:
+        padding = np.zeros((x.shape[0], slice_length - remaining))
+        x = np.hstack((x, padding))
+        num_slices += 1
+
+    shape: Tuple[int, int] = (num_slices, slice_length)
+    strides: Tuple[int, int] = (slice_hop * x.strides[1], x.strides[1])
+    sliced_x = as_strided(x, shape=shape, strides=strides)
+
+    return sliced_x
+
+
+def slice_padded_array_for_subbatch(x: np.ndarray,
+                                    slice_length: int,
+                                    slice_hop: int,
+                                    pad: bool = True,
+                                    sub_batch_size: int = 1,
+                                    dtype: np.dtype = np.float32) -> np.ndarray:
+    """
+    Slices the input array into overlapping windows based on the given slice length and slice hop,
+    and pads it to make the output divisible by the sub_batch_size.
+
+    NOTE: This method is currently not used.
+    
+    Args:
+        x: The input array to be sliced, such as (1, n_frames).
+        slice_length: The length of each slice.
+        slice_hop: The number of elements between the start of each slice.
+        pad: If True, the last slice will be padded with zeros if necessary.
+        sub_batch_size: The desired number of slices to be divisible by.
+
+    Returns:
+        A numpy array with shape (n_slices, slice_length) containing the slices.
+    """
+    num_slices = (x.shape[1] - slice_length) // slice_hop + 1
+    remaining = (x.shape[1] - slice_length) % slice_hop
+
+    if pad and remaining > 0:
+        padding = np.zeros((x.shape[0], slice_length - remaining), dtype=dtype)
+        x = np.hstack((x, padding))
+        num_slices += 1
+
+    # Adjust the padding to make n_slices divisible by sub_batch_size
+    if pad and num_slices % sub_batch_size != 0:
+        additional_padding_needed = (sub_batch_size - (num_slices % sub_batch_size)) * slice_hop
+        additional_padding = np.zeros((x.shape[0], additional_padding_needed), dtype=dtype)
+        x = np.hstack((x, additional_padding))
+        num_slices += (sub_batch_size - (num_slices % sub_batch_size))
+
+    shape: Tuple[int, int] = (num_slices, slice_length)
+    strides: Tuple[int, int] = (slice_hop * x.strides[1], x.strides[1])
+    sliced_x = as_strided(x, shape=shape, strides=strides)
+
+    return sliced_x
+
+
+def pitch_shift_audio(src_audio_file: os.PathLike,
+                      min_pitch_shift: int = -5,
+                      max_pitch_shift: int = 6,
+                      random_microshift_range: tuple[int, int] = (-10, 11)):
+    """
+    Pitch shift audio file using the Sox command-line tool.
+
+    NOTE: This method is currently not used. Previously, we used this for 
+    offline augmentation for GuitarSet.
+
+    Args:
+        src_audio_file: Path to the input audio file.
+        min_pitch_shift: Minimum pitch shift in semitones.
+        max_pitch_shift: Maximum pitch shift in semitones.
+        random_microshift_range: Range of random microshifts to apply in tenths of a semitone.
+
+    Returns:
+        None
+
+    Raises:
+        CalledProcessError: If the Sox command fails to execute.
+
+    """
+
+    # files
+    src_audio_dir = os.path.dirname(src_audio_file)
+    src_audio_filename = os.path.basename(src_audio_file).split('.')[0]
+
+    # load source audio
+    try:
+        audio = load_audio_file(src_audio_file, dtype=np.int16)
+        audio = audio / 2**15
+        audio = audio.astype(np.float16)
+    except Exception as e:
+        print(f"Failed to load audio file: {src_audio_file}. {e}")
+        return
+
+    # pitch shift audio for each semitone in the range
+    for pitch_shift in range(min_pitch_shift, max_pitch_shift):
+        if pitch_shift == 0:
+            continue
+
+        # pitch shift audio by sox
+        dst_audio_file = os.path.join(src_audio_dir, f'{src_audio_filename}_pshift{pitch_shift}.wav')
+        shift_semitone = 100 * pitch_shift + np.random.randint(*random_microshift_range)
+
+        # build Sox command
+        command = ['sox', src_audio_file, '-r', '16000', dst_audio_file, 'pitch', str(shift_semitone)]
+
+        try:
+            # execute Sox command and check for errors
+            subprocess.run(command, check=True)
+            print(f"Created {dst_audio_file}")
+        except subprocess.CalledProcessError as e:
+            print(f"Failed to pitch shift audio file: {src_audio_file}, pitch_shift: {pitch_shift}. {e}")
+
+
+def write_wav_file(filename: str, x: np.ndarray, samplerate: int = 16000) -> None:
+    """
+    Write a mono PCM WAV file from a NumPy array of audio samples.
+
+    Args:
+        filename (str): The name of the WAV file to be created.
+        x (np.ndarray): A 1D NumPy array containing the audio samples to be written to the WAV file. 
+                        The audio samples should be in the range [-1, 1].
+        samplerate (int): The sample rate (in Hz) of the audio samples.
+
+    Returns:
+        None
+    """
+    # Set the WAV file parameters
+    nchannels = 1  # Mono
+    sampwidth = 2  # 16-bit
+    framerate = samplerate
+    nframes = len(x)
+
+    # Scale the audio samples to the range [-32767, 32767]
+    x_scaled = np.array(x * 32767, dtype=np.int16)
+
+    # Set the buffer size for writing the WAV file
+    BUFFER_SIZE = 1024
+
+    # Open the WAV file for writing
+    with wave.open(filename, "wb") as wav_file:
+        # Set the WAV file parameters
+        wav_file.setparams((nchannels, sampwidth, framerate, nframes, "NONE", "NONE"))
+
+        # Write the audio samples to the file in chunks
+        for i in range(0, len(x_scaled), BUFFER_SIZE):
+            # Get the next chunk of audio samples
+            chunk = x_scaled[i:i + BUFFER_SIZE]
+
+            # Convert the chunk of audio samples to a byte string and write it to the WAV file
+            wav_file.writeframes(chunk.tobytes())
+
+    # Close the WAV file
+    wav_file.close()
+
+
+def guess_onset_offset_by_amp_envelope(x, fs=16000, onset_threshold=0.05, offset_threshold=0.02, frame_size=256):
+    """ Guess onset/offset from audio signal x """
+    amp_env = []
+    num_frames = math.floor(len(x) / frame_size)
+    for t in range(num_frames):
+        lower = t * frame_size
+        upper = (t + 1) * frame_size - 1
+        # Find maximum of each frame and add it to our array
+        amp_env.append(np.max(x[lower:upper]))
+    amp_env = np.array(amp_env)
+    # Find the first index where the amplitude envelope is greater than the threshold
+    onset = np.where(amp_env > onset_threshold)[0][0] * frame_size
+    offset = (len(amp_env) - 1 - np.where(amp_env[::-1] > offset_threshold)[0][0]) * frame_size
+    return onset, offset, amp_env
+
+
+# from pydub import AudioSegment
+# def convert_flac_to_wav(input_path, output_path):
+#     # Load FLAC file using Pydub
+#     sound = AudioSegment.from_file(input_path, format="flac")
+
+#     # Set the parameters for the output WAV file
+#     channels = 1  # mono
+#     sample_width = 2  # 16-bit
+#     frame_rate = 16000
+
+#     # Convert the input sound to the specified format
+#     sound = sound.set_frame_rate(frame_rate)
+#     sound = sound.set_channels(channels)
+#     sound = sound.set_sample_width(sample_width)
+
+#     # Save the output WAV file to the specified path
+#     sound.export(output_path, format="wav")