add checkpoint

ckpt/best.pt.tar

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

ckpt/codec_ckpt/hub/models--facebook--w2v-bert-2.0/config.json

@@ -0,0 +1,81 @@
+{
+  "activation_dropout": 0.0,
+  "adapter_act": "relu",
+  "adapter_kernel_size": 3,
+  "adapter_stride": 2,
+  "add_adapter": false,
+  "apply_spec_augment": false,
+  "architectures": [
+    "Wav2Vec2BertModel"
+  ],
+  "attention_dropout": 0.0,
+  "bos_token_id": 1,
+  "classifier_proj_size": 768,
+  "codevector_dim": 768,
+  "conformer_conv_dropout": 0.1,
+  "contrastive_logits_temperature": 0.1,
+  "conv_depthwise_kernel_size": 31,
+  "ctc_loss_reduction": "sum",
+  "ctc_zero_infinity": false,
+  "diversity_loss_weight": 0.1,
+  "eos_token_id": 2,
+  "feat_proj_dropout": 0.0,
+  "feat_quantizer_dropout": 0.0,
+  "feature_projection_input_dim": 160,
+  "final_dropout": 0.1,
+  "hidden_act": "swish",
+  "hidden_dropout": 0.0,
+  "hidden_size": 1024,
+  "initializer_range": 0.02,
+  "intermediate_size": 4096,
+  "layer_norm_eps": 1e-05,
+  "layerdrop": 0.1,
+  "left_max_position_embeddings": 64,
+  "mask_feature_length": 10,
+  "mask_feature_min_masks": 0,
+  "mask_feature_prob": 0.0,
+  "mask_time_length": 10,
+  "mask_time_min_masks": 2,
+  "mask_time_prob": 0.05,
+  "max_source_positions": 5000,
+  "model_type": "wav2vec2-bert",
+  "num_adapter_layers": 1,
+  "num_attention_heads": 16,
+  "num_codevector_groups": 2,
+  "num_codevectors_per_group": 320,
+  "num_hidden_layers": 24,
+  "num_negatives": 100,
+  "output_hidden_size": 1024,
+  "pad_token_id": 0,
+  "position_embeddings_type": "relative_key",
+  "proj_codevector_dim": 768,
+  "right_max_position_embeddings": 8,
+  "rotary_embedding_base": 10000,
+  "tdnn_dilation": [
+    1,
+    2,
+    3,
+    1,
+    1
+  ],
+  "tdnn_dim": [
+    512,
+    512,
+    512,
+    512,
+    1500
+  ],
+  "tdnn_kernel": [
+    5,
+    3,
+    3,
+    1,
+    1
+  ],
+  "torch_dtype": "float32",
+  "transformers_version": "4.37.0.dev0",
+  "use_intermediate_ffn_before_adapter": false,
+  "use_weighted_layer_sum": false,
+  "vocab_size": null,
+  "xvector_output_dim": 512
+}

ckpt/codec_ckpt/hub/models--facebook--w2v-bert-2.0/preprocessor_config.json

@@ -0,0 +1,11 @@
+{
+  "feature_extractor_type": "SeamlessM4TFeatureExtractor",
+  "feature_size": 80,
+  "num_mel_bins": 80,
+  "padding_side": "right",
+  "padding_value": 1,
+  "processor_class": "Wav2Vec2BertProcessor",
+  "return_attention_mask": true,
+  "sampling_rate": 16000,
+  "stride": 2
+}

ckpt/codec_ckpt/hub/version.txt

@@ -0,0 +1 @@
+1

ckpt/download.sh

@@ -0,0 +1,18 @@
+python download_script.py \
+    --source hf \
+    --repo_id microsoft/wavlm-large \
+    --filename pytorch_model.bin \
+    --save_path ./WavLM-Large.pt
+
+python download_script.py \
+    --source hf \
+    --repo_id facebook/w2v-bert-2.0 \
+    --filename model.safetensors \
+    --save_path \
+    ./codec_ckpt/hub/models--facebook--w2v-bert-2.0/model.safetensors
+
+python download_script.py \
+     --source hf \
+     --repo_id HKUSTAudio/xcodec2 \
+     --filename ckpt/epoch=4-step=1400000.ckpt \
+     --save_path ./codec_ckpt/epoch=4-step=1400000.ckpt

ckpt/download_ckpt.py

@@ -0,0 +1,58 @@
+import os
+import requests
+import argparse
+from huggingface_hub import hf_hub_download
+from tqdm import tqdm
+
+def download_from_url(url, save_path):
+    """Download a file from a given URL and save it locally."""
+    response = requests.get(url, stream=True)
+    total_size = int(response.headers.get("content-length", 0))
+    block_size = 1024  # 1 KB
+    progress_bar = tqdm(total=total_size, unit="B", unit_scale=True)
+
+    with open(save_path, "wb") as file:
+        for data in response.iter_content(block_size):
+            progress_bar.update(len(data))
+            file.write(data)
+    progress_bar.close()
+
+    if total_size != 0 and progress_bar.n != total_size:
+        print("Download failed!")
+    else:
+        print(f"File downloaded to: {save_path}")
+
+def download_from_hf(repo_id, filename, save_path):
+    """Download a file from Hugging Face Hub."""
+    print(f"Downloading from Hugging Face Hub: {repo_id}/{filename}")
+    try:
+        hf_hub_download(repo_id=repo_id, filename=filename, local_dir=os.path.dirname(save_path), local_dir_use_symlinks=False)
+        print(f"File downloaded to: {save_path}")
+    except Exception as e:
+        print(f"Download failed: {e}")
+
+def main():
+    parser = argparse.ArgumentParser(description="Automatically download model checkpoints")
+    parser.add_argument("--source", type=str, required=True, choices=["hf", "url"], help="Download source: hf (Hugging Face Hub) or url (custom URL)")
+    parser.add_argument("--repo_id", type=str, help="Hugging Face model repository ID (e.g., google/bert-base-uncased)")
+    parser.add_argument("--filename", type=str, help="Filename in the Hugging Face repository")
+    parser.add_argument("--url", type=str, help="Custom download URL")
+    parser.add_argument("--save_path", type=str, required=True, help="Path to save the file (including filename)")
+    args = parser.parse_args()
+
+    # Ensure the save directory exists
+    os.makedirs(os.path.dirname(args.save_path), exist_ok=True)
+
+    if args.source == "hf":
+        if not args.repo_id or not args.filename:
+            print("Please provide a Hugging Face repository ID and filename!")
+            return
+        download_from_hf(args.repo_id, args.filename, args.save_path)
+    elif args.source == "url":
+        if not args.url:
+            print("Please provide a download URL!")
+            return
+        download_from_url(args.url, args.save_path)
+
+if __name__ == "__main__":
+    main()

config/test.yml

@@ -0,0 +1,21 @@
+test:
+  checkpoint: ./ckpt/best.pt.tar
+  use_cuda: True
+  infer_feat_too: True
+  inference_time: 1
+
+save:
+  feat_dir: ./decode/feat/se
+  wav_dir: ./decode/wav/se
+
+task: SE
+
+# LLaSE config
+nnet_conf:
+  d_model: 1024
+  nhead: 16
+  num_layers: 16
+  
+datareader:
+  sample_rate: 16000
+  filename: /home/node57_data2/bykang/work_plus/test_set/interspeech2020/syn_no_reverb.scp # /path/to/your/filelist

inference.py

@@ -0,0 +1,474 @@
+import os
+import sys
+import time
+import librosa
+import yaml
+import joblib
+import argparse
+
+import soundfile as sf
+import numpy as np
+
+from pathlib import Path
+from collections import defaultdict
+from typing import Optional
+from tqdm import tqdm
+
+sys.path.append(os.path.dirname(__file__))
+sys.path.append(os.path.dirname(os.path.dirname(__file__)))
+
+# Torch
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.distributed as dist
+from torch.nn.parallel import DistributedDataParallel
+
+# WavLM
+from nnet.WavLM import WavLM, WavLMConfig
+
+# Xcodec2
+from vq.codec_encoder import CodecEncoder_Transformer
+from vq.codec_decoder_vocos import CodecDecoderVocos
+from vq.module import SemanticEncoder
+from transformers import AutoFeatureExtractor, Wav2Vec2BertModel
+from collections import OrderedDict
+
+# Dataloader
+from loader.datareader import DataReader
+from loader.datareader_aec import DataReaderAEC
+from loader.datareader_tse import DataReaderTSE
+
+# LLaSE
+from nnet.llase import LLM_AR as model
+
+class Encodec():
+    '''
+    Load Xcodec2
+    '''
+    def __init__(self,device="cpu") -> None:
+        self.device=device
+        ckpt = "./ckpt/codec_ckpt/epoch=4-step=1400000.ckpt",
+        # ckpt = '/home/bykang/codec_ckpt/epoch=4-step=1400000.ckpt'
+        ckpt = torch.load(ckpt, map_location='cpu')
+        state_dict = ckpt['state_dict']
+        filtered_state_dict_codec = OrderedDict()
+        filtered_state_dict_semantic_encoder = OrderedDict()
+        filtered_state_dict_gen = OrderedDict()
+        filtered_state_dict_fc_post_a = OrderedDict()
+        filtered_state_dict_fc_prior = OrderedDict()
+        for key, value in state_dict.items():
+            if key.startswith('CodecEnc.'):
+                new_key = key[len('CodecEnc.'):]
+                filtered_state_dict_codec[new_key] = value
+            elif key.startswith('generator.'):
+                new_key = key[len('generator.'):]
+                filtered_state_dict_gen[new_key] = value
+            elif key.startswith('fc_post_a.'):
+                new_key = key[len('fc_post_a.'):]
+                filtered_state_dict_fc_post_a[new_key] = value
+            elif key.startswith('SemanticEncoder_module.'):
+                new_key = key[len('SemanticEncoder_module.'):]
+                filtered_state_dict_semantic_encoder[new_key] = value
+            elif key.startswith('fc_prior.'):
+                new_key = key[len('fc_prior.'):]
+                filtered_state_dict_fc_prior[new_key] = value
+        
+        self.semantic_model = Wav2Vec2BertModel.from_pretrained(
+            "./ckpt/codec_ckpt/hub/models--facebook--w2v-bert-2.0",
+            # "/home/bykang/codec_ckpt/hub/models--facebook--w2v-bert-2.0/snapshots/da985ba0987f70aaeb84a80f2851cfac8c697a7b",
+            output_hidden_states=True)
+        self.semantic_model=self.semantic_model.eval().to(self.device)
+        
+        self.SemanticEncoder_module = SemanticEncoder(1024,1024,1024)
+        self.SemanticEncoder_module.load_state_dict(filtered_state_dict_semantic_encoder)
+        self.SemanticEncoder_module = self.SemanticEncoder_module.eval().to(self.device)
+
+        self.encoder = CodecEncoder_Transformer()
+        self.encoder.load_state_dict(filtered_state_dict_codec)
+        self.encoder = self.encoder.eval().to(self.device)
+
+        self.decoder = CodecDecoderVocos()
+        self.decoder.load_state_dict(filtered_state_dict_gen)
+        self.decoder = self.decoder.eval().to(self.device)
+
+        self.fc_post_a = nn.Linear( 2048, 1024 )
+        self.fc_post_a.load_state_dict(filtered_state_dict_fc_post_a)
+        self.fc_post_a = self.fc_post_a.eval().to(self.device)
+
+        self.fc_prior = nn.Linear( 2048, 2048 )
+        self.fc_prior.load_state_dict(filtered_state_dict_fc_prior)
+        self.fc_prior = self.fc_prior.eval().to(self.device)
+
+        self.feature_extractor = AutoFeatureExtractor.from_pretrained(
+            "./ckpt/codec_ckpt/hub/models--facebook--w2v-bert-2.0")
+            # "/home/bykang/codec_ckpt/hub/models--facebook--w2v-bert-2.0/snapshots/da985ba0987f70aaeb84a80f2851cfac8c697a7b")
+    
+    def get_feat(self, wav_batch, pad=None):
+
+        if len(wav_batch.shape) != 2:
+            return self.feature_extractor(F.pad(wav_batch, pad), sampling_rate=16000, return_tensors="pt") .data['input_features']
+        
+        padded_wavs = torch.stack([F.pad(wav, pad) for wav in wav_batch])
+        batch_feats = []
+
+        for wav in padded_wavs:
+            feat = self.feature_extractor(
+                wav,
+                sampling_rate=16000,
+                return_tensors="pt"
+            ).data['input_features']
+
+            batch_feats.append(feat)
+        feat_batch = torch.concat(batch_feats, dim=0).to(self.device)
+        return feat_batch 
+
+    def get_embedding(self, wav_cpu):
+        wav_cpu = wav_cpu.cpu()
+        feat = self.get_feat(wav_cpu,pad=(160,160))
+        feat = feat.to(self.device)
+
+        if(len(wav_cpu.shape)==1):
+            wav = wav_cpu.unsqueeze(0).to(self.device)
+        else:
+            wav = wav_cpu.to(self.device)
+
+        wav = torch.nn.functional.pad(wav, (0, (200 - (wav.shape[1] % 200))))
+        with torch.no_grad():
+            vq_emb = self.encoder(wav.unsqueeze(1))
+            vq_emb = vq_emb.transpose(1, 2) 
+
+            if vq_emb.shape[2]!=feat.shape[1]:
+                feat = self.get_feat(wav_cpu)
+                feat = feat.to(self.device)
+
+            semantic_target = self.semantic_model(feat[:,  :,:])
+            semantic_target = semantic_target.hidden_states[16]
+            semantic_target = semantic_target.transpose(1, 2)
+            semantic_target = self.SemanticEncoder_module(semantic_target)
+
+            vq_emb = torch.cat([semantic_target, vq_emb], dim=1)
+
+        return vq_emb
+    
+    def emb2token(self, emb):
+        emb.to(self.device)
+        emb =  self.fc_prior(emb.transpose(1, 2)).transpose(1, 2)
+        _, vq_code, _ = self.decoder(emb, vq=True)
+        return vq_code
+
+    def token2wav(self, vq_code):
+        vq_code.to(self.device)
+        vq_post_emb = self.decoder.quantizer.get_output_from_indices(vq_code.transpose(1, 2))
+        vq_post_emb = vq_post_emb.transpose(1, 2)
+        vq_post_emb = self.fc_post_a(vq_post_emb.transpose(1,2)).transpose(1,2)
+        recon = self.decoder(vq_post_emb.transpose(1, 2), vq=False)[0].squeeze()
+        # if write the wav, add .squeeze().detach().cpu().numpy()
+        # if need gradient use the config right now
+        return recon
+
+class WavLM_feat(object):
+    '''
+    Load WavLM
+    '''
+    def __init__(self, device):
+        self.wavlm = self._reload_wavLM_large(device=device)
+
+    def __call__(self, wav):
+        T = wav.shape[-1]
+        wav = wav.reshape(-1, T)
+        with torch.no_grad():
+            feat = self.wavlm.extract_features(wav, output_layer=6, ret_layer_results=False)[0]
+            B, T, D = feat.shape
+            feat = torch.reshape(feat, (-1, D))
+
+            return feat
+
+    def _reload_wavLM_large(self, path="/home/bykang/WavLM-Large.pt", device: Optional[torch.device] = None):
+        cpt = torch.load(path, map_location="cpu")
+        cfg = WavLMConfig(cpt['cfg'])
+        wavLM = WavLM(cfg)
+        wavLM.load_state_dict(cpt['model'])
+        wavLM.eval()
+        if device != None:
+            wavLM = wavLM.to(device)
+        for p in wavLM.parameters():
+            p.requires_grad = False
+        print('successful to reload wavLM', path)
+        return wavLM 
+
+def get_firstchannel_read(path, fs=16000):
+    '''
+    Get first channel of the wav
+    '''
+    wave_data, sr = sf.read(path)
+    if sr != fs:
+        if len(wave_data.shape) != 1:
+            wave_data = wave_data.transpose((1, 0))
+        wave_data = librosa.resample(wave_data, orig_sr=sr, target_sr=fs)
+        if len(wave_data.shape) != 1:
+            wave_data = wave_data.transpose((1, 0))
+    if len(wave_data.shape) > 1:
+        wave_data = wave_data[:, 0]
+    return wave_data
+
+def load_obj(obj, device):
+    '''
+    Offload tensor object in obj to cuda device
+    '''
+    def cuda(obj):
+        return obj.to(device) if isinstance(obj, torch.Tensor) else obj
+    
+    if isinstance(obj, dict):
+        return {key: load_obj(obj[key], device) for key in obj}
+    elif isinstance(obj, list):
+        return [load_obj(val, device) for val in obj]
+    else:
+        return cuda(obj)
+
+def run(args):
+    LOCAL_RANK = int(os.environ['LOCAL_RANK'])
+    WORLD_SIZE = int(os.environ['WORLD_SIZE'])
+    WORLD_RANK = int(os.environ['RANK'])    
+    dist.init_process_group(args.backend, rank=WORLD_RANK, world_size=WORLD_SIZE)    
+    torch.cuda.set_device(LOCAL_RANK)
+    device = torch.device('cuda', LOCAL_RANK)
+    print(f"[{os.getpid()}] using device: {device}", torch.cuda.current_device(), "local rank", LOCAL_RANK)
+
+    with open(args.conf, "r") as f:
+        conf = yaml.load(f, Loader=yaml.FullLoader)
+
+    # Dataloader
+    if conf["task"]=="AEC":
+        data_reader = DataReaderAEC(**conf["datareader"])
+    elif conf["task"]=="TSE":
+        data_reader = DataReaderTSE(**conf["datareader"])
+    else:
+        data_reader = DataReader(**conf["datareader"])
+
+    # Load WavLM and XCodec2
+    codec = Encodec(device)
+    wavlm_feat = WavLM_feat(device)
+
+    # Load LLaSE
+    nnet = model(**conf["nnet_conf"])
+    cpt_fname = Path(conf["test"]["checkpoint"])
+    cpt = torch.load(cpt_fname, map_location="cpu")
+
+    nnet = nnet.to(device)
+    nnet = DistributedDataParallel(nnet, device_ids=[LOCAL_RANK], output_device=LOCAL_RANK, find_unused_parameters=True) 
+    nnet.load_state_dict(cpt["model_state_dict"])
+    nnet.eval()
+
+    # Make sure the dir exists
+    if conf["task"]=="AEC":
+        if not os.path.exists(conf["save"]["feat_dir"]+"/mic"):
+            os.makedirs(conf["save"]["feat_dir"]+"/mic")
+        if not os.path.exists(conf["save"]["feat_dir"]+"/ref"):
+            os.makedirs(conf["save"]["feat_dir"]+"/ref")
+    elif conf["task"]=="TSE":
+        if not os.path.exists(conf["save"]["feat_dir"]+"/mic"):
+            os.makedirs(conf["save"]["feat_dir"]+"/mic")
+        if not os.path.exists(conf["save"]["feat_dir"]+"/ref"):
+            os.makedirs(conf["save"]["feat_dir"]+"/ref")
+    else:
+        if not os.path.exists(conf["save"]["feat_dir"]):
+            os.makedirs(conf["save"]["feat_dir"])
+            
+    if not os.path.exists(conf["save"]["wav_dir"]):
+        os.makedirs(conf["save"]["wav_dir"])      
+
+    # Main of inference
+    if_feat_too = conf["test"]["infer_feat_too"]
+
+    origin_feat_dir = conf["save"]["feat_dir"]
+    origin_wav_dir = conf["save"]["wav_dir"]
+    
+    last_feat_dir = origin_feat_dir
+    last_wav_dir = origin_wav_dir
+
+    for inference_time in range(conf["test"]["inference_time"]):
+        # For multi-inference
+        if inference_time > 0:
+            feat_dir = origin_feat_dir + "inference" + str(inference_time) 
+            wav_dir = origin_wav_dir + "inference" + str(inference_time) 
+        else:
+            feat_dir = origin_feat_dir
+            wav_dir = origin_wav_dir
+            
+        if not os.path.exists(feat_dir):
+            os.makedirs(feat_dir)
+        if not os.path.exists(wav_dir):
+            os.makedirs(wav_dir)
+
+        with torch.no_grad():
+            # Extract WavLM features
+            if if_feat_too ==True or inference_time>0:
+                for egs in tqdm(data_reader):
+                    egs = load_obj(egs, device)
+                    
+                    if conf["task"]=="AEC" or conf["task"]=="TSE":
+                        if inference_time > 0:
+                            mic_path = last_wav_dir + '/' + egs["mic_name"] + ".wav"
+                            egs["mic"] = torch.from_numpy(get_firstchannel_read(mic_path).astype(np.float32)).unsqueeze(0).to(device)
+                        else:
+                            egs["mic"]=egs["mic"].contiguous()                            
+                        egs["ref"]=egs["ref"].contiguous()
+
+                        feat_mic = wavlm_feat(egs["mic"])
+                        out_mic = feat_mic.detach().squeeze(0).cpu().numpy()
+                        
+                        if not os.path.exists(os.path.join(feat_dir, "mic")):
+                            os.makedirs(os.path.join(feat_dir, "mic"))    
+                        np.save(os.path.join(feat_dir, "mic", egs["mic_name"]), out_mic)
+                        
+                        # For AEC and TSE, reference audio only need to extract feats at first time
+                        if inference_time == 0:
+                            feat_ref = wavlm_feat(egs["ref"])
+                            out_ref = feat_ref.detach().squeeze(0).cpu().numpy()
+                            np.save(os.path.join(origin_feat_dir, "ref", egs["ref_name"]), out_ref)
+
+                        torch.cuda.empty_cache()
+
+                    else:
+                        if inference_time > 0:
+                            mix_path = last_wav_dir + '/' + egs["name"] + ".wav"
+                            egs["mix"] = torch.from_numpy(get_firstchannel_read(mix_path).astype(np.float32)).unsqueeze(0).to(device)
+                        else:
+                            egs["mix"]=egs["mix"].contiguous()
+                        
+                        feat = wavlm_feat(egs["mix"])
+                        out = feat.detach().squeeze(0).cpu().numpy()
+                        np.save(os.path.join(feat_dir, egs["name"]), out)
+            
+            # Predict the clean tokens and token2wav
+            for egs in tqdm(data_reader):
+                egs = load_obj(egs, device)
+                sr = 16000
+                
+                if conf["task"] == "AEC":
+                    # Get feat
+                    feat_path_mic = os.path.join(feat_dir, "mic", egs["mic_name"]) + ".npy" 
+                    feat_path_ref = os.path.join(origin_feat_dir, "ref", egs["ref_name"]) + ".npy"
+
+                    feat_mic = torch.from_numpy(np.load(feat_path_mic)).unsqueeze(0)
+                    feat_ref = torch.from_numpy(np.load(feat_path_ref)).unsqueeze(0)
+
+                    # For multi-inference
+                    if inference_time > 0:
+                        est = nnet(feat_mic)
+                    else:
+                        est = nnet(feat_mic, feat_ref)
+
+                    # Get tokens and token2wav
+                    max, max_indices_1 = torch.max(est[1], dim=1)
+                    recon_1 = codec.token2wav(max_indices_1.unsqueeze(0)).squeeze().detach().cpu().numpy()
+
+                    # Save the wav
+                    target_path = os.path.join(wav_dir, egs["mic_name"] + ".wav")
+                    print(target_path)
+                    sf.write(target_path , recon_1, sr)   
+                    
+                elif conf["task"] == "TSE" :
+                    # Get feat
+                    feat_path_mic = os.path.join(feat_dir, "mic", egs["mic_name"]) + ".npy" 
+                    feat_path_ref = os.path.join(origin_feat_dir, "ref", egs["ref_name"]) + ".npy"
+
+                    feat_mic = torch.from_numpy(np.load(feat_path_mic)).unsqueeze(0)
+                    feat_ref = torch.from_numpy(np.load(feat_path_ref)).unsqueeze(0)
+
+                    # Choose if keep the enroallment audio while multi-inference
+                    if_keep_ref = True
+
+                    if inference_time>0 and if_keep_ref== False:
+                        est = nnet(feat_mic)
+                    else:
+                        est = nnet(feat_mic, feat_ref)
+                    
+                    # Get tokens and token2wav
+                    max, max_indices_1 = torch.max(est[0], dim=1)
+                    recon_1 = codec.token2wav(max_indices_1.unsqueeze(0)).squeeze().detach().cpu().numpy()
+
+                    # Save the wav
+                    target_path = os.path.join(wav_dir, egs["mic_name"] + ".wav")
+                    print(target_path)
+                    sf.write(target_path , recon_1, sr) 
+                    
+                elif conf["task"] == "PLC":
+                    # Get feat
+                    feat_path = os.path.join(feat_dir, egs["name"]) + ".npy" 
+                    feat = torch.from_numpy(np.load(feat_path)).unsqueeze(0)
+
+                    # Get tokens and token2wav
+                    est = nnet(feat)
+                    max, max_indices_1 = torch.max(est[1], dim=1)
+                    recon_1 = codec.token2wav(max_indices_1.unsqueeze(0)).squeeze().detach().cpu().numpy()
+
+                    # Save the wav
+                    target_path = os.path.join(wav_dir, egs["name"] + ".wav")
+                    print(target_path)
+                    sf.write(target_path , recon_1, sr)
+                    
+                elif conf["task"] == "SS":
+                    # Get feat
+                    feat_path = os.path.join(feat_dir, egs["name"]) + ".npy" 
+                    feat = torch.from_numpy(np.load(feat_path)).unsqueeze(0)
+                    
+                    # Separate the first speaker
+                    est = nnet(feat)
+                    max, max_indices_1 = torch.max(est[1], dim=1)
+                    recon_1 = codec.token2wav(max_indices_1.unsqueeze(0)).squeeze().detach().cpu().numpy()
+
+                    target_path_1 = os.path.join(wav_dir, egs["name"] + ".wav")
+                    sf.write(target_path_1 , recon_1, sr)
+                    
+                    # Separate the second speaker, SS need at least 2 inference time in config
+                    if inference_time > 0:
+                        origin_feat_path = os.path.join(origin_feat_dir, egs["name"]) + ".npy"
+                        origin_feat = torch.from_numpy(np.load(origin_feat_path)).unsqueeze(0)
+                        
+                        est2 = nnet(origin_feat, feat)
+                        max, max_indices_2 = torch.max(est2[1], dim=1)
+                        recon_2 = codec.token2wav(max_indices_2.unsqueeze(0)).squeeze().detach().cpu().numpy()
+                    
+                        if not os.path.exists(last_wav_dir + "s2"):
+                            os.makedirs(last_wav_dir + "s2")
+                    
+                        target_path_2 = os.path.join(last_wav_dir + "s2", egs["name"] + ".wav")
+                        sf.write(target_path_2 , recon_2, sr)
+                    
+                else:
+                    # Get feat
+                    feat_path = os.path.join(feat_dir, egs["name"]) + ".npy" 
+                    feat = torch.from_numpy(np.load(feat_path)).unsqueeze(0)
+                    
+                    # Get tokens and token2wav
+                    est = nnet(feat)
+                    max, max_indices_1 = torch.max(est[1], dim=1)
+                    recon_1 = codec.token2wav(max_indices_1.unsqueeze(0)).squeeze().detach().cpu().numpy()
+
+                    # Save the wav
+                    target_path = os.path.join(wav_dir, egs["name"] + ".wav")
+                    print(target_path)
+                    sf.write(target_path , recon_1, sr)        
+
+        # For next inference
+        last_feat_dir = feat_dir
+        last_wav_dir = wav_dir
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description = "Command to test separation model in Pytorch",
+        formatter_class = argparse.ArgumentDefaultsHelpFormatter)
+    parser.add_argument("-conf",
+                        type=str,
+                        required=True,
+                        help="Yaml configuration file for training")
+    parser.add_argument("--backend",
+                        type=str,
+                        default="nccl",
+                        choices=["nccl", "gloo"])                          
+    args = parser.parse_args()    
+    # for nccl debug
+    os.environ["NCCL_DEBUG"] = "INFO"
+    run(args)

inference.sh

@@ -0,0 +1,6 @@
+CUDA_VISIBLE_DEVICES=1 torchrun \
+     --nnodes=1 \
+     --nproc_per_node=1 \
+     --master_port=21547 \
+     inference.py \
+     -conf ./config/test.yml

loader/datareader.py

@@ -0,0 +1,65 @@
+import numpy as np
+import torchaudio
+import torch
+
+def get_firstchannel_read(path, fs=16000):
+    wave_data, sr = torchaudio.load(path)
+    if sr != fs:
+        wave_data = torchaudio.functional.resample(wave_data, sr, fs)
+    if len(wave_data.shape) > 1:
+        wave_data = wave_data[0,...]
+    wave_data = wave_data.cpu().numpy()
+    return wave_data
+
+def parse_scp(scp, path_list):
+    with open(scp) as fid: 
+        for line in fid:
+            tmp = line.strip().split()
+            if len(tmp) > 1:
+                path_list.append({"inputs": tmp[0], "duration": tmp[1]})
+            else:
+                path_list.append({"inputs": tmp[0]})
+
+class DataReader(object):
+    def __init__(self, filename, sample_rate): 
+        self.file_list = []
+        self.sample_rate = sample_rate
+        parse_scp(filename, self.file_list)
+
+    def extract_feature(self, path):
+        path = path["inputs"]
+        name = path.split("/")[-1].split(".")[0]
+        data = get_firstchannel_read(path, fs=self.sample_rate).astype(np.float32)
+        max_norm = np.max(np.abs(data))
+        if max_norm == 0:
+            max_norm = 1      
+        data = data / max_norm
+        inputs = np.reshape(data, [1, data.shape[0]])
+        inputs = torch.from_numpy(inputs)
+
+        egs = {
+            "mix": inputs,
+            "max_norm": max_norm,
+            "name": name
+        }
+        return egs
+
+    def __len__(self):
+        return len(self.file_list)
+
+    def __getitem__(self, index):
+        return self.extract_feature(self.file_list[index])
+
+    def get_utt2spk(self, path):
+        lines = open(path, "r").readlines()
+        for line in lines:
+            line = line.strip().split()
+            utt_path, spk_id = line[0], line[1]
+            self.utt2spk[utt_path] = spk_id
+    
+    def get_spk2utt(self, path):
+        lines = open(path, "r").readlines()
+        for line in lines:
+            line = line.strip().split()
+            utt_path, spk_id = line[0], line[1]
+            self.spk2aux[spk_id] = utt_path

loader/datareader_aec.py

@@ -0,0 +1,86 @@
+import librosa
+import torch as th
+import numpy as np
+import soundfile as sf
+
+import sys, os
+sys.path.append(os.path.dirname(__file__))
+# from speex_linear.lp_or_tde import LP_or_TDE
+
+
+def audio(path, fs=16000):
+    wave_data, sr = sf.read(path)
+    if sr != fs:
+        wave_data = librosa.resample(wave_data, orig_sr=sr, target_sr=fs)
+    return wave_data
+
+def get_firstchannel_read(path, fs=16000):
+    wave_data, sr = sf.read(path)
+    if sr != fs:
+        if len(wave_data.shape) != 1:
+            wave_data = wave_data.transpose((1, 0))
+        wave_data = librosa.resample(wave_data, orig_sr=sr, target_sr=fs)
+        if len(wave_data.shape) != 1:
+            wave_data = wave_data.transpose((1, 0))
+    if len(wave_data.shape) > 1:
+        wave_data = wave_data[:, 0]
+    return wave_data
+
+def parse_scp(scp, path_list):
+    with open(scp) as fid: 
+        for line in fid:
+            tmp = line.strip().split()
+            if len(tmp) > 1:
+                path_list.append({"inputs": tmp[0], "duration": tmp[1]})
+            else:
+                path_list.append({"inputs": tmp[0]})
+
+class DataReaderAEC(object):
+    def __init__(self, filename, sample_rate): #, aux_segment): # filename是不带id的待解码音频，noisy_id是带id的带解码音频，clean是带id的注册音频
+        self.file_list = []
+        parse_scp(filename, self.file_list)
+        self.sample_rate = sample_rate
+
+        # self.aux_segment_length = aux_segment * sample_rate
+
+    def extract_feature(self, path):
+        mic_path = path["inputs"]
+        utt_id = mic_path.split("/")[-1]
+        mic_name = mic_path.split("/")[-1].split(".")[0]
+
+        ref_path = mic_path.replace("mic.wav", "lpb.wav")
+        ref_name = ref_path.split("/")[-1].split(".")[0]
+
+        mic = get_firstchannel_read(mic_path, self.sample_rate).astype(np.float32)
+        ref = get_firstchannel_read(ref_path, self.sample_rate).astype(np.float32)
+        
+        min_len = min(mic.shape[0], ref.shape[0])
+        mic = mic[:min_len]
+        ref = ref[:min_len]
+
+        inputs_mic = np.reshape(mic, [1, mic.shape[0]])
+        inputs_ref = np.reshape(ref, [1, ref.shape[0]]).astype(np.float32)
+        
+        
+        inputs_mic = th.from_numpy(inputs_mic)
+        inputs_ref = th.from_numpy(inputs_ref)
+        
+        # print(f'e: {inputs_e.shape}')
+        # print(f'mic: {inputs_mic.shape}')
+        # print(f'ref: {inputs_ref.shape}')
+
+        egs = {
+            "mic": inputs_mic,
+            "ref": inputs_ref, 
+            "utt_id": utt_id,
+            "mic_name": mic_name,
+            "ref_name": ref_name
+            # "max_norm": max_norm
+        }
+        return egs
+
+    def __len__(self):
+        return len(self.file_list)
+
+    def __getitem__(self, index):
+        return self.extract_feature(self.file_list[index])

loader/datareader_tse.py

@@ -0,0 +1,85 @@
+import librosa
+import torch as th
+import numpy as np
+import soundfile as sf
+
+import sys, os
+sys.path.append(os.path.dirname(__file__))
+# from speex_linear.lp_or_tde import LP_or_TDE
+
+def audio(path, fs=16000):
+    wave_data, sr = sf.read(path)
+    if sr != fs:
+        wave_data = librosa.resample(wave_data, orig_sr=sr, target_sr=fs)
+    return wave_data
+
+def get_firstchannel_read(path, fs=16000):
+    wave_data, sr = sf.read(path)
+    if sr != fs:
+        if len(wave_data.shape) != 1:
+            wave_data = wave_data.transpose((1, 0))
+        wave_data = librosa.resample(wave_data, orig_sr=sr, target_sr=fs)
+        if len(wave_data.shape) != 1:
+            wave_data = wave_data.transpose((1, 0))
+    if len(wave_data.shape) > 1:
+        wave_data = wave_data[:, 0]
+    return wave_data
+
+def parse_scp(scp, path_list):
+    with open(scp) as fid: 
+        for line in fid:
+            tmp = line.strip().split()
+            if len(tmp) > 1:
+                path_list.append({"inputs": tmp[0], "duration": tmp[1]})
+            else:
+                path_list.append({"inputs": tmp[0]})
+
+class DataReaderTSE(object):
+    def __init__(self, filename, sample_rate):  # filename是不带id的待解码音频，noisy_id是带id的带解码音频，clean是带id的注册音频
+        self.file_list = []
+        parse_scp(filename, self.file_list)
+        self.sample_rate = sample_rate
+
+    def extract_feature(self, path):
+        mic_path = path["inputs"]
+        utt_id = mic_path.split("/")[-1]
+        mic_name = mic_path.split("/")[-1].split(".")[0]
+
+        ref_path = mic_path.replace("noisy/", "enrol/")
+        ref_name = ref_path.split("/")[-1].split(".")[0]
+
+        mic = get_firstchannel_read(mic_path, self.sample_rate).astype(np.float32)
+        ref = get_firstchannel_read(ref_path, self.sample_rate).astype(np.float32)
+        
+        if ref.shape[0] > mic.shape[0]:
+            min_len = mic.shape[0]
+            ref = ref[:min_len]
+            
+        # print(ref.shape[0])
+        # print(mic.shape[0])
+
+        inputs_mic = np.reshape(mic, [1, mic.shape[0]]).astype(np.float32)
+        inputs_ref = np.reshape(ref, [1, ref.shape[0]]).astype(np.float32)
+        
+        inputs_mic = th.from_numpy(inputs_mic)
+        inputs_ref = th.from_numpy(inputs_ref)
+        
+        # print(f'e: {inputs_e.shape}')
+        # print(f'mic: {inputs_mic.shape}')
+        # print(f'ref: {inputs_ref.shape}')
+
+        egs = {
+            "mic": inputs_mic,
+            "ref": inputs_ref, 
+            "utt_id": utt_id,
+            "mic_name": mic_name,
+            "ref_name": ref_name
+            # "max_norm": max_norm
+        }
+        return egs
+
+    def __len__(self):
+        return len(self.file_list)
+
+    def __getitem__(self, index):
+        return self.extract_feature(self.file_list[index])

nnet/WavLM.py

@@ -0,0 +1,793 @@
+# --------------------------------------------------------
+# WavLM: Large-Scale Self-Supervised  Pre-training  for Full Stack Speech Processing (https://arxiv.org/abs/2110.13900.pdf)
+# Github source: https://github.com/microsoft/unilm/tree/master/wavlm
+# Copyright (c) 2021 Microsoft
+# Licensed under The MIT License [see LICENSE for details]
+# Based on fairseq code bases
+# https://github.com/pytorch/fairseq
+# --------------------------------------------------------
+
+import math
+import logging
+from typing import List, Optional, Tuple
+
+import sys,os
+sys.path.append(os.path.dirname(sys.path[0]))
+import numpy as np
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.nn import LayerNorm
+from nnet.modules import (
+    Fp32GroupNorm,
+    Fp32LayerNorm,
+    GradMultiply,
+    MultiheadAttention,
+    SamePad,
+    init_bert_params,
+    get_activation_fn,
+    TransposeLast,
+    GLU_Linear,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def compute_mask_indices(
+    shape: Tuple[int, int],
+    padding_mask: Optional[torch.Tensor],
+    mask_prob: float,
+    mask_length: int,
+    mask_type: str = "static",
+    mask_other: float = 0.0,
+    min_masks: int = 0,
+    no_overlap: bool = False,
+    min_space: int = 0,
+) -> np.ndarray:
+    """
+    Computes random mask spans for a given shape
+
+    Args:
+        shape: the the shape for which to compute masks.
+            should be of size 2 where first element is batch size and 2nd is timesteps
+        padding_mask: optional padding mask of the same size as shape, which will prevent masking padded elements
+        mask_prob: probability for each token to be chosen as start of the span to be masked. this will be multiplied by
+            number of timesteps divided by length of mask span to mask approximately this percentage of all elements.
+            however due to overlaps, the actual number will be smaller (unless no_overlap is True)
+        mask_type: how to compute mask lengths
+            static = fixed size
+            uniform = sample from uniform distribution [mask_other, mask_length*2]
+            normal = sample from normal distribution with mean mask_length and stdev mask_other. mask is min 1 element
+            poisson = sample from possion distribution with lambda = mask length
+        min_masks: minimum number of masked spans
+        no_overlap: if false, will switch to an alternative recursive algorithm that prevents spans from overlapping
+        min_space: only used if no_overlap is True, this is how many elements to keep unmasked between spans
+    """
+
+    bsz, all_sz = shape
+    mask = np.full((bsz, all_sz), False)
+
+    all_num_mask = int(
+        # add a random number for probabilistic rounding
+        mask_prob * all_sz / float(mask_length)
+        + np.random.rand()
+    )
+
+    all_num_mask = max(min_masks, all_num_mask)
+
+    mask_idcs = []
+    for i in range(bsz):
+        if padding_mask is not None:
+            sz = all_sz - padding_mask[i].long().sum().item()
+            num_mask = int(
+                # add a random number for probabilistic rounding
+                mask_prob * sz / float(mask_length)
+                + np.random.rand()
+            )
+            num_mask = max(min_masks, num_mask)
+        else:
+            sz = all_sz
+            num_mask = all_num_mask
+
+        if mask_type == "static":
+            lengths = np.full(num_mask, mask_length)
+        elif mask_type == "uniform":
+            lengths = np.random.randint(mask_other, mask_length * 2 + 1, size=num_mask)
+        elif mask_type == "normal":
+            lengths = np.random.normal(mask_length, mask_other, size=num_mask)
+            lengths = [max(1, int(round(x))) for x in lengths]
+        elif mask_type == "poisson":
+            lengths = np.random.poisson(mask_length, size=num_mask)
+            lengths = [int(round(x)) for x in lengths]
+        else:
+            raise Exception("unknown mask selection " + mask_type)
+
+        if sum(lengths) == 0:
+            lengths[0] = min(mask_length, sz - 1)
+
+        if no_overlap:
+            mask_idc = []
+
+            def arrange(s, e, length, keep_length):
+                span_start = np.random.randint(s, e - length)
+                mask_idc.extend(span_start + i for i in range(length))
+
+                new_parts = []
+                if span_start - s - min_space >= keep_length:
+                    new_parts.append((s, span_start - min_space + 1))
+                if e - span_start - keep_length - min_space > keep_length:
+                    new_parts.append((span_start + length + min_space, e))
+                return new_parts
+
+            parts = [(0, sz)]
+            min_length = min(lengths)
+            for length in sorted(lengths, reverse=True):
+                lens = np.fromiter(
+                    (e - s if e - s >= length + min_space else 0 for s, e in parts),
+                    np.int,
+                )
+                l_sum = np.sum(lens)
+                if l_sum == 0:
+                    break
+                probs = lens / np.sum(lens)
+                c = np.random.choice(len(parts), p=probs)
+                s, e = parts.pop(c)
+                parts.extend(arrange(s, e, length, min_length))
+            mask_idc = np.asarray(mask_idc)
+        else:
+            min_len = min(lengths)
+            if sz - min_len <= num_mask:
+                min_len = sz - num_mask - 1
+
+            mask_idc = np.random.choice(sz - min_len, num_mask, replace=False)
+
+            mask_idc = np.asarray(
+                [
+                    mask_idc[j] + offset
+                    for j in range(len(mask_idc))
+                    for offset in range(lengths[j])
+                ]
+            )
+
+        mask_idcs.append(np.unique(mask_idc[mask_idc < sz]))
+
+    min_len = min([len(m) for m in mask_idcs])
+    for i, mask_idc in enumerate(mask_idcs):
+        if len(mask_idc) > min_len:
+            mask_idc = np.random.choice(mask_idc, min_len, replace=False)
+        mask[i, mask_idc] = True
+
+    return mask
+
+
+class WavLMConfig:
+    def __init__(self, cfg=None):
+        self.extractor_mode: str = "default"     # mode for feature extractor. default has a single group norm with d groups in the first conv block, whereas layer_norm has layer norms in every block (meant to use with normalize=True)
+        self.encoder_layers: int = 12     # num encoder layers in the transformer
+
+        self.encoder_embed_dim: int = 768     # encoder embedding dimension
+        self.encoder_ffn_embed_dim: int = 3072     # encoder embedding dimension for FFN
+        self.encoder_attention_heads: int = 12     # num encoder attention heads
+        self.activation_fn: str = "gelu"     # activation function to use
+
+        self.layer_norm_first: bool = False     # apply layernorm first in the transformer
+        self.conv_feature_layers: str = "[(512,10,5)] + [(512,3,2)] * 4 + [(512,2,2)] * 2"     # string describing convolutional feature extraction layers in form of a python list that contains [(dim, kernel_size, stride), ...]
+        self.conv_bias: bool = False     # include bias in conv encoder
+        self.feature_grad_mult: float = 1.0     # multiply feature extractor var grads by this
+
+        self.normalize: bool = False  # normalize input to have 0 mean and unit variance during training
+
+        # dropouts
+        self.dropout: float = 0.1     # dropout probability for the transformer
+        self.attention_dropout: float = 0.1     # dropout probability for attention weights
+        self.activation_dropout: float = 0.0     # dropout probability after activation in FFN
+        self.encoder_layerdrop: float = 0.0     # probability of dropping a tarnsformer layer
+        self.dropout_input: float = 0.0     # dropout to apply to the input (after feat extr)
+        self.dropout_features: float = 0.0     # dropout to apply to the features (after feat extr)
+
+        # masking
+        self.mask_length: int = 10     # mask length
+        self.mask_prob: float = 0.65     # probability of replacing a token with mask
+        self.mask_selection: str = "static"     # how to choose mask length
+        self.mask_other: float = 0     # secondary mask argument (used for more complex distributions), see help in compute_mask_indicesh
+        self.no_mask_overlap: bool = False     # whether to allow masks to overlap
+        self.mask_min_space: int = 1     # min space between spans (if no overlap is enabled)
+
+        # channel masking
+        self.mask_channel_length: int = 10     # length of the mask for features (channels)
+        self.mask_channel_prob: float = 0.0     # probability of replacing a feature with 0
+        self.mask_channel_selection: str = "static"     # how to choose mask length for channel masking
+        self.mask_channel_other: float = 0     # secondary mask argument (used for more complex distributions), see help in compute_mask_indices
+        self.no_mask_channel_overlap: bool = False     # whether to allow channel masks to overlap
+        self.mask_channel_min_space: int = 1     # min space between spans (if no overlap is enabled)
+
+        # positional embeddings
+        self.conv_pos: int = 128     # number of filters for convolutional positional embeddings
+        self.conv_pos_groups: int = 16     # number of groups for convolutional positional embedding
+
+        # relative position embedding
+        self.relative_position_embedding: bool = False     # apply relative position embedding
+        self.num_buckets: int = 320     # number of buckets for relative position embedding
+        self.max_distance: int = 1280     # maximum distance for relative position embedding
+        self.gru_rel_pos: bool = False     # apply gated relative position embedding
+
+        if cfg is not None:
+            self.update(cfg)
+
+    def update(self, cfg: dict):
+        self.__dict__.update(cfg)
+
+
+class WavLM(nn.Module):
+    def __init__(
+        self,
+        cfg: WavLMConfig,
+    ) -> None:
+        super().__init__()
+        logger.info(f"WavLM Config: {cfg.__dict__}")
+
+        self.cfg = cfg
+        feature_enc_layers = eval(cfg.conv_feature_layers)
+        self.embed = feature_enc_layers[-1][0]
+
+        self.feature_extractor = ConvFeatureExtractionModel(
+            conv_layers=feature_enc_layers,
+            dropout=0.0,
+            mode=cfg.extractor_mode,
+            conv_bias=cfg.conv_bias,
+        )
+
+        self.post_extract_proj = (
+            nn.Linear(self.embed, cfg.encoder_embed_dim)
+            if self.embed != cfg.encoder_embed_dim
+            else None
+        )
+
+        self.mask_prob = cfg.mask_prob
+        self.mask_selection = cfg.mask_selection
+        self.mask_other = cfg.mask_other
+        self.mask_length = cfg.mask_length
+        self.no_mask_overlap = cfg.no_mask_overlap
+        self.mask_min_space = cfg.mask_min_space
+
+        self.mask_channel_prob = cfg.mask_channel_prob
+        self.mask_channel_selection = cfg.mask_channel_selection
+        self.mask_channel_other = cfg.mask_channel_other
+        self.mask_channel_length = cfg.mask_channel_length
+        self.no_mask_channel_overlap = cfg.no_mask_channel_overlap
+        self.mask_channel_min_space = cfg.mask_channel_min_space
+
+        self.dropout_input = nn.Dropout(cfg.dropout_input)
+        self.dropout_features = nn.Dropout(cfg.dropout_features)
+
+        self.feature_grad_mult = cfg.feature_grad_mult
+
+        self.mask_emb = nn.Parameter(
+            torch.FloatTensor(cfg.encoder_embed_dim).uniform_()
+        )
+
+        self.encoder = TransformerEncoder(cfg)
+        self.layer_norm = LayerNorm(self.embed)
+
+    def apply_mask(self, x, padding_mask):
+        B, T, C = x.shape
+        if self.mask_prob > 0:
+            mask_indices = compute_mask_indices(
+                (B, T),
+                padding_mask,
+                self.mask_prob,
+                self.mask_length,
+                self.mask_selection,
+                self.mask_other,
+                min_masks=2,
+                no_overlap=self.no_mask_overlap,
+                min_space=self.mask_min_space,
+            )
+            mask_indices = torch.from_numpy(mask_indices).to(x.device)
+            x[mask_indices] = self.mask_emb
+        else:
+            mask_indices = None
+
+        if self.mask_channel_prob > 0:
+            mask_channel_indices = compute_mask_indices(
+                (B, C),
+                None,
+                self.mask_channel_prob,
+                self.mask_channel_length,
+                self.mask_channel_selection,
+                self.mask_channel_other,
+                no_overlap=self.no_mask_channel_overlap,
+                min_space=self.mask_channel_min_space,
+            )
+            mask_channel_indices = (
+                torch.from_numpy(mask_channel_indices)
+                .to(x.device)
+                .unsqueeze(1)
+                .expand(-1, T, -1)
+            )
+            x[mask_channel_indices] = 0
+
+        return x, mask_indices
+
+    def forward_padding_mask(
+            self, features: torch.Tensor, padding_mask: torch.Tensor,
+    ) -> torch.Tensor:
+        extra = padding_mask.size(1) % features.size(1)
+        if extra > 0:
+            padding_mask = padding_mask[:, :-extra]
+        padding_mask = padding_mask.view(
+            padding_mask.size(0), features.size(1), -1
+        )
+        padding_mask = padding_mask.all(-1)
+        return padding_mask
+
+    def extract_features(
+        self,
+        source: torch.Tensor,
+        padding_mask: Optional[torch.Tensor] = None,
+        mask: bool = False,
+        ret_conv: bool = False,
+        output_layer: Optional[int] = None,
+        ret_layer_results: bool = False,
+    ):
+
+        if self.feature_grad_mult > 0:
+            features = self.feature_extractor(source)
+            if self.feature_grad_mult != 1.0:
+                features = GradMultiply.apply(features, self.feature_grad_mult)
+        else:
+            with torch.no_grad():
+                features = self.feature_extractor(source)
+
+        features = features.transpose(1, 2)
+        features = self.layer_norm(features)
+
+        if padding_mask is not None:
+            padding_mask = self.forward_padding_mask(features, padding_mask)
+
+        if self.post_extract_proj is not None:
+            features = self.post_extract_proj(features)
+
+        features = self.dropout_input(features)
+
+        if mask:
+            x, mask_indices = self.apply_mask(
+                features, padding_mask
+            )
+        else:
+            x = features
+
+        # feature: (B, T, D), float
+        # target: (B, T), long
+        # x: (B, T, D), float
+        # padding_mask: (B, T), bool
+        # mask_indices: (B, T), bool
+        x, layer_results = self.encoder(
+            x,
+            padding_mask=padding_mask,
+            layer=None if output_layer is None else output_layer - 1
+        )
+
+        res = {"x": x, "padding_mask": padding_mask, "features": features, "layer_results": layer_results}
+
+        feature = res["features"] if ret_conv else res["x"]
+        if ret_layer_results:
+            feature = (feature, res["layer_results"])
+        return feature, res["padding_mask"]
+
+
+    def long_term_modeling(
+        self,
+        source: torch.Tensor,
+        padding_mask: Optional[torch.Tensor] = None,
+        mask: bool = False,
+        ret_conv: bool = False,
+        output_layer: Optional[int] = None,
+        ret_layer_results: bool = False,
+    ):
+
+        features = source.transpose(1, 2)
+        features = self.layer_norm(features)
+
+        if padding_mask is not None:
+            padding_mask = self.forward_padding_mask(features, padding_mask)
+
+        if self.post_extract_proj is not None:
+            features = self.post_extract_proj(features)
+
+        features = self.dropout_input(features)
+
+        if mask:
+            x, mask_indices = self.apply_mask(
+                features, padding_mask
+            )
+        else:
+            x = features
+
+        # feature: (B, T, D), float
+        # target: (B, T), long
+        # x: (B, T, D), float
+        # padding_mask: (B, T), bool
+        # mask_indices: (B, T), bool
+        x, layer_results = self.encoder(
+            x,
+            padding_mask=padding_mask,
+            layer=None if output_layer is None else output_layer - 1
+        )
+
+        res = {"x": x, "padding_mask": padding_mask, "features": features, "layer_results": layer_results}
+
+        feature = res["features"] if ret_conv else res["x"]
+        if ret_layer_results:
+            feature = (feature, res["layer_results"])
+        return feature, res["padding_mask"]
+
+
+
+class ConvFeatureExtractionModel(nn.Module):
+    def __init__(
+            self,
+            conv_layers: List[Tuple[int, int, int]],
+            dropout: float = 0.0,
+            mode: str = "default",
+            conv_bias: bool = False,
+            conv_type: str = "default"
+    ):
+        super().__init__()
+
+        assert mode in {"default", "layer_norm"}
+
+        def block(
+                n_in,
+                n_out,
+                k,
+                stride,
+                is_layer_norm=False,
+                is_group_norm=False,
+                conv_bias=False,
+        ):
+            def make_conv():
+                conv = nn.Conv1d(n_in, n_out, k, stride=stride, bias=conv_bias)
+                nn.init.kaiming_normal_(conv.weight)
+                return conv
+
+            assert (
+                           is_layer_norm and is_group_norm
+                   ) == False, "layer norm and group norm are exclusive"
+
+            if is_layer_norm:
+                return nn.Sequential(
+                    make_conv(),
+                    nn.Dropout(p=dropout),
+                    nn.Sequential(
+                        TransposeLast(),
+                        Fp32LayerNorm(dim, elementwise_affine=True),
+                        TransposeLast(),
+                    ),
+                    nn.GELU(),
+                )
+            elif is_group_norm:
+                return nn.Sequential(
+                    make_conv(),
+                    nn.Dropout(p=dropout),
+                    Fp32GroupNorm(dim, dim, affine=True),
+                    nn.GELU(),
+                )
+            else:
+                return nn.Sequential(make_conv(), nn.Dropout(p=dropout), nn.GELU())
+
+        self.conv_type = conv_type
+        if self.conv_type == "default":
+            in_d = 1
+            self.conv_layers = nn.ModuleList()
+            for i, cl in enumerate(conv_layers):
+                assert len(cl) == 3, "invalid conv definition: " + str(cl)
+                (dim, k, stride) = cl
+
+                self.conv_layers.append(
+                    block(
+                        in_d,
+                        dim,
+                        k,
+                        stride,
+                        is_layer_norm=mode == "layer_norm",
+                        is_group_norm=mode == "default" and i == 0,
+                        conv_bias=conv_bias,
+                    )
+                )
+                in_d = dim
+        elif self.conv_type == "conv2d":
+            in_d = 1
+            self.conv_layers = nn.ModuleList()
+            for i, cl in enumerate(conv_layers):
+                assert len(cl) == 3
+                (dim, k, stride) = cl
+
+                self.conv_layers.append(
+                    torch.nn.Conv2d(in_d, dim, k, stride)
+                )
+                self.conv_layers.append(torch.nn.ReLU())
+                in_d = dim
+        elif self.conv_type == "custom":
+            in_d = 1
+            idim = 80
+            self.conv_layers = nn.ModuleList()
+            for i, cl in enumerate(conv_layers):
+                assert len(cl) == 3
+                (dim, k, stride) = cl
+                self.conv_layers.append(
+                    torch.nn.Conv2d(in_d, dim, k, stride, padding=1)
+                )
+                self.conv_layers.append(
+                    torch.nn.LayerNorm([dim, idim])
+                )
+                self.conv_layers.append(torch.nn.ReLU())
+                in_d = dim
+                if (i + 1) % 2 == 0:
+                    self.conv_layers.append(
+                        torch.nn.MaxPool2d(2, stride=2, ceil_mode=True)
+                    )
+                    idim = int(math.ceil(idim / 2))
+        else:
+            pass
+
+    def forward(self, x, mask=None):
+
+        # BxT -> BxCxT
+        x = x.unsqueeze(1)
+        if self.conv_type == "custom":
+            for conv in self.conv_layers:
+                if isinstance(conv, nn.LayerNorm):
+                    x = x.transpose(1, 2)
+                    x = conv(x).transpose(1, 2)
+                else:
+                    x = conv(x)
+            x = x.transpose(2, 3).contiguous()
+            x = x.view(x.size(0), -1, x.size(-1))
+        else:
+            for conv in self.conv_layers:
+                x = conv(x)
+            if self.conv_type == "conv2d":
+                b, c, t, f = x.size()
+                x = x.transpose(2, 3).contiguous().view(b, c * f, t)
+        return x
+
+
+class TransformerEncoder(nn.Module):
+    def __init__(self, args):
+        super().__init__()
+
+        self.dropout = args.dropout
+        self.embedding_dim = args.encoder_embed_dim
+
+        self.pos_conv = nn.Conv1d(
+            self.embedding_dim,
+            self.embedding_dim,
+            kernel_size=args.conv_pos,
+            padding=args.conv_pos // 2,
+            groups=args.conv_pos_groups,
+        )
+        dropout = 0
+        std = math.sqrt((4 * (1.0 - dropout)) / (args.conv_pos * self.embedding_dim))
+        nn.init.normal_(self.pos_conv.weight, mean=0, std=std)
+        nn.init.constant_(self.pos_conv.bias, 0)
+
+        self.pos_conv = nn.utils.weight_norm(self.pos_conv, name="weight", dim=2)
+        self.pos_conv = nn.Sequential(self.pos_conv, SamePad(args.conv_pos), nn.GELU())
+
+        if hasattr(args, "relative_position_embedding"):
+            self.relative_position_embedding = args.relative_position_embedding
+            self.num_buckets = args.num_buckets
+            self.max_distance = args.max_distance
+        else:
+            self.relative_position_embedding = False
+            self.num_buckets = 0
+            self.max_distance = 0
+
+        self.layers = nn.ModuleList(
+            [
+                TransformerSentenceEncoderLayer(
+                    embedding_dim=self.embedding_dim,
+                    ffn_embedding_dim=args.encoder_ffn_embed_dim,
+                    num_attention_heads=args.encoder_attention_heads,
+                    dropout=self.dropout,
+                    attention_dropout=args.attention_dropout,
+                    activation_dropout=args.activation_dropout,
+                    activation_fn=args.activation_fn,
+                    layer_norm_first=args.layer_norm_first,
+                    has_relative_attention_bias=(self.relative_position_embedding and i == 0),
+                    num_buckets=self.num_buckets,
+                    max_distance=self.max_distance,
+                    gru_rel_pos=args.gru_rel_pos,
+                )
+                for i in range(args.encoder_layers)
+            ]
+        )
+
+        self.layer_norm_first = args.layer_norm_first
+        self.layer_norm = LayerNorm(self.embedding_dim)
+        self.layerdrop = args.encoder_layerdrop
+
+        self.apply(init_bert_params)
+
+    def forward(self, x, padding_mask=None, streaming_mask=None, layer=None):
+        x, layer_results = self.extract_features(x, padding_mask, streaming_mask, layer)
+
+        if self.layer_norm_first and layer is None:
+            x = self.layer_norm(x)
+
+        return x, layer_results
+
+    def extract_features(self, x, padding_mask=None, streaming_mask=None, tgt_layer=None):
+
+        if padding_mask is not None:
+            x[padding_mask] = 0
+
+        y = x.transpose(1, 2).clone()
+        x_conv = self.pos_conv(y)
+        x_conv = x_conv.transpose(1, 2)
+        x += x_conv
+
+        if not self.layer_norm_first:
+            x = self.layer_norm(x)
+
+        x = F.dropout(x, p=self.dropout, training=self.training)
+
+        # B x T x C -> T x B x C
+        x = x.transpose(0, 1)
+
+        layer_results = []
+        z = None
+        if tgt_layer is not None:
+            layer_results.append((x, z))
+        r = None
+        pos_bias = None
+        for i, layer in enumerate(self.layers):
+            dropout_probability = np.random.random()
+            if not self.training or (dropout_probability > self.layerdrop):
+                x, z, pos_bias = layer(x, self_attn_padding_mask=padding_mask, need_weights=False,
+                                       self_attn_mask=streaming_mask, pos_bias=pos_bias)
+            if tgt_layer is not None:
+                layer_results.append((x, z))
+            if i == tgt_layer:
+                r = x
+                break
+
+        if r is not None:
+            x = r
+
+        # T x B x C -> B x T x C
+        x = x.transpose(0, 1)
+
+        return x, layer_results
+
+
+class TransformerSentenceEncoderLayer(nn.Module):
+    """
+    Implements a Transformer Encoder Layer used in BERT/XLM style pre-trained
+    models.
+    """
+
+    def __init__(
+            self,
+            embedding_dim: float = 768,
+            ffn_embedding_dim: float = 3072,
+            num_attention_heads: float = 8,
+            dropout: float = 0.1,
+            attention_dropout: float = 0.1,
+            activation_dropout: float = 0.1,
+            activation_fn: str = "relu",
+            layer_norm_first: bool = False,
+            has_relative_attention_bias: bool = False,
+            num_buckets: int = 0,
+            max_distance: int = 0,
+            rescale_init: bool = False,
+            gru_rel_pos: bool = False,
+    ) -> None:
+
+        super().__init__()
+        # Initialize parameters
+        self.embedding_dim = embedding_dim
+        self.dropout = dropout
+        self.activation_dropout = activation_dropout
+
+        # Initialize blocks
+        self.activation_name = activation_fn
+        self.activation_fn = get_activation_fn(activation_fn)
+        self.self_attn = MultiheadAttention(
+            self.embedding_dim,
+            num_attention_heads,
+            dropout=attention_dropout,
+            self_attention=True,
+            has_relative_attention_bias=has_relative_attention_bias,
+            num_buckets=num_buckets,
+            max_distance=max_distance,
+            rescale_init=rescale_init,
+            gru_rel_pos=gru_rel_pos,
+        )
+
+        self.dropout1 = nn.Dropout(dropout)
+        self.dropout2 = nn.Dropout(self.activation_dropout)
+        self.dropout3 = nn.Dropout(dropout)
+
+        self.layer_norm_first = layer_norm_first
+
+        # layer norm associated with the self attention layer
+        self.self_attn_layer_norm = LayerNorm(self.embedding_dim)
+
+        if self.activation_name == "glu":
+            self.fc1 = GLU_Linear(self.embedding_dim, ffn_embedding_dim, "swish")
+        else:
+            self.fc1 = nn.Linear(self.embedding_dim, ffn_embedding_dim)
+        self.fc2 = nn.Linear(ffn_embedding_dim, self.embedding_dim)
+
+        # layer norm associated with the position wise feed-forward NN
+        self.final_layer_norm = LayerNorm(self.embedding_dim)
+
+    def forward(
+            self,
+            x: torch.Tensor,
+            self_attn_mask: torch.Tensor = None,
+            self_attn_padding_mask: torch.Tensor = None,
+            need_weights: bool = False,
+            pos_bias=None
+    ):
+        """
+        LayerNorm is applied either before or after the self-attention/ffn
+        modules similar to the original Transformer imlementation.
+        """
+        residual = x
+
+        if self.layer_norm_first:
+            x = self.self_attn_layer_norm(x)
+            x, attn, pos_bias = self.self_attn(
+                query=x,
+                key=x,
+                value=x,
+                key_padding_mask=self_attn_padding_mask,
+                need_weights=False,
+                attn_mask=self_attn_mask,
+                position_bias=pos_bias
+            )
+            x = self.dropout1(x)
+            x = residual + x
+
+            residual = x
+            x = self.final_layer_norm(x)
+            if self.activation_name == "glu":
+                x = self.fc1(x)
+            else:
+                x = self.activation_fn(self.fc1(x))
+            x = self.dropout2(x)
+            x = self.fc2(x)
+            x = self.dropout3(x)
+            x = residual + x
+        else:
+            x, attn, pos_bias = self.self_attn(
+                query=x,
+                key=x,
+                value=x,
+                key_padding_mask=self_attn_padding_mask,
+                need_weights=need_weights,
+                attn_mask=self_attn_mask,
+                position_bias=pos_bias
+            )
+
+            x = self.dropout1(x)
+            x = residual + x
+
+            x = self.self_attn_layer_norm(x)
+
+            residual = x
+            if self.activation_name == "glu":
+                x = self.fc1(x)
+            else:
+                x = self.activation_fn(self.fc1(x))
+            x = self.dropout2(x)
+            x = self.fc2(x)
+            x = self.dropout3(x)
+            x = residual + x
+            x = self.final_layer_norm(x)
+
+        return x, attn, pos_bias

nnet/llase.py

@@ -0,0 +1,104 @@
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+import sys,os
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+from typing import Union, Optional
+from transformers import LlamaConfig, LlamaForCausalLM
+
+NUM_AUDIO_TOKENS = 65536 # Codebook size
+
+class LLM_AR(nn.Module):
+    def __init__(
+        self,
+        d_model: int,
+        nhead: int,
+        num_layers: int
+    ):
+        super().__init__()
+        self.d_model = d_model
+
+        self.audio_linear_y = nn.Linear(1024, d_model)
+        self.audio_linear_x = nn.Linear(1024, d_model)
+
+        self.Llama_config = LlamaConfig(
+            hidden_size=d_model*2,
+            intermediate_size=d_model * 4,
+            num_attention_heads=nhead,
+            num_hidden_layers=num_layers,
+            dropout_rate=0.1,
+            attention_dropout=0.1,
+            is_decoder=True,
+            use_cache=True
+        )
+
+        self.llama= LlamaForCausalLM(config=self.Llama_config)
+        self.predict_layer_x = nn.Linear(2*d_model, NUM_AUDIO_TOKENS)
+        self.predict_layer_y = nn.Linear(2*d_model, NUM_AUDIO_TOKENS)
+
+    def forward(
+        self,
+        y: torch.Tensor,
+        x: Union[torch.Tensor, None] = None,
+    ) -> torch.Tensor:
+        # y = y.transpose(1,2) # if codec input use this transpose
+
+        if x is None:
+            x = torch.zeros_like(y)
+        elif x.dim() == 2:
+            x = x.unsqueeze(-1)
+            x = x.expand_as(y)
+            
+
+        y_emb = self.audio_linear_y(y)  # [B, T, D] 
+        x_emb = self.audio_linear_x(x)  # [B, T, D]
+
+        if x_emb.shape[1] < y_emb.shape[1]:
+            pad_length = y_emb.shape[1] - x_emb.shape[1]
+            x_emb= F.pad(x_emb, (0, 0, 0, pad_length), mode='constant', value=0)
+            
+        if y_emb.shape[1] < x_emb.shape[1]:
+            pad_length = x_emb.shape[1] - y_emb.shape[1]
+            y_emb= F.pad(y_emb, (0, 0, 0, pad_length), mode='constant', value=0)
+            
+        y_emb = torch.concat([x_emb, y_emb], dim = -1) # [B, T_y, D*2]
+         
+        outputs = self.llama(inputs_embeds = y_emb, output_hidden_states=True)
+
+        dec = outputs.hidden_states[-1] # [B, T_y, D*2]
+        
+        logits_y = self.predict_layer_y(dec)  # [B, T, NUM_AUDIO_TOKENS]
+        logits_x = self.predict_layer_x(dec)
+
+        logits_y = logits_y.transpose(-1, -2)  # [B, NUM_AUDIO_TOKENS, T]
+        logits_x = logits_x.transpose(-1, -2)
+
+        return logits_y, logits_x
+
+if __name__=="__main__":
+    # Simple test
+    model = LLM_AR(d_model=1024, nhead=8, num_layers=16)
+    ce_loss = nn.CrossEntropyLoss()
+
+    y = torch.randn([1,199,1024])
+    x = torch.randn([1,99,1024])
+    label = torch.from_numpy(np.random.randint(0, 300, size=[2,1,199])) 
+
+    total_params = sum(p.numel() for p in model.parameters())
+
+    print(f"Total Params: {total_params}")
+
+    logits = model(y)
+    print(logits[0].shape)
+    print(logits[1].shape)
+
+    logits = model(y,x)
+    print(logits[0].shape)
+    print(logits[1].shape)
+    
+    logits = model(y,y)
+    print(logits[0].shape)
+    print(logits[1].shape)

nnet/modules.py

@@ -0,0 +1,825 @@
+# --------------------------------------------------------
+# WavLM: Large-Scale Self-Supervised  Pre-training  for Full Stack Speech Processing (https://arxiv.org/abs/2110.13900.pdf)
+# Github source: https://github.com/microsoft/unilm/tree/master/wavlm
+# Copyright (c) 2021 Microsoft
+# Licensed under The MIT License [see LICENSE for details]
+# Based on fairseq code bases
+# https://github.com/pytorch/fairseq
+# --------------------------------------------------------
+
+import math
+import warnings
+from typing import Dict, Optional, Tuple
+import torch
+from torch import Tensor, nn
+from torch.nn import Parameter
+import torch.nn.functional as F
+
+class TransposeLast(nn.Module):
+    def __init__(self, deconstruct_idx=None):
+        super().__init__()
+        self.deconstruct_idx = deconstruct_idx
+
+    def forward(self, x):
+        if self.deconstruct_idx is not None:
+            x = x[self.deconstruct_idx]
+        return x.transpose(-2, -1)
+
+
+class Fp32LayerNorm(nn.LayerNorm):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def forward(self, input):
+        output = F.layer_norm(
+            input.float(),
+            self.normalized_shape,
+            self.weight.float() if self.weight is not None else None,
+            self.bias.float() if self.bias is not None else None,
+            self.eps,
+        )
+        return output.type_as(input)
+
+
+class Fp32GroupNorm(nn.GroupNorm):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def forward(self, input):
+        output = F.group_norm(
+            input.float(),
+            self.num_groups,
+            self.weight.float() if self.weight is not None else None,
+            self.bias.float() if self.bias is not None else None,
+            self.eps,
+        )
+        return output.type_as(input)
+
+
+class GradMultiply(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, x, scale):
+        ctx.scale = scale
+        res = x.new(x)
+        return res
+
+    @staticmethod
+    def backward(ctx, grad):
+        return grad * ctx.scale, None
+
+
+class SamePad(nn.Module):
+    def __init__(self, kernel_size, causal=False):
+        super().__init__()
+        if causal:
+            self.remove = kernel_size - 1
+        else:
+            self.remove = 1 if kernel_size % 2 == 0 else 0
+
+    def forward(self, x):
+        if self.remove > 0:
+            x = x[:, :, : -self.remove]
+        return x
+
+
+class Swish(nn.Module):
+    """Swish function
+    """
+
+    def __init__(self):
+        """Construct an MultiHeadedAttention object."""
+        super(Swish, self).__init__()
+        self.act = torch.nn.Sigmoid()
+
+    def forward(self, x):
+        return x * self.act(x)
+
+
+class GLU_Linear(nn.Module):
+    def __init__(self, input_dim, output_dim, glu_type="sigmoid", bias_in_glu=True):
+        super(GLU_Linear, self).__init__()
+
+        self.glu_type = glu_type
+        self.output_dim = output_dim
+
+        if glu_type == "sigmoid":
+            self.glu_act = torch.nn.Sigmoid()
+        elif glu_type == "swish":
+            self.glu_act = Swish()
+        elif glu_type == "relu":
+            self.glu_act = torch.nn.ReLU()
+        elif glu_type == "gelu":
+            self.glu_act = torch.nn.GELU()
+
+        if bias_in_glu:
+            self.linear = nn.Linear(input_dim, output_dim * 2, True)
+        else:
+            self.linear = nn.Linear(input_dim, output_dim * 2, False)
+
+    def forward(self, x):
+        # to be consistent with GLU_Linear, we assume the input always has the #channel (#dim) in the last dimension of the tensor, so need to switch the dimension first for 1D-Conv case
+        x = self.linear(x)
+
+        if self.glu_type == "bilinear":
+            x = (x[:, :, 0:self.output_dim] * x[:, :, self.output_dim:self.output_dim * 2])
+        else:
+            x = (x[:, :, 0:self.output_dim] * self.glu_act(x[:, :, self.output_dim:self.output_dim * 2]))
+
+        return x
+
+def gelu_accurate(x):
+    if not hasattr(gelu_accurate, "_a"):
+        gelu_accurate._a = math.sqrt(2 / math.pi)
+    return (
+        0.5 * x * (1 + torch.tanh(gelu_accurate._a * (x + 0.044715 * torch.pow(x, 3))))
+    )
+
+
+def gelu(x: torch.Tensor) -> torch.Tensor:
+    return torch.nn.functional.gelu(x.float()).type_as(x)
+
+
+def get_activation_fn(activation: str):
+    """Returns the activation function corresponding to `activation`"""
+
+    if activation == "relu":
+        return F.relu
+    elif activation == "gelu":
+        return gelu
+    elif activation == "gelu_fast":
+        warnings.warn(
+            "--activation-fn=gelu_fast has been renamed to gelu_accurate"
+        )
+        return gelu_accurate
+    elif activation == "gelu_accurate":
+        return gelu_accurate
+    elif activation == "tanh":
+        return torch.tanh
+    elif activation == "linear":
+        return lambda x: x
+    elif activation == "glu":
+        return lambda x: x
+    else:
+        raise RuntimeError("--activation-fn {} not supported".format(activation))
+
+
+def init_bert_params(module):
+    """
+    Initialize the weights specific to the BERT Model.
+    This overrides the default initializations depending on the specified arguments.
+        1. If normal_init_linear_weights is set then weights of linear
+           layer will be initialized using the normal distribution and
+           bais will be set to the specified value.
+        2. If normal_init_embed_weights is set then weights of embedding
+           layer will be initialized using the normal distribution.
+        3. If normal_init_proj_weights is set then weights of
+           in_project_weight for MultiHeadAttention initialized using
+           the normal distribution (to be validated).
+    """
+
+    def normal_(data):
+        # with FSDP, module params will be on CUDA, so we cast them back to CPU
+        # so that the RNG is consistent with and without FSDP
+        data.copy_(
+            data.cpu().normal_(mean=0.0, std=0.02).to(data.device)
+        )
+
+    if isinstance(module, nn.Linear):
+        normal_(module.weight.data)
+        if module.bias is not None:
+            module.bias.data.zero_()
+    if isinstance(module, nn.Embedding):
+        normal_(module.weight.data)
+        if module.padding_idx is not None:
+            module.weight.data[module.padding_idx].zero_()
+    if isinstance(module, MultiheadAttention):
+        normal_(module.q_proj.weight.data)
+        normal_(module.k_proj.weight.data)
+        normal_(module.v_proj.weight.data)
+
+
+def quant_noise(module, p, block_size):
+    """
+    Wraps modules and applies quantization noise to the weights for
+    subsequent quantization with Iterative Product Quantization as
+    described in "Training with Quantization Noise for Extreme Model Compression"
+
+    Args:
+        - module: nn.Module
+        - p: amount of Quantization Noise
+        - block_size: size of the blocks for subsequent quantization with iPQ
+
+    Remarks:
+        - Module weights must have the right sizes wrt the block size
+        - Only Linear, Embedding and Conv2d modules are supported for the moment
+        - For more detail on how to quantize by blocks with convolutional weights,
+          see "And the Bit Goes Down: Revisiting the Quantization of Neural Networks"
+        - We implement the simplest form of noise here as stated in the paper
+          which consists in randomly dropping blocks
+    """
+
+    # if no quantization noise, don't register hook
+    if p <= 0:
+        return module
+
+    # supported modules
+    assert isinstance(module, (nn.Linear, nn.Embedding, nn.Conv2d))
+
+    # test whether module.weight has the right sizes wrt block_size
+    is_conv = module.weight.ndim == 4
+
+    # 2D matrix
+    if not is_conv:
+        assert (
+            module.weight.size(1) % block_size == 0
+        ), "Input features must be a multiple of block sizes"
+
+    # 4D matrix
+    else:
+        # 1x1 convolutions
+        if module.kernel_size == (1, 1):
+            assert (
+                module.in_channels % block_size == 0
+            ), "Input channels must be a multiple of block sizes"
+        # regular convolutions
+        else:
+            k = module.kernel_size[0] * module.kernel_size[1]
+            assert k % block_size == 0, "Kernel size must be a multiple of block size"
+
+    def _forward_pre_hook(mod, input):
+        # no noise for evaluation
+        if mod.training:
+            if not is_conv:
+                # gather weight and sizes
+                weight = mod.weight
+                in_features = weight.size(1)
+                out_features = weight.size(0)
+
+                # split weight matrix into blocks and randomly drop selected blocks
+                mask = torch.zeros(
+                    in_features // block_size * out_features, device=weight.device
+                )
+                mask.bernoulli_(p)
+                mask = mask.repeat_interleave(block_size, -1).view(-1, in_features)
+
+            else:
+                # gather weight and sizes
+                weight = mod.weight
+                in_channels = mod.in_channels
+                out_channels = mod.out_channels
+
+                # split weight matrix into blocks and randomly drop selected blocks
+                if mod.kernel_size == (1, 1):
+                    mask = torch.zeros(
+                        int(in_channels // block_size * out_channels),
+                        device=weight.device,
+                    )
+                    mask.bernoulli_(p)
+                    mask = mask.repeat_interleave(block_size, -1).view(-1, in_channels)
+                else:
+                    mask = torch.zeros(
+                        weight.size(0), weight.size(1), device=weight.device
+                    )
+                    mask.bernoulli_(p)
+                    mask = (
+                        mask.unsqueeze(2)
+                        .unsqueeze(3)
+                        .repeat(1, 1, mod.kernel_size[0], mod.kernel_size[1])
+                    )
+
+            # scale weights and apply mask
+            mask = mask.to(
+                torch.bool
+            )  # x.bool() is not currently supported in TorchScript
+            s = 1 / (1 - p)
+            mod.weight.data = s * weight.masked_fill(mask, 0)
+
+    module.register_forward_pre_hook(_forward_pre_hook)
+    return module
+
+
+class MultiheadAttention(nn.Module):
+    """Multi-headed attention.
+
+    See "Attention Is All You Need" for more details.
+    """
+
+    def __init__(
+            self,
+            embed_dim,
+            num_heads,
+            kdim=None,
+            vdim=None,
+            dropout=0.0,
+            bias=True,
+            add_bias_kv=False,
+            add_zero_attn=False,
+            self_attention=False,
+            encoder_decoder_attention=False,
+            q_noise=0.0,
+            qn_block_size=8,
+            has_relative_attention_bias=False,
+            num_buckets=32,
+            max_distance=128,
+            gru_rel_pos=False,
+            rescale_init=False,
+    ):
+        super().__init__()
+        self.embed_dim = embed_dim
+        self.kdim = kdim if kdim is not None else embed_dim
+        self.vdim = vdim if vdim is not None else embed_dim
+        self.qkv_same_dim = self.kdim == embed_dim and self.vdim == embed_dim
+
+        self.num_heads = num_heads
+        self.dropout_module = nn.Dropout(dropout)
+
+        self.has_relative_attention_bias = has_relative_attention_bias
+        self.num_buckets = num_buckets
+        self.max_distance = max_distance
+        if self.has_relative_attention_bias:
+            self.relative_attention_bias = nn.Embedding(num_buckets, num_heads)
+
+        self.head_dim = embed_dim // num_heads
+        self.q_head_dim = self.head_dim
+        self.k_head_dim = self.head_dim
+        assert (
+                self.head_dim * num_heads == self.embed_dim
+        ), "embed_dim must be divisible by num_heads"
+        self.scaling = self.head_dim ** -0.5
+
+        self.self_attention = self_attention
+        self.encoder_decoder_attention = encoder_decoder_attention
+
+        assert not self.self_attention or self.qkv_same_dim, (
+            "Self-attention requires query, key and " "value to be of the same size"
+        )
+
+        k_bias = True
+        if rescale_init:
+            k_bias = False
+
+        k_embed_dim = embed_dim
+        q_embed_dim = embed_dim
+
+        self.k_proj = quant_noise(
+            nn.Linear(self.kdim, k_embed_dim, bias=k_bias), q_noise, qn_block_size
+        )
+        self.v_proj = quant_noise(
+            nn.Linear(self.vdim, embed_dim, bias=bias), q_noise, qn_block_size
+        )
+        self.q_proj = quant_noise(
+            nn.Linear(embed_dim, q_embed_dim, bias=bias), q_noise, qn_block_size
+        )
+
+        self.out_proj = quant_noise(
+            nn.Linear(embed_dim, embed_dim, bias=bias), q_noise, qn_block_size
+        )
+
+        if add_bias_kv:
+            self.bias_k = Parameter(torch.Tensor(1, 1, embed_dim))
+            self.bias_v = Parameter(torch.Tensor(1, 1, embed_dim))
+        else:
+            self.bias_k = self.bias_v = None
+
+        self.add_zero_attn = add_zero_attn
+
+        self.gru_rel_pos = gru_rel_pos
+        if self.gru_rel_pos:
+            self.grep_linear = nn.Linear(self.q_head_dim, 8)
+            self.grep_a = nn.Parameter(torch.ones(1, num_heads, 1, 1))
+
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        if self.qkv_same_dim:
+            # Empirically observed the convergence to be much better with
+            # the scaled initialization
+            nn.init.xavier_uniform_(self.k_proj.weight, gain=1 / math.sqrt(2))
+            nn.init.xavier_uniform_(self.v_proj.weight, gain=1 / math.sqrt(2))
+            nn.init.xavier_uniform_(self.q_proj.weight, gain=1 / math.sqrt(2))
+        else:
+            nn.init.xavier_uniform_(self.k_proj.weight)
+            nn.init.xavier_uniform_(self.v_proj.weight)
+            nn.init.xavier_uniform_(self.q_proj.weight)
+
+        nn.init.xavier_uniform_(self.out_proj.weight)
+        if self.out_proj.bias is not None:
+            nn.init.constant_(self.out_proj.bias, 0.0)
+        if self.bias_k is not None:
+            nn.init.xavier_normal_(self.bias_k)
+        if self.bias_v is not None:
+            nn.init.xavier_normal_(self.bias_v)
+        if self.has_relative_attention_bias:
+            nn.init.xavier_normal_(self.relative_attention_bias.weight)
+
+    def _relative_positions_bucket(self, relative_positions, bidirectional=True):
+        num_buckets = self.num_buckets
+        max_distance = self.max_distance
+        relative_buckets = 0
+
+        if bidirectional:
+            num_buckets = num_buckets // 2
+            relative_buckets += (relative_positions > 0).to(torch.long) * num_buckets
+            relative_positions = torch.abs(relative_positions)
+        else:
+            relative_positions = -torch.min(relative_positions, torch.zeros_like(relative_positions))
+
+        max_exact = num_buckets // 2
+        is_small = relative_positions < max_exact
+
+        relative_postion_if_large = max_exact + (
+                torch.log(relative_positions.float() / max_exact)
+                / math.log(max_distance / max_exact)
+                * (num_buckets - max_exact)
+        ).to(torch.long)
+        relative_postion_if_large = torch.min(
+            relative_postion_if_large, torch.full_like(relative_postion_if_large, num_buckets - 1)
+        )
+
+        relative_buckets += torch.where(is_small, relative_positions, relative_postion_if_large)
+        return relative_buckets
+
+    def compute_bias(self, query_length, key_length):
+        context_position = torch.arange(query_length, dtype=torch.long)[:, None]
+        memory_position = torch.arange(key_length, dtype=torch.long)[None, :]
+        relative_position = memory_position - context_position
+        relative_position_bucket = self._relative_positions_bucket(
+            relative_position,
+            bidirectional=True
+        )
+        relative_position_bucket = relative_position_bucket.to(self.relative_attention_bias.weight.device)
+        values = self.relative_attention_bias(relative_position_bucket)
+        values = values.permute([2, 0, 1])
+        return values
+
+    def forward(
+            self,
+            query,
+            key: Optional[Tensor],
+            value: Optional[Tensor],
+            key_padding_mask: Optional[Tensor] = None,
+            incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None,
+            need_weights: bool = True,
+            static_kv: bool = False,
+            attn_mask: Optional[Tensor] = None,
+            before_softmax: bool = False,
+            need_head_weights: bool = False,
+            position_bias: Optional[Tensor] = None
+    ) -> Tuple[Tensor, Optional[Tensor], Optional[Tensor]]:
+        """Input shape: Time x Batch x Channel
+
+        Args:
+            key_padding_mask (ByteTensor, optional): mask to exclude
+                keys that are pads, of shape `(batch, src_len)`, where
+                padding elements are indicated by 1s.
+            need_weights (bool, optional): return the attention weights,
+                averaged over heads (default: False).
+            attn_mask (ByteTensor, optional): typically used to
+                implement causal attention, where the mask prevents the
+                attention from looking forward in time (default: None).
+            before_softmax (bool, optional): return the raw attention
+                weights and values before the attention softmax.
+            need_head_weights (bool, optional): return the attention
+                weights for each head. Implies *need_weights*. Default:
+                return the average attention weights over all heads.
+        """
+        if need_head_weights:
+            need_weights = True
+
+        is_tpu = query.device.type == "xla"
+
+        tgt_len, bsz, embed_dim = query.size()
+        src_len = tgt_len
+        assert embed_dim == self.embed_dim
+        assert list(query.size()) == [tgt_len, bsz, embed_dim]
+        if key is not None:
+            src_len, key_bsz, _ = key.size()
+            if not torch.jit.is_scripting():
+                assert key_bsz == bsz
+                assert value is not None
+                assert src_len, bsz == value.shape[:2]
+
+        if self.has_relative_attention_bias and position_bias is None:
+            position_bias = self.compute_bias(tgt_len, src_len)
+            position_bias = position_bias.unsqueeze(0).repeat(bsz, 1, 1, 1).view(bsz * self.num_heads, tgt_len, src_len)
+
+        if (
+                not is_tpu  # don't use PyTorch version on TPUs
+                and incremental_state is None
+                and not static_kv
+                # A workaround for quantization to work. Otherwise JIT compilation
+                # treats bias in linear module as method.
+                and not torch.jit.is_scripting()
+                and self.q_head_dim == self.head_dim
+        ):
+            assert key is not None and value is not None
+            assert attn_mask is None
+
+            attn_mask_rel_pos = None
+            if position_bias is not None:
+                attn_mask_rel_pos = position_bias
+                if self.gru_rel_pos:
+                    query_layer = query.transpose(0, 1)
+                    new_x_shape = query_layer.size()[:-1] + (self.num_heads, -1)
+                    query_layer = query_layer.view(*new_x_shape)
+                    query_layer = query_layer.permute(0, 2, 1, 3)
+                    _B, _H, _L, __ = query_layer.size()
+
+                    gate_a, gate_b = torch.sigmoid(self.grep_linear(query_layer).view(
+                        _B, _H, _L, 2, 4).sum(-1, keepdim=False)).chunk(2, dim=-1)
+                    gate_a_1 = gate_a * (gate_b * self.grep_a - 1.0) + 2.0
+                    attn_mask_rel_pos = gate_a_1.view(bsz * self.num_heads, -1, 1) * position_bias
+
+                attn_mask_rel_pos = attn_mask_rel_pos.view((-1, tgt_len, tgt_len))
+            k_proj_bias = self.k_proj.bias
+            if k_proj_bias is None:
+                k_proj_bias = torch.zeros_like(self.q_proj.bias)
+
+            x, attn = F.multi_head_attention_forward(
+                query,
+                key,
+                value,
+                self.embed_dim,
+                self.num_heads,
+                torch.empty([0]),
+                torch.cat((self.q_proj.bias, self.k_proj.bias, self.v_proj.bias)),
+                self.bias_k,
+                self.bias_v,
+                self.add_zero_attn,
+                self.dropout_module.p,
+                self.out_proj.weight,
+                self.out_proj.bias,
+                self.training,
+                # self.training or self.dropout_module.apply_during_inference,
+                key_padding_mask,
+                need_weights,
+                attn_mask_rel_pos,
+                use_separate_proj_weight=True,
+                q_proj_weight=self.q_proj.weight,
+                k_proj_weight=self.k_proj.weight,
+                v_proj_weight=self.v_proj.weight,
+            )
+            return x, attn, position_bias
+
+        if incremental_state is not None:
+            saved_state = self._get_input_buffer(incremental_state)
+            if saved_state is not None and "prev_key" in saved_state:
+                # previous time steps are cached - no need to recompute
+                # key and value if they are static
+                if static_kv:
+                    assert self.encoder_decoder_attention and not self.self_attention
+                    key = value = None
+        else:
+            saved_state = None
+
+        if self.self_attention:
+            q = self.q_proj(query)
+            k = self.k_proj(query)
+            v = self.v_proj(query)
+        elif self.encoder_decoder_attention:
+            # encoder-decoder attention
+            q = self.q_proj(query)
+            if key is None:
+                assert value is None
+                k = v = None
+            else:
+                k = self.k_proj(key)
+                v = self.v_proj(key)
+
+        else:
+            assert key is not None and value is not None
+            q = self.q_proj(query)
+            k = self.k_proj(key)
+            v = self.v_proj(value)
+        q *= self.scaling
+
+        if self.bias_k is not None:
+            assert self.bias_v is not None
+            k = torch.cat([k, self.bias_k.repeat(1, bsz, 1)])
+            v = torch.cat([v, self.bias_v.repeat(1, bsz, 1)])
+            if attn_mask is not None:
+                attn_mask = torch.cat(
+                    [attn_mask, attn_mask.new_zeros(attn_mask.size(0), 1)], dim=1
+                )
+            if key_padding_mask is not None:
+                key_padding_mask = torch.cat(
+                    [
+                        key_padding_mask,
+                        key_padding_mask.new_zeros(key_padding_mask.size(0), 1),
+                    ],
+                    dim=1,
+                )
+
+        q = (
+            q.contiguous()
+                .view(tgt_len, bsz * self.num_heads, self.q_head_dim)
+                .transpose(0, 1)
+        )
+        if k is not None:
+            k = (
+                k.contiguous()
+                    .view(-1, bsz * self.num_heads, self.k_head_dim)
+                    .transpose(0, 1)
+            )
+        if v is not None:
+            v = (
+                v.contiguous()
+                    .view(-1, bsz * self.num_heads, self.head_dim)
+                    .transpose(0, 1)
+            )
+
+        if saved_state is not None:
+            # saved states are stored with shape (bsz, num_heads, seq_len, head_dim)
+            if "prev_key" in saved_state:
+                _prev_key = saved_state["prev_key"]
+                assert _prev_key is not None
+                prev_key = _prev_key.view(bsz * self.num_heads, -1, self.head_dim)
+                if static_kv:
+                    k = prev_key
+                else:
+                    assert k is not None
+                    k = torch.cat([prev_key, k], dim=1)
+                src_len = k.size(1)
+            if "prev_value" in saved_state:
+                _prev_value = saved_state["prev_value"]
+                assert _prev_value is not None
+                prev_value = _prev_value.view(bsz * self.num_heads, -1, self.head_dim)
+                if static_kv:
+                    v = prev_value
+                else:
+                    assert v is not None
+                    v = torch.cat([prev_value, v], dim=1)
+            prev_key_padding_mask: Optional[Tensor] = None
+            if "prev_key_padding_mask" in saved_state:
+                prev_key_padding_mask = saved_state["prev_key_padding_mask"]
+            assert k is not None and v is not None
+            key_padding_mask = MultiheadAttention._append_prev_key_padding_mask(
+                key_padding_mask=key_padding_mask,
+                prev_key_padding_mask=prev_key_padding_mask,
+                batch_size=bsz,
+                src_len=k.size(1),
+                static_kv=static_kv,
+            )
+
+            saved_state["prev_key"] = k.view(bsz, self.num_heads, -1, self.head_dim)
+            saved_state["prev_value"] = v.view(bsz, self.num_heads, -1, self.head_dim)
+            saved_state["prev_key_padding_mask"] = key_padding_mask
+            # In this branch incremental_state is never None
+            assert incremental_state is not None
+            incremental_state = self._set_input_buffer(incremental_state, saved_state)
+        assert k is not None
+        assert k.size(1) == src_len
+
+        # This is part of a workaround to get around fork/join parallelism
+        # not supporting Optional types.
+        if key_padding_mask is not None and key_padding_mask.dim() == 0:
+            key_padding_mask = None
+
+        if key_padding_mask is not None:
+            assert key_padding_mask.size(0) == bsz
+            assert key_padding_mask.size(1) == src_len
+
+        if self.add_zero_attn:
+            assert v is not None
+            src_len += 1
+            k = torch.cat([k, k.new_zeros((k.size(0), 1) + k.size()[2:])], dim=1)
+            v = torch.cat([v, v.new_zeros((v.size(0), 1) + v.size()[2:])], dim=1)
+            if attn_mask is not None:
+                attn_mask = torch.cat(
+                    [attn_mask, attn_mask.new_zeros(attn_mask.size(0), 1)], dim=1
+                )
+            if key_padding_mask is not None:
+                key_padding_mask = torch.cat(
+                    [
+                        key_padding_mask,
+                        torch.zeros(key_padding_mask.size(0), 1).type_as(
+                            key_padding_mask
+                        ),
+                    ],
+                    dim=1,
+                )
+
+        attn_weights = torch.bmm(q, k.transpose(1, 2))
+        attn_weights = self.apply_sparse_mask(attn_weights, tgt_len, src_len, bsz)
+
+        assert list(attn_weights.size()) == [bsz * self.num_heads, tgt_len, src_len]
+
+        if attn_mask is not None:
+            attn_mask = attn_mask.unsqueeze(0)
+            attn_weights += attn_mask
+
+        if key_padding_mask is not None:
+            # don't attend to padding symbols
+            attn_weights = attn_weights.view(bsz, self.num_heads, tgt_len, src_len)
+            if not is_tpu:
+                attn_weights = attn_weights.masked_fill(
+                    key_padding_mask.unsqueeze(1).unsqueeze(2).to(torch.bool),
+                    float("-inf"),
+                )
+            else:
+                attn_weights = attn_weights.transpose(0, 2)
+                attn_weights = attn_weights.masked_fill(key_padding_mask, float("-inf"))
+                attn_weights = attn_weights.transpose(0, 2)
+            attn_weights = attn_weights.view(bsz * self.num_heads, tgt_len, src_len)
+
+        if before_softmax:
+            return attn_weights, v, position_bias
+
+        if position_bias is not None:
+            if self.gru_rel_pos == 1:
+                query_layer = q.view(bsz, self.num_heads, tgt_len, self.q_head_dim)
+                _B, _H, _L, __ = query_layer.size()
+                gate_a, gate_b = torch.sigmoid(self.grep_linear(query_layer).view(
+                    _B, _H, _L, 2, 4).sum(-1, keepdim=False)).chunk(2, dim=-1)
+                gate_a_1 = gate_a * (gate_b * self.grep_a - 1.0) + 2.0
+                position_bias = gate_a_1.view(bsz * self.num_heads, -1, 1) * position_bias
+
+            position_bias = position_bias.view(attn_weights.size())
+
+            attn_weights = attn_weights + position_bias
+
+        attn_weights_float = F.softmax(
+            attn_weights, dim=-1
+        )
+        attn_weights = attn_weights_float.type_as(attn_weights)
+        attn_probs = self.dropout_module(attn_weights)
+
+        assert v is not None
+        attn = torch.bmm(attn_probs, v)
+        assert list(attn.size()) == [bsz * self.num_heads, tgt_len, self.head_dim]
+        attn = attn.transpose(0, 1).contiguous().view(tgt_len, bsz, embed_dim)
+        attn = self.out_proj(attn)
+        attn_weights: Optional[Tensor] = None
+        if need_weights:
+            attn_weights = attn_weights_float.view(
+                bsz, self.num_heads, tgt_len, src_len
+            ).transpose(1, 0)
+            if not need_head_weights:
+                # average attention weights over heads
+                attn_weights = attn_weights.mean(dim=0)
+
+        return attn, attn_weights, position_bias
+
+    @staticmethod
+    def _append_prev_key_padding_mask(
+            key_padding_mask: Optional[Tensor],
+            prev_key_padding_mask: Optional[Tensor],
+            batch_size: int,
+            src_len: int,
+            static_kv: bool,
+    ) -> Optional[Tensor]:
+        # saved key padding masks have shape (bsz, seq_len)
+        if prev_key_padding_mask is not None and static_kv:
+            new_key_padding_mask = prev_key_padding_mask
+        elif prev_key_padding_mask is not None and key_padding_mask is not None:
+            new_key_padding_mask = torch.cat(
+                [prev_key_padding_mask.float(), key_padding_mask.float()], dim=1
+            )
+        # During incremental decoding, as the padding token enters and
+        # leaves the frame, there will be a time when prev or current
+        # is None
+        elif prev_key_padding_mask is not None:
+            if src_len > prev_key_padding_mask.size(1):
+                filler = torch.zeros(
+                    (batch_size, src_len - prev_key_padding_mask.size(1)),
+                    device=prev_key_padding_mask.device,
+                )
+                new_key_padding_mask = torch.cat(
+                    [prev_key_padding_mask.float(), filler.float()], dim=1
+                )
+            else:
+                new_key_padding_mask = prev_key_padding_mask.float()
+        elif key_padding_mask is not None:
+            if src_len > key_padding_mask.size(1):
+                filler = torch.zeros(
+                    (batch_size, src_len - key_padding_mask.size(1)),
+                    device=key_padding_mask.device,
+                )
+                new_key_padding_mask = torch.cat(
+                    [filler.float(), key_padding_mask.float()], dim=1
+                )
+            else:
+                new_key_padding_mask = key_padding_mask.float()
+        else:
+            new_key_padding_mask = prev_key_padding_mask
+        return new_key_padding_mask
+
+    def _get_input_buffer(
+            self, incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]]
+    ) -> Dict[str, Optional[Tensor]]:
+        result = self.get_incremental_state(incremental_state, "attn_state")
+        if result is not None:
+            return result
+        else:
+            empty_result: Dict[str, Optional[Tensor]] = {}
+            return empty_result
+
+    def _set_input_buffer(
+            self,
+            incremental_state: Dict[str, Dict[str, Optional[Tensor]]],
+            buffer: Dict[str, Optional[Tensor]],
+    ):
+        return self.set_incremental_state(incremental_state, "attn_state", buffer)
+
+    def apply_sparse_mask(self, attn_weights, tgt_len: int, src_len: int, bsz: int):
+        return attn_weights

vq/__init__.py

@@ -0,0 +1,4 @@
+from vq.codec_encoder import CodecEncoder
+from vq.codec_decoder import CodecDecoder
+from vq.codec_decoder_vocos import CodecDecoderVocos
+from vq.codec_encoder import CodecEncoder_Transformer,CodecEncoder_only_Transformer