Delete src

src/LMdecoder.py

@@ -1,170 +0,0 @@
-import copy
-from doctest import ELLIPSIS_MARKER
-from functools import partial
-import json
-from turtle import forward, shape
-import einops
-import torch
-from torch import nn
-
-from mmcls.models.backbones.vision_transformer import TransformerEncoderLayer
-from transformers import GPT2Model, GPT2Config,GPT2LMHeadModel,GPTNeoForCausalLM,GPTNeoModel, \
- BartModel, BartConfig, BartForCausalLM, BertForMaskedLM, AutoConfig, AutoModel, AutoModelForCausalLM, AutoTokenizer 
-from transformers import BitsAndBytesConfig
-
-from peft import prepare_model_for_kbit_training
-from peft import LoraConfig
-from peft import get_peft_model
-
-        
-from mmcv.cnn import build_norm_layer
-from mmcv.runner import BaseModule
-import math
-from ipdb import set_trace
-
-class mixEmbed(nn.Module):
-    def __init__(self, lm_embed: nn.Embedding , audio_embeddings, *args, **kwargs) -> None:
-        super().__init__(*args, **kwargs)
-        self.lm_embed = lm_embed
-        self.audio_embeddings = audio_embeddings # ugly but works without modifying raw model codes
-        
-    def forward(self, input_ids):
-        text_ids = torch.clamp(input_ids.clone(), 0).long()
-        
-        au_ids = torch.clamp(-(input_ids.clone() + 1), 0).long()
-        text_embeds = self.lm_embed(text_ids)
-        au_embeds = self.audio_embeddings[au_ids]
-        with torch.no_grad():
-            embed_mask = (input_ids > 0)
-        mix_embeds = au_embeds.clone()
-        mix_embeds[embed_mask] = text_embeds[embed_mask]
-        return mix_embeds
- 
-
-class LMDecoder(nn.Module):
-    def __init__(self,
-                # num_patches=196,
-                img_size=(80,512),
-                patch_size:int=16,
-                in_chans:int=3,
-                embed_dim=1024, # encoder embed dim
-                decoder_embed_dim=512,
-                norm_cfg=dict(type='LN', eps=1e-6),
-                # patch_resolution=14,
-                decoder_type='gpt2',
-                freeze_decoder=True,
-                additional_layer:int=0,
-                ):
-        super().__init__()
-        self.decoder_type = decoder_type
-        self.load_lm()
-        
-        self.lm_embed = self.lm.get_input_embeddings()
-        try:
-            self.lm_pos_embed = self.lm.get_position_embeddings()
-        except NotImplementedError:
-            self.lm_pos_embed = None # rotrary embeds
-            
-        
-        if hasattr(self.lm,'embed_dim'):
-            self.embed_dim = self.lm.embed_dim
-        else:
-            self.embed_dim = decoder_embed_dim
-        
-        # self.asLM = asLM # if generates tokens rather than hidden states
-        # if self.asLM: # TODO: 当年写这个是为啥？
-        #     self.lm.set_output_embeddings(nn.Linear(self.embed_dim, self.self.LMconfig.vocab_size, bias=False))
-        self.freeze_decoder = False
-        if True:
-            for para in self.lm.parameters():
-                para.requires_grad = False
-        
-    def load_lm(self):
-        ## ---------------------LM setting----------------------
-        __import__('pdb').set_trace()
-        self.tokenizer = AutoTokenizer.from_pretrained('meta-llama/Llama-2-7b-hf', token='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')
-        if self.tokenizer.pad_token is None:
-            self.tokenizer.pad_token = self.tokenizer.eos_token
-        self.LMconfig = AutoConfig.from_pretrained('meta-llama/Llama-2-7b-hf', token='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')
-        self.lm = AutoModelForCausalLM.from_pretrained('meta-llama/Llama-2-7b-hf', token='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')
-       
-        
-    def forward(self, input_ids, flatten_embs, attention_mask, labels, **kwargs):
-        mix_embed = mixEmbed(self.lm_embed, flatten_embs)
-        self.lm.set_input_embeddings(mix_embed) # modification of the lm embed 
-        output = self.lm(input_ids=input_ids, attention_mask=attention_mask, labels=labels, output_hidden_states=True, **kwargs) 
-        self.lm.set_input_embeddings(self.lm_embed) # modification of the lm embed 
-        return output
-
-    def generate(self, input_ids, flatten_embs):
-        mix_embed = mixEmbed(self.lm_embed, flatten_embs)
-        self.lm.set_input_embeddings(mix_embed) # modification of the lm embed 
-        outputs = self.lm.generate(input_ids=input_ids, max_new_tokens=256, use_cache=False)
-        # outputs = self.lm.generate(input_ids=input_ids, 
-        #                            max_new_tokens=1024, 
-        #                            do_sample=True,
-        #                            temperature=1.5,
-        #                            num_beams=1,
-        #                            top_p=0.9,
-        #                            top_k=3,
-        #                            use_cache=False)
-        self.lm.set_input_embeddings(self.lm_embed) # modification of the lm embed 
-        return outputs
-'''
-## infer params
-max_input_tokens: 40
-batch_size_test: 16
-max_new_tokens: 64
-min_length: 2
-num_beams: 5
-length_penalty: -2.0
-top_p: 0.9
-top_k: 3
-no_repeat_ngram_size: 2
-apply_lemmatizer: False
-use_nucleus_sampling: True
-'''
-
-class LMDecoder_qlora(LMDecoder):
-    def __init__(self,
-                # num_patches=196,
-                img_size=(80,512),
-                patch_size:int=16,
-                in_chans:int=3,
-                embed_dim=1024, # encoder embed dim
-                decoder_embed_dim=512,
-                norm_cfg=dict(type='LN', eps=1e-6),
-                # patch_resolution=14,
-                decoder_type='gpt2',
-                freeze_decoder=True,
-                additional_layer:int=0,
-                ):
-        super().__init__( img_size, patch_size, in_chans, embed_dim, decoder_embed_dim, norm_cfg, decoder_type, freeze_decoder, additional_layer)
-        
-    def load_lm(self):
-        self.tokenizer = AutoTokenizer.from_pretrained(self.decoder_type)
-        self.LMconfig = AutoConfig.from_pretrained(self.decoder_type, trust_remote_code=True )
-        double_quant_config = BitsAndBytesConfig(
-            load_in_4bit=True,
-            bnb_4bit_use_double_quant=True,
-            )
-        model = AutoModelForCausalLM.from_pretrained(self.decoder_type, 
-                                                    #  device_map='auto', # if remove, can not add lora 
-                                                    # load_in_4bit=True,# if remove, can not add lora 
-                                                    # # torch_dtype=torch.bfloat16,
-                                                    #  quantization_config=double_quant_config, # if remove, can not add lora 
-                                                     trust_remote_code=True )
-
-        model.gradient_checkpointing_enable()
-        model = prepare_model_for_kbit_training(model)
-        lora_config = LoraConfig(
-            r=8, 
-            lora_alpha=32, 
-            target_modules=["query_key_value"], 
-            lora_dropout=0.05, 
-            bias="none", 
-            task_type="CAUSAL_LM"
-        )
-
-        self.lm = get_peft_model(model, lora_config)
-        self.lm.print_trainable_parameters()

src/__init__.py

@@ -1,5 +0,0 @@
-from .spectprompt import SpectPrompt
-from .LMdecoder import LMDecoder
-from .mae_vit import MAEViT
-from .vision_transformer import VisionTransformer
-from .htsat import HTSAT_Swin_Transformer, create_htsat_model

src/comm_utils.py

@@ -1,255 +0,0 @@
-"""
-This file contains primitives for multi-gpu communication.
-This is useful when doing distributed training.
-"""
-
-import functools
-import logging
-import numpy as np
-import pickle
-import torch
-import torch.distributed as dist
-
-_LOCAL_PROCESS_GROUP = None
-"""
-A torch process group which only includes processes that on the same machine as the current process.
-This variable is set when processes are spawned by `launch()` in "engine/launch.py".
-"""
-
-
-def get_world_size() -> int:
-    if not dist.is_available():
-        return 1
-    if not dist.is_initialized():
-        return 1
-    return dist.get_world_size()
-
-
-def get_rank() -> int:
-    if not dist.is_available():
-        return 0
-    if not dist.is_initialized():
-        return 0
-    return dist.get_rank()
-
-
-def get_local_rank() -> int:
-    """
-    Returns:
-        The rank of the current process within the local (per-machine) process group.
-    """
-    if not dist.is_available():
-        return 0
-    if not dist.is_initialized():
-        return 0
-    assert _LOCAL_PROCESS_GROUP is not None
-    return dist.get_rank(group=_LOCAL_PROCESS_GROUP)
-
-
-def get_local_size() -> int:
-    """
-    Returns:
-        The size of the per-machine process group,
-        i.e. the number of processes per machine.
-    """
-    if not dist.is_available():
-        return 1
-    if not dist.is_initialized():
-        return 1
-    return dist.get_world_size(group=_LOCAL_PROCESS_GROUP)
-
-
-def is_main_process() -> bool:
-    return get_rank() == 0
-
-
-def synchronize():
-    """
-    Helper function to synchronize (barrier) among all processes when
-    using distributed training
-    """
-    if not dist.is_available():
-        return
-    if not dist.is_initialized():
-        return
-    world_size = dist.get_world_size()
-    if world_size == 1:
-        return
-    dist.barrier()
-
-
-@functools.lru_cache()
-def _get_global_gloo_group():
-    """
-    Return a process group based on gloo backend, containing all the ranks
-    The result is cached.
-    """
-    if dist.get_backend() == "nccl":
-        return dist.new_group(backend="gloo")
-    else:
-        return dist.group.WORLD
-
-
-def _serialize_to_tensor(data, group):
-    backend = dist.get_backend(group)
-    assert backend in ["gloo", "nccl"]
-    device = torch.device("cpu" if backend == "gloo" else "cuda")
-
-    buffer = pickle.dumps(data)
-    if len(buffer) > 1024 ** 3:
-        logger = logging.getLogger(__name__)
-        logger.warning(
-            "Rank {} trying to all-gather {:.2f} GB of data on device {}".format(
-                get_rank(), len(buffer) / (1024 ** 3), device
-            )
-        )
-    storage = torch.ByteStorage.from_buffer(buffer)
-    tensor = torch.ByteTensor(storage).to(device=device)
-    return tensor
-
-
-def _pad_to_largest_tensor(tensor, group):
-    """
-    Returns:
-        list[int]: size of the tensor, on each rank
-        Tensor: padded tensor that has the max size
-    """
-    world_size = dist.get_world_size(group=group)
-    assert (
-            world_size >= 1
-    ), "comm.gather/all_gather must be called from ranks within the given group!"
-    local_size = torch.tensor([tensor.numel()], dtype=torch.int64, device=tensor.device)
-    size_list = [
-        torch.zeros([1], dtype=torch.int64, device=tensor.device) for _ in range(world_size)
-    ]
-    dist.all_gather(size_list, local_size, group=group)
-    size_list = [int(size.item()) for size in size_list]
-
-    max_size = max(size_list)
-
-    # we pad the tensor because torch all_gather does not support
-    # gathering tensors of different shapes
-    if local_size != max_size:
-        padding = torch.zeros((max_size - local_size,), dtype=torch.uint8, device=tensor.device)
-        tensor = torch.cat((tensor, padding), dim=0)
-    return size_list, tensor
-
-
-def all_gather(data, group=None):
-    """
-    Run all_gather on arbitrary picklable data (not necessarily tensors).
-    Args:
-        data: any picklable object
-        group: a torch process group. By default, will use a group which
-            contains all ranks on gloo backend.
-    Returns:
-        list[data]: list of data gathered from each rank
-    """
-    if get_world_size() == 1:
-        return [data]
-    if group is None:
-        group = _get_global_gloo_group()
-    if dist.get_world_size(group) == 1:
-        return [data]
-
-    tensor = _serialize_to_tensor(data, group)
-
-    size_list, tensor = _pad_to_largest_tensor(tensor, group)
-    max_size = max(size_list)
-
-    # receiving Tensor from all ranks
-    tensor_list = [
-        torch.empty((max_size,), dtype=torch.uint8, device=tensor.device) for _ in size_list
-    ]
-    dist.all_gather(tensor_list, tensor, group=group)
-
-    data_list = []
-    for size, tensor in zip(size_list, tensor_list):
-        buffer = tensor.cpu().numpy().tobytes()[:size]
-        data_list.append(pickle.loads(buffer))
-
-    return data_list
-
-
-def gather(data, dst=0, group=None):
-    """
-    Run gather on arbitrary picklable data (not necessarily tensors).
-    Args:
-        data: any picklable object
-        dst (int): destination rank
-        group: a torch process group. By default, will use a group which
-            contains all ranks on gloo backend.
-    Returns:
-        list[data]: on dst, a list of data gathered from each rank. Otherwise,
-            an empty list.
-    """
-    if get_world_size() == 1:
-        return [data]
-    if group is None:
-        group = _get_global_gloo_group()
-    if dist.get_world_size(group=group) == 1:
-        return [data]
-    rank = dist.get_rank(group=group)
-
-    tensor = _serialize_to_tensor(data, group)
-    size_list, tensor = _pad_to_largest_tensor(tensor, group)
-
-    # receiving Tensor from all ranks
-    if rank == dst:
-        max_size = max(size_list)
-        tensor_list = [
-            torch.empty((max_size,), dtype=torch.uint8, device=tensor.device) for _ in size_list
-        ]
-        dist.gather(tensor, tensor_list, dst=dst, group=group)
-
-        data_list = []
-        for size, tensor in zip(size_list, tensor_list):
-            buffer = tensor.cpu().numpy().tobytes()[:size]
-            data_list.append(pickle.loads(buffer))
-        return data_list
-    else:
-        dist.gather(tensor, [], dst=dst, group=group)
-        return []
-
-
-def shared_random_seed():
-    """
-    Returns:
-        int: a random number that is the same across all workers.
-            If workers need a shared RNG, they can use this shared seed to
-            create one.
-    All workers must call this function, otherwise it will deadlock.
-    """
-    ints = np.random.randint(2 ** 31)
-    all_ints = all_gather(ints)
-    return all_ints[0]
-
-
-def reduce_dict(input_dict, average=True):
-    """
-    Reduce the values in the dictionary from all processes so that process with rank
-    0 has the reduced results.
-    Args:
-        input_dict (dict): inputs to be reduced. All the values must be scalar CUDA Tensor.
-        average (bool): whether to do average or sum
-    Returns:
-        a dict with the same keys as input_dict, after reduction.
-    """
-    world_size = get_world_size()
-    if world_size < 2:
-        return input_dict
-    with torch.no_grad():
-        names = []
-        values = []
-        # sort the keys so that they are consistent across processes
-        for k in sorted(input_dict.keys()):
-            names.append(k)
-            values.append(input_dict[k])
-        values = torch.stack(values, dim=0)
-        dist.reduce(values, dst=0)
-        if dist.get_rank() == 0 and average:
-            # only main process gets accumulated, so only divide by
-            # world_size in this case
-            values /= world_size
-        reduced_dict = {k: v for k, v in zip(names, values)}
-    return reduced_dict

src/htsat.py

@@ -1,1249 +0,0 @@
-# Ke Chen
-# [email protected]
-# HTS-AT: A HIERARCHICAL TOKEN-SEMANTIC AUDIO TRANSFORMER FOR SOUND CLASSIFICATION AND DETECTION
-# Some layers designed on the model
-# below codes are based and referred from https://github.com/microsoft/Swin-Transformer
-# Swin Transformer for Computer Vision: https://arxiv.org/pdf/2103.14030.pdf
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from itertools import repeat
-import collections.abc
-import math
-import warnings
-
-from torch.nn.init import _calculate_fan_in_and_fan_out
-import torch.utils.checkpoint as checkpoint
-
-import random
-
-from torchlibrosa.stft import Spectrogram, LogmelFilterBank
-from torchlibrosa.augmentation import SpecAugmentation
-from einops import rearrange
-from itertools import repeat
-# from .utils import interpolate
-
-# from .feature_fusion import iAFF, AFF, DAF
-
-
-'''
-Feature Fusion for Varible-Length Data Processing
-AFF/iAFF is referred and modified from https://github.com/YimianDai/open-aff/blob/master/aff_pytorch/aff_net/fusion.py
-According to the paper: Yimian Dai et al, Attentional Feature Fusion, IEEE Winter Conference on Applications of Computer Vision, WACV 2021
-'''
-
-class DAF(nn.Module):
-    '''
-    直接相加 DirectAddFuse
-    '''
-
-    def __init__(self):
-        super(DAF, self).__init__()
-
-    def forward(self, x, residual):
-        return x + residual
-
-
-class iAFF(nn.Module):
-    '''
-    多特征融合 iAFF
-    '''
-
-    def __init__(self, channels=64, r=4, type='2D'):
-        super(iAFF, self).__init__()
-        inter_channels = int(channels // r)
-
-        if type == '1D':
-            # 本地注意力
-            self.local_att = nn.Sequential(
-                nn.Conv1d(channels, inter_channels, kernel_size=1, stride=1, padding=0),
-                nn.BatchNorm1d(inter_channels),
-                nn.ReLU(inplace=True),
-                nn.Conv1d(inter_channels, channels, kernel_size=1, stride=1, padding=0),
-                nn.BatchNorm1d(channels),
-            )
-
-            # 全局注意力
-            self.global_att = nn.Sequential(
-                nn.AdaptiveAvgPool1d(1),
-                nn.Conv1d(channels, inter_channels, kernel_size=1, stride=1, padding=0),
-                nn.BatchNorm1d(inter_channels),
-                nn.ReLU(inplace=True),
-                nn.Conv1d(inter_channels, channels, kernel_size=1, stride=1, padding=0),
-                nn.BatchNorm1d(channels),
-            )
-
-            # 第二次本地注意力
-            self.local_att2 = nn.Sequential(
-                nn.Conv1d(channels, inter_channels, kernel_size=1, stride=1, padding=0),
-                nn.BatchNorm1d(inter_channels),
-                nn.ReLU(inplace=True),
-                nn.Conv1d(inter_channels, channels, kernel_size=1, stride=1, padding=0),
-                nn.BatchNorm1d(channels),
-            )
-            # 第二次全局注意力
-            self.global_att2 = nn.Sequential(
-                nn.AdaptiveAvgPool1d(1),
-                nn.Conv1d(channels, inter_channels, kernel_size=1, stride=1, padding=0),
-                nn.BatchNorm1d(inter_channels),
-                nn.ReLU(inplace=True),
-                nn.Conv1d(inter_channels, channels, kernel_size=1, stride=1, padding=0),
-                nn.BatchNorm1d(channels),
-            )
-        elif type == '2D':
-            # 本地注意力
-            self.local_att = nn.Sequential(
-                nn.Conv2d(channels, inter_channels, kernel_size=1, stride=1, padding=0),
-                nn.BatchNorm2d(inter_channels),
-                nn.ReLU(inplace=True),
-                nn.Conv2d(inter_channels, channels, kernel_size=1, stride=1, padding=0),
-                nn.BatchNorm2d(channels),
-            )
-
-            # 全局注意力
-            self.global_att = nn.Sequential(
-                nn.AdaptiveAvgPool2d(1),
-                nn.Conv2d(channels, inter_channels, kernel_size=1, stride=1, padding=0),
-                nn.BatchNorm2d(inter_channels),
-                nn.ReLU(inplace=True),
-                nn.Conv2d(inter_channels, channels, kernel_size=1, stride=1, padding=0),
-                nn.BatchNorm2d(channels),
-            )
-
-            # 第二次本地注意力
-            self.local_att2 = nn.Sequential(
-                nn.Conv2d(channels, inter_channels, kernel_size=1, stride=1, padding=0),
-                nn.BatchNorm2d(inter_channels),
-                nn.ReLU(inplace=True),
-                nn.Conv2d(inter_channels, channels, kernel_size=1, stride=1, padding=0),
-                nn.BatchNorm2d(channels),
-            )
-            # 第二次全局注意力
-            self.global_att2 = nn.Sequential(
-                nn.AdaptiveAvgPool2d(1),
-                nn.Conv2d(channels, inter_channels, kernel_size=1, stride=1, padding=0),
-                nn.BatchNorm2d(inter_channels),
-                nn.ReLU(inplace=True),
-                nn.Conv2d(inter_channels, channels, kernel_size=1, stride=1, padding=0),
-                nn.BatchNorm2d(channels),
-            )
-        else:
-            raise f'the type is not supported'
-
-        self.sigmoid = nn.Sigmoid()
-
-    def forward(self, x, residual):
-        flag = False
-        xa = x + residual
-        if xa.size(0) == 1:
-            xa = torch.cat([xa,xa],dim=0)
-            flag = True
-        xl = self.local_att(xa)
-        xg = self.global_att(xa)
-        xlg = xl + xg
-        wei = self.sigmoid(xlg)
-        xi = x * wei + residual * (1 - wei)
-
-        xl2 = self.local_att2(xi)
-        xg2 = self.global_att(xi)
-        xlg2 = xl2 + xg2
-        wei2 = self.sigmoid(xlg2)
-        xo = x * wei2 + residual * (1 - wei2)
-        if flag:
-            xo = xo[0].unsqueeze(0)
-        return xo
-
-
-class AFF(nn.Module):
-    '''
-    多特征融合 AFF
-    '''
-
-    def __init__(self, channels=64, r=4, type='2D'):
-        super(AFF, self).__init__()
-        inter_channels = int(channels // r)
-
-        if type == '1D':
-            self.local_att = nn.Sequential(
-                nn.Conv1d(channels, inter_channels, kernel_size=1, stride=1, padding=0),
-                nn.BatchNorm1d(inter_channels),
-                nn.ReLU(inplace=True),
-                nn.Conv1d(inter_channels, channels, kernel_size=1, stride=1, padding=0),
-                nn.BatchNorm1d(channels),
-            )
-            self.global_att = nn.Sequential(
-                nn.AdaptiveAvgPool1d(1),
-                nn.Conv1d(channels, inter_channels, kernel_size=1, stride=1, padding=0),
-                nn.BatchNorm1d(inter_channels),
-                nn.ReLU(inplace=True),
-                nn.Conv1d(inter_channels, channels, kernel_size=1, stride=1, padding=0),
-                nn.BatchNorm1d(channels),
-            )
-        elif type == '2D':
-            self.local_att = nn.Sequential(
-                nn.Conv2d(channels, inter_channels, kernel_size=1, stride=1, padding=0),
-                nn.BatchNorm2d(inter_channels),
-                nn.ReLU(inplace=True),
-                nn.Conv2d(inter_channels, channels, kernel_size=1, stride=1, padding=0),
-                nn.BatchNorm2d(channels),
-            )
-            self.global_att = nn.Sequential(
-                nn.AdaptiveAvgPool2d(1),
-                nn.Conv2d(channels, inter_channels, kernel_size=1, stride=1, padding=0),
-                nn.BatchNorm2d(inter_channels),
-                nn.ReLU(inplace=True),
-                nn.Conv2d(inter_channels, channels, kernel_size=1, stride=1, padding=0),
-                nn.BatchNorm2d(channels),
-            )
-        else:
-            raise f'the type is not supported.'
-        
-        self.sigmoid = nn.Sigmoid()
-
-    def forward(self, x, residual):
-        flag = False
-        xa = x + residual
-        if xa.size(0) == 1:
-            xa = torch.cat([xa,xa],dim=0)
-            flag = True
-        xl = self.local_att(xa)
-        xg = self.global_att(xa)
-        xlg = xl + xg
-        wei = self.sigmoid(xlg)
-        xo = 2 * x * wei + 2 * residual * (1 - wei)
-        if flag:
-            xo = xo[0].unsqueeze(0)
-        return xo
-
-
-# .utils
-
-def interpolate(x, ratio):
-    """Interpolate data in time domain. This is used to compensate the
-    resolution reduction in downsampling of a CNN.
-
-    Args:
-      x: (batch_size, time_steps, classes_num)
-      ratio: int, ratio to interpolate
-    Returns:
-      upsampled: (batch_size, time_steps * ratio, classes_num)
-    """
-    (batch_size, time_steps, classes_num) = x.shape
-    upsampled = x[:, :, None, :].repeat(1, 1, ratio, 1)
-    upsampled = upsampled.reshape(batch_size, time_steps * ratio, classes_num)
-    return upsampled
-
-def do_mixup(x, mixup_lambda):
-    """
-    Args:
-      x: (batch_size , ...)
-      mixup_lambda: (batch_size,)
-    Returns:
-      out: (batch_size, ...)
-    """
-    out = (
-            x.transpose(0, -1) * mixup_lambda
-            + torch.flip(x, dims=[0]).transpose(0, -1) * (1 - mixup_lambda)
-    ).transpose(0, -1)
-    return out
-
-# from PyTorch internals
-def _ntuple(n):
-    def parse(x):
-        if isinstance(x, collections.abc.Iterable):
-            return x
-        return tuple(repeat(x, n))
-    return parse
-
-to_1tuple = _ntuple(1)
-to_2tuple = _ntuple(2)
-to_3tuple = _ntuple(3)
-to_4tuple = _ntuple(4)
-to_ntuple = _ntuple
-
-def drop_path(x, drop_prob: float = 0., training: bool = False):
-    """Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks).
-    This is the same as the DropConnect impl I created for EfficientNet, etc networks, however,
-    the original name is misleading as 'Drop Connect' is a different form of dropout in a separate paper...
-    See discussion: https://github.com/tensorflow/tpu/issues/494#issuecomment-532968956 ... I've opted for
-    changing the layer and argument names to 'drop path' rather than mix DropConnect as a layer name and use
-    'survival rate' as the argument.
-    """
-    if drop_prob == 0. or not training:
-        return x
-    keep_prob = 1 - drop_prob
-    shape = (x.shape[0],) + (1,) * (x.ndim - 1)  # work with diff dim tensors, not just 2D ConvNets
-    random_tensor = keep_prob + torch.rand(shape, dtype=x.dtype, device=x.device)
-    random_tensor.floor_()  # binarize
-    output = x.div(keep_prob) * random_tensor
-    return output
-
-
-class DropPath(nn.Module):
-    """Drop paths (Stochastic Depth) per sample  (when applied in main path of residual blocks).
-    """
-    def __init__(self, drop_prob=None):
-        super(DropPath, self).__init__()
-        self.drop_prob = drop_prob
-
-    def forward(self, x):
-        return drop_path(x, self.drop_prob, self.training)
-
-class PatchEmbed(nn.Module):
-    """ 2D Image to Patch Embedding
-    """
-    def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768, norm_layer=None, flatten=True, patch_stride = 16,
-        enable_fusion=False, fusion_type='None'):
-        super().__init__()
-        img_size = to_2tuple(img_size)
-        patch_size = to_2tuple(patch_size)
-        patch_stride = to_2tuple(patch_stride)
-        self.img_size = img_size
-        self.patch_size = patch_size
-        self.patch_stride = patch_stride
-        self.grid_size = (img_size[0] // patch_stride[0], img_size[1] // patch_stride[1])
-        self.num_patches = self.grid_size[0] * self.grid_size[1]
-        self.flatten = flatten
-        self.in_chans = in_chans
-        self.embed_dim = embed_dim
-
-        self.enable_fusion = enable_fusion
-        self.fusion_type = fusion_type
-        
-        padding = ((patch_size[0] - patch_stride[0]) // 2, (patch_size[1] - patch_stride[1]) // 2)
-
-        if (self.enable_fusion) and (self.fusion_type == 'channel_map'):
-            self.proj = nn.Conv2d(in_chans*4, embed_dim, kernel_size=patch_size, stride=patch_stride, padding=padding)
-        else:
-            self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_stride, padding=padding)
-        self.norm = norm_layer(embed_dim) if norm_layer else nn.Identity()
-
-        if (self.enable_fusion) and (self.fusion_type in ['daf_2d','aff_2d','iaff_2d']):
-            self.mel_conv2d = nn.Conv2d(in_chans, embed_dim, kernel_size=(patch_size[0], patch_size[1]*3), stride=(patch_stride[0], patch_stride[1] * 3), padding=padding)
-            if self.fusion_type == 'daf_2d':
-                self.fusion_model = DAF()
-            elif self.fusion_type == 'aff_2d':
-                self.fusion_model = AFF(channels=embed_dim, type='2D')
-            elif self.fusion_type == 'iaff_2d':
-                self.fusion_model = iAFF(channels=embed_dim, type='2D')    
-    def forward(self, x, longer_idx = None):
-        if (self.enable_fusion) and (self.fusion_type in ['daf_2d','aff_2d','iaff_2d']):
-            global_x = x[:,0:1,:,:]
-            
-
-            # global processing
-            B, C, H, W = global_x.shape
-            assert H == self.img_size[0] and W == self.img_size[1], \
-                f"Input image size ({H}*{W}) doesn't match model ({self.img_size[0]}*{self.img_size[1]})."
-            global_x = self.proj(global_x)
-            TW = global_x.size(-1)
-            if len(longer_idx) > 0:
-                # local processing
-                local_x = x[longer_idx,1:,:,:].contiguous()
-                B, C, H, W = local_x.shape
-                local_x = local_x.view(B*C,1,H,W)
-                local_x = self.mel_conv2d(local_x)
-                local_x = local_x.view(B,C,local_x.size(1),local_x.size(2),local_x.size(3))
-                local_x = local_x.permute((0,2,3,1,4)).contiguous().flatten(3)
-                TB,TC,TH,_ = local_x.size()
-                if local_x.size(-1) < TW:
-                    local_x = torch.cat([local_x, torch.zeros((TB,TC,TH,TW-local_x.size(-1)), device=global_x.device)], dim=-1)
-                else:
-                    local_x = local_x[:,:,:,:TW]
-                
-                global_x[longer_idx] = self.fusion_model(global_x[longer_idx],local_x)
-            x = global_x
-        else:
-            B, C, H, W = x.shape
-            assert H == self.img_size[0] and W == self.img_size[1], \
-                f"Input image size ({H}*{W}) doesn't match model ({self.img_size[0]}*{self.img_size[1]})."
-            x = self.proj(x)
-        
-        if self.flatten:
-            x = x.flatten(2).transpose(1, 2)  # BCHW -> BNC
-        x = self.norm(x)
-        return x
-
-class Mlp(nn.Module):
-    """ MLP as used in Vision Transformer, MLP-Mixer and related networks
-    """
-    def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):
-        super().__init__()
-        out_features = out_features or in_features
-        hidden_features = hidden_features or in_features
-        self.fc1 = nn.Linear(in_features, hidden_features)
-        self.act = act_layer()
-        self.fc2 = nn.Linear(hidden_features, out_features)
-        self.drop = nn.Dropout(drop)
-
-    def forward(self, x):
-        x = self.fc1(x)
-        x = self.act(x)
-        x = self.drop(x)
-        x = self.fc2(x)
-        x = self.drop(x)
-        return x
-
-def _no_grad_trunc_normal_(tensor, mean, std, a, b):
-    # Cut & paste from PyTorch official master until it's in a few official releases - RW
-    # Method based on https://people.sc.fsu.edu/~jburkardt/presentations/truncated_normal.pdf
-    def norm_cdf(x):
-        # Computes standard normal cumulative distribution function
-        return (1. + math.erf(x / math.sqrt(2.))) / 2.
-
-    if (mean < a - 2 * std) or (mean > b + 2 * std):
-        warnings.warn("mean is more than 2 std from [a, b] in nn.init.trunc_normal_. "
-                      "The distribution of values may be incorrect.",
-                      stacklevel=2)
-
-    with torch.no_grad():
-        # Values are generated by using a truncated uniform distribution and
-        # then using the inverse CDF for the normal distribution.
-        # Get upper and lower cdf values
-        l = norm_cdf((a - mean) / std)
-        u = norm_cdf((b - mean) / std)
-
-        # Uniformly fill tensor with values from [l, u], then translate to
-        # [2l-1, 2u-1].
-        tensor.uniform_(2 * l - 1, 2 * u - 1)
-
-        # Use inverse cdf transform for normal distribution to get truncated
-        # standard normal
-        tensor.erfinv_()
-
-        # Transform to proper mean, std
-        tensor.mul_(std * math.sqrt(2.))
-        tensor.add_(mean)
-
-        # Clamp to ensure it's in the proper range
-        tensor.clamp_(min=a, max=b)
-        return tensor
-
-
-def trunc_normal_(tensor, mean=0., std=1., a=-2., b=2.):
-    # type: (Tensor, float, float, float, float) -> Tensor
-    r"""Fills the input Tensor with values drawn from a truncated
-    normal distribution. The values are effectively drawn from the
-    normal distribution :math:`\mathcal{N}(\text{mean}, \text{std}^2)`
-    with values outside :math:`[a, b]` redrawn until they are within
-    the bounds. The method used for generating the random values works
-    best when :math:`a \leq \text{mean} \leq b`.
-    Args:
-        tensor: an n-dimensional `torch.Tensor`
-        mean: the mean of the normal distribution
-        std: the standard deviation of the normal distribution
-        a: the minimum cutoff value
-        b: the maximum cutoff value
-    Examples:
-        >>> w = torch.empty(3, 5)
-        >>> nn.init.trunc_normal_(w)
-    """
-    return _no_grad_trunc_normal_(tensor, mean, std, a, b)
-
-
-def variance_scaling_(tensor, scale=1.0, mode='fan_in', distribution='normal'):
-    fan_in, fan_out = _calculate_fan_in_and_fan_out(tensor)
-    if mode == 'fan_in':
-        denom = fan_in
-    elif mode == 'fan_out':
-        denom = fan_out
-    elif mode == 'fan_avg':
-        denom = (fan_in + fan_out) / 2
-
-    variance = scale / denom
-
-    if distribution == "truncated_normal":
-        # constant is stddev of standard normal truncated to (-2, 2)
-        trunc_normal_(tensor, std=math.sqrt(variance) / .87962566103423978)
-    elif distribution == "normal":
-        tensor.normal_(std=math.sqrt(variance))
-    elif distribution == "uniform":
-        bound = math.sqrt(3 * variance)
-        tensor.uniform_(-bound, bound)
-    else:
-        raise ValueError(f"invalid distribution {distribution}")
-
-
-def lecun_normal_(tensor):
-    variance_scaling_(tensor, mode='fan_in', distribution='truncated_normal')
-
-def window_partition(x, window_size):
-    """
-    Args:
-        x: (B, H, W, C)
-        window_size (int): window size
-    Returns:
-        windows: (num_windows*B, window_size, window_size, C)
-    """
-    B, H, W, C = x.shape
-    x = x.view(B, H // window_size, window_size, W // window_size, window_size, C)
-    windows = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size, window_size, C)
-    return windows
-
-
-def window_reverse(windows, window_size, H, W):
-    """
-    Args:
-        windows: (num_windows*B, window_size, window_size, C)
-        window_size (int): Window size
-        H (int): Height of image
-        W (int): Width of image
-    Returns:
-        x: (B, H, W, C)
-    """
-    B = int(windows.shape[0] / (H * W / window_size / window_size))
-    x = windows.view(B, H // window_size, W // window_size, window_size, window_size, -1)
-    x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, H, W, -1)
-    return x
-
-
-class WindowAttention(nn.Module):
-    r""" Window based multi-head self attention (W-MSA) module with relative position bias.
-    It supports both of shifted and non-shifted window.
-    Args:
-        dim (int): Number of input channels.
-        window_size (tuple[int]): The height and width of the window.
-        num_heads (int): Number of attention heads.
-        qkv_bias (bool, optional):  If True, add a learnable bias to query, key, value. Default: True
-        qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set
-        attn_drop (float, optional): Dropout ratio of attention weight. Default: 0.0
-        proj_drop (float, optional): Dropout ratio of output. Default: 0.0
-    """
-
-    def __init__(self, dim, window_size, num_heads, qkv_bias=True, qk_scale=None, attn_drop=0., proj_drop=0.):
-
-        super().__init__()
-        self.dim = dim
-        self.window_size = window_size  # Wh, Ww
-        self.num_heads = num_heads
-        head_dim = dim // num_heads
-        self.scale = qk_scale or head_dim ** -0.5
-
-        # define a parameter table of relative position bias
-        self.relative_position_bias_table = nn.Parameter(
-            torch.zeros((2 * window_size[0] - 1) * (2 * window_size[1] - 1), num_heads))  # 2*Wh-1 * 2*Ww-1, nH
-
-        # get pair-wise relative position index for each token inside the window
-        coords_h = torch.arange(self.window_size[0])
-        coords_w = torch.arange(self.window_size[1])
-        coords = torch.stack(torch.meshgrid([coords_h, coords_w]))  # 2, Wh, Ww
-        coords_flatten = torch.flatten(coords, 1)  # 2, Wh*Ww
-        relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :]  # 2, Wh*Ww, Wh*Ww
-        relative_coords = relative_coords.permute(1, 2, 0).contiguous()  # Wh*Ww, Wh*Ww, 2
-        relative_coords[:, :, 0] += self.window_size[0] - 1  # shift to start from 0
-        relative_coords[:, :, 1] += self.window_size[1] - 1
-        relative_coords[:, :, 0] *= 2 * self.window_size[1] - 1
-        relative_position_index = relative_coords.sum(-1)  # Wh*Ww, Wh*Ww
-        self.register_buffer("relative_position_index", relative_position_index)
-
-        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
-        self.attn_drop = nn.Dropout(attn_drop)
-        self.proj = nn.Linear(dim, dim)
-        self.proj_drop = nn.Dropout(proj_drop)
-
-        trunc_normal_(self.relative_position_bias_table, std=.02)
-        self.softmax = nn.Softmax(dim=-1)
-
-    def forward(self, x, mask=None):
-        """
-        Args:
-            x: input features with shape of (num_windows*B, N, C)
-            mask: (0/-inf) mask with shape of (num_windows, Wh*Ww, Wh*Ww) or None
-        """
-        B_, N, C = x.shape
-        qkv = self.qkv(x).reshape(B_, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
-        q, k, v = qkv[0], qkv[1], qkv[2]  # make torchscript happy (cannot use tensor as tuple)
-
-        q = q * self.scale
-        attn = (q @ k.transpose(-2, -1))
-
-        relative_position_bias = self.relative_position_bias_table[self.relative_position_index.view(-1)].view(
-            self.window_size[0] * self.window_size[1], self.window_size[0] * self.window_size[1], -1)  # Wh*Ww,Wh*Ww,nH
-        relative_position_bias = relative_position_bias.permute(2, 0, 1).contiguous()  # nH, Wh*Ww, Wh*Ww
-        attn = attn + relative_position_bias.unsqueeze(0)
-
-        if mask is not None:
-            nW = mask.shape[0]
-            attn = attn.view(B_ // nW, nW, self.num_heads, N, N) + mask.unsqueeze(1).unsqueeze(0)
-            attn = attn.view(-1, self.num_heads, N, N)
-            attn = self.softmax(attn)
-        else:
-            attn = self.softmax(attn)
-
-        attn = self.attn_drop(attn)
-
-        x = (attn @ v).transpose(1, 2).reshape(B_, N, C)
-        x = self.proj(x)
-        x = self.proj_drop(x)
-        return x, attn
-
-    def extra_repr(self):
-        return f'dim={self.dim}, window_size={self.window_size}, num_heads={self.num_heads}'
-
-
-# We use the model based on Swintransformer Block, therefore we can use the swin-transformer pretrained model
-class SwinTransformerBlock(nn.Module):
-    r""" Swin Transformer Block.
-    Args:
-        dim (int): Number of input channels.
-        input_resolution (tuple[int]): Input resulotion.
-        num_heads (int): Number of attention heads.
-        window_size (int): Window size.
-        shift_size (int): Shift size for SW-MSA.
-        mlp_ratio (float): Ratio of mlp hidden dim to embedding dim.
-        qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True
-        qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set.
-        drop (float, optional): Dropout rate. Default: 0.0
-        attn_drop (float, optional): Attention dropout rate. Default: 0.0
-        drop_path (float, optional): Stochastic depth rate. Default: 0.0
-        act_layer (nn.Module, optional): Activation layer. Default: nn.GELU
-        norm_layer (nn.Module, optional): Normalization layer.  Default: nn.LayerNorm
-    """
-
-    def __init__(self, dim, input_resolution, num_heads, window_size=7, shift_size=0,
-                 mlp_ratio=4., qkv_bias=True, qk_scale=None, drop=0., attn_drop=0., drop_path=0.,
-                 act_layer=nn.GELU, norm_layer=nn.LayerNorm, norm_before_mlp='ln'):
-        super().__init__()
-        self.dim = dim
-        self.input_resolution = input_resolution
-        self.num_heads = num_heads
-        self.window_size = window_size
-        self.shift_size = shift_size
-        self.mlp_ratio = mlp_ratio
-        self.norm_before_mlp = norm_before_mlp
-        if min(self.input_resolution) <= self.window_size:
-            # if window size is larger than input resolution, we don't partition windows
-            self.shift_size = 0
-            self.window_size = min(self.input_resolution)
-        assert 0 <= self.shift_size < self.window_size, "shift_size must in 0-window_size"
-
-        self.norm1 = norm_layer(dim)
-        self.attn = WindowAttention(
-            dim, window_size=to_2tuple(self.window_size), num_heads=num_heads,
-            qkv_bias=qkv_bias, qk_scale=qk_scale, attn_drop=attn_drop, proj_drop=drop)
-
-        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
-        if self.norm_before_mlp == 'ln':
-            self.norm2 = nn.LayerNorm(dim)
-        elif self.norm_before_mlp == 'bn':
-            self.norm2 = lambda x: nn.BatchNorm1d(dim)(x.transpose(1, 2)).transpose(1, 2)
-        else:
-            raise NotImplementedError
-        mlp_hidden_dim = int(dim * mlp_ratio)
-        self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)
-
-        if self.shift_size > 0:
-            # calculate attention mask for SW-MSA
-            H, W = self.input_resolution
-            img_mask = torch.zeros((1, H, W, 1))  # 1 H W 1
-            h_slices = (slice(0, -self.window_size),
-                        slice(-self.window_size, -self.shift_size),
-                        slice(-self.shift_size, None))
-            w_slices = (slice(0, -self.window_size),
-                        slice(-self.window_size, -self.shift_size),
-                        slice(-self.shift_size, None))
-            cnt = 0
-            for h in h_slices:
-                for w in w_slices:
-                    img_mask[:, h, w, :] = cnt
-                    cnt += 1
-
-            mask_windows = window_partition(img_mask, self.window_size)  # nW, window_size, window_size, 1
-            mask_windows = mask_windows.view(-1, self.window_size * self.window_size)
-            attn_mask = mask_windows.unsqueeze(1) - mask_windows.unsqueeze(2)
-            attn_mask = attn_mask.masked_fill(attn_mask != 0, float(-100.0)).masked_fill(attn_mask == 0, float(0.0))
-        else:
-            attn_mask = None
-
-        self.register_buffer("attn_mask", attn_mask)
-
-    def forward(self, x):
-        # pdb.set_trace()
-        H, W = self.input_resolution
-        # print("H: ", H)
-        # print("W: ", W)
-        # pdb.set_trace()
-        B, L, C = x.shape
-        # assert L == H * W, "input feature has wrong size"
-
-        shortcut = x
-        x = self.norm1(x)
-        x = x.view(B, H, W, C)
-
-        # cyclic shift
-        if self.shift_size > 0:
-            shifted_x = torch.roll(x, shifts=(-self.shift_size, -self.shift_size), dims=(1, 2))
-        else:
-            shifted_x = x
-
-        # partition windows
-        x_windows = window_partition(shifted_x, self.window_size)  # nW*B, window_size, window_size, C
-        x_windows = x_windows.view(-1, self.window_size * self.window_size, C)  # nW*B, window_size*window_size, C
-
-        # W-MSA/SW-MSA
-        attn_windows, attn = self.attn(x_windows, mask=self.attn_mask)  # nW*B, window_size*window_size, C
-
-        # merge windows
-        attn_windows = attn_windows.view(-1, self.window_size, self.window_size, C)
-        shifted_x = window_reverse(attn_windows, self.window_size, H, W)  # B H' W' C
-
-        # reverse cyclic shift
-        if self.shift_size > 0:
-            x = torch.roll(shifted_x, shifts=(self.shift_size, self.shift_size), dims=(1, 2))
-        else:
-            x = shifted_x
-        x = x.view(B, H * W, C)
-
-        # FFN
-        x = shortcut + self.drop_path(x)
-        x = x + self.drop_path(self.mlp(self.norm2(x)))
-
-        return x, attn
-
-    def extra_repr(self):
-        return f"dim={self.dim}, input_resolution={self.input_resolution}, num_heads={self.num_heads}, " \
-               f"window_size={self.window_size}, shift_size={self.shift_size}, mlp_ratio={self.mlp_ratio}"
-
-
-
-class PatchMerging(nn.Module):
-    r""" Patch Merging Layer.
-    Args:
-        input_resolution (tuple[int]): Resolution of input feature.
-        dim (int): Number of input channels.
-        norm_layer (nn.Module, optional): Normalization layer.  Default: nn.LayerNorm
-    """
-
-    def __init__(self, input_resolution, dim, norm_layer=nn.LayerNorm):
-        super().__init__()
-        self.input_resolution = input_resolution
-        self.dim = dim
-        self.reduction = nn.Linear(4 * dim, 2 * dim, bias=False)
-        self.norm = norm_layer(4 * dim)
-
-    def forward(self, x):
-        """
-        x: B, H*W, C
-        """
-        H, W = self.input_resolution
-        B, L, C = x.shape
-        assert L == H * W, "input feature has wrong size"
-        assert H % 2 == 0 and W % 2 == 0, f"x size ({H}*{W}) are not even."
-
-        x = x.view(B, H, W, C)
-
-        x0 = x[:, 0::2, 0::2, :]  # B H/2 W/2 C
-        x1 = x[:, 1::2, 0::2, :]  # B H/2 W/2 C
-        x2 = x[:, 0::2, 1::2, :]  # B H/2 W/2 C
-        x3 = x[:, 1::2, 1::2, :]  # B H/2 W/2 C
-        x = torch.cat([x0, x1, x2, x3], -1)  # B H/2 W/2 4*C
-        x = x.view(B, -1, 4 * C)  # B H/2*W/2 4*C
-
-        x = self.norm(x)
-        x = self.reduction(x)
-
-        return x
-
-    def extra_repr(self):
-        return f"input_resolution={self.input_resolution}, dim={self.dim}"
-
-
-class BasicLayer(nn.Module):
-    """ A basic Swin Transformer layer for one stage.
-    Args:
-        dim (int): Number of input channels.
-        input_resolution (tuple[int]): Input resolution.
-        depth (int): Number of blocks.
-        num_heads (int): Number of attention heads.
-        window_size (int): Local window size.
-        mlp_ratio (float): Ratio of mlp hidden dim to embedding dim.
-        qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True
-        qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set.
-        drop (float, optional): Dropout rate. Default: 0.0
-        attn_drop (float, optional): Attention dropout rate. Default: 0.0
-        drop_path (float | tuple[float], optional): Stochastic depth rate. Default: 0.0
-        norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm
-        downsample (nn.Module | None, optional): Downsample layer at the end of the layer. Default: None
-        use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False.
-    """
-
-    def __init__(self, dim, input_resolution, depth, num_heads, window_size,
-                 mlp_ratio=4., qkv_bias=True, qk_scale=None, drop=0., attn_drop=0.,
-                 drop_path=0., norm_layer=nn.LayerNorm, downsample=None, use_checkpoint=False,
-                 norm_before_mlp='ln'):
-
-        super().__init__()
-        self.dim = dim
-        self.input_resolution = input_resolution
-        self.depth = depth
-        self.use_checkpoint = use_checkpoint
-
-        # build blocks
-        self.blocks = nn.ModuleList([
-            SwinTransformerBlock(dim=dim, input_resolution=input_resolution,
-                                 num_heads=num_heads, window_size=window_size,
-                                 shift_size=0 if (i % 2 == 0) else window_size // 2,
-                                 mlp_ratio=mlp_ratio,
-                                 qkv_bias=qkv_bias, qk_scale=qk_scale,
-                                 drop=drop, attn_drop=attn_drop,
-                                 drop_path=drop_path[i] if isinstance(drop_path, list) else drop_path,
-                                 norm_layer=norm_layer, norm_before_mlp=norm_before_mlp)
-            for i in range(depth)])
-
-        # patch merging layer
-        if downsample is not None:
-            self.downsample = downsample(input_resolution, dim=dim, norm_layer=norm_layer)
-        else:
-            self.downsample = None
-
-    def forward(self, x):
-        attns = []
-        for blk in self.blocks:
-            if self.use_checkpoint:
-                x = checkpoint.checkpoint(blk, x)
-            else:
-                x, attn = blk(x)
-                if not self.training:
-                    attns.append(attn.unsqueeze(0))
-        if self.downsample is not None:
-            x = self.downsample(x)
-        if not self.training:
-            attn = torch.cat(attns, dim = 0)
-            attn = torch.mean(attn, dim = 0)
-        return x, attn
-    
-        # if self.downsample is not None:
-        #     x = self.downsample(x)
-        # if not self.training:
-        #     attn = torch.cat(attns, dim = 0)
-        #     attn = torch.mean(attn, dim = 0)
-        # return x, attn
-
-    def extra_repr(self):
-        return f"dim={self.dim}, input_resolution={self.input_resolution}, depth={self.depth}"
-
-
-# The Core of HTSAT
-class HTSAT_Swin_Transformer(nn.Module):
-    r"""HTSAT based on the Swin Transformer
-    Args:
-        spec_size (int | tuple(int)): Input Spectrogram size. Default 256
-        patch_size (int | tuple(int)): Patch size. Default: 4
-        path_stride (iot | tuple(int)): Patch Stride for Frequency and Time Axis. Default: 4
-        in_chans (int): Number of input image channels. Default: 1 (mono)
-        num_classes (int): Number of classes for classification head. Default: 527
-        embed_dim (int): Patch embedding dimension. Default: 96
-        depths (tuple(int)): Depth of each HTSAT-Swin Transformer layer.
-        num_heads (tuple(int)): Number of attention heads in different layers.
-        window_size (int): Window size. Default: 8
-        mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. Default: 4
-        qkv_bias (bool): If True, add a learnable bias to query, key, value. Default: True
-        qk_scale (float): Override default qk scale of head_dim ** -0.5 if set. Default: None
-        drop_rate (float): Dropout rate. Default: 0
-        attn_drop_rate (float): Attention dropout rate. Default: 0
-        drop_path_rate (float): Stochastic depth rate. Default: 0.1
-        norm_layer (nn.Module): Normalization layer. Default: nn.LayerNorm.
-        ape (bool): If True, add absolute position embedding to the patch embedding. Default: False
-        patch_norm (bool): If True, add normalization after patch embedding. Default: True
-        use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False
-        config (module): The configuration Module from config.py
-    """
-
-    def __init__(self, spec_size=256, patch_size=4, patch_stride=(4,4), 
-                in_chans=1, num_classes=527,
-                 embed_dim=96, depths=[2, 2, 6, 2], num_heads=[4, 8, 16, 32],
-                 window_size=8, mlp_ratio=4., qkv_bias=True, qk_scale=None,
-                 drop_rate=0., attn_drop_rate=0., drop_path_rate=0.1,
-                 norm_layer=nn.LayerNorm, 
-                 ape=False, patch_norm=True,
-                 use_checkpoint=False, norm_before_mlp='ln', config = None, 
-                 enable_fusion = False, fusion_type = 'None', **kwargs):
-        super(HTSAT_Swin_Transformer, self).__init__()
-
-        self.config = config
-        self.spec_size = spec_size 
-        self.patch_stride = patch_stride
-        self.patch_size = patch_size
-        self.window_size = window_size
-        self.embed_dim = embed_dim
-        self.depths = depths
-        self.ape = ape
-        self.in_chans = in_chans
-        self.num_classes = num_classes
-        self.num_heads = num_heads
-        self.num_layers = len(self.depths)
-        self.num_features = int(self.embed_dim * 2 ** (self.num_layers - 1))
-        
-        self.drop_rate = drop_rate
-        self.attn_drop_rate = attn_drop_rate
-        self.drop_path_rate = drop_path_rate
-
-        self.qkv_bias = qkv_bias
-        self.qk_scale = None
-
-        self.patch_norm = patch_norm
-        self.norm_layer = norm_layer if self.patch_norm else None
-        self.norm_before_mlp = norm_before_mlp
-        self.mlp_ratio = mlp_ratio
-
-        self.use_checkpoint = use_checkpoint
-
-        self.enable_fusion = enable_fusion
-        self.fusion_type = fusion_type
-
-        #  process mel-spec ; used only once
-        self.freq_ratio = self.spec_size // self.config.mel_bins
-        window = 'hann'
-        center = True
-        pad_mode = 'reflect'
-        ref = 1.0
-        amin = 1e-10
-        top_db = None
-        self.interpolate_ratio = 32     # Downsampled ratio
-        # Spectrogram extractor
-        self.spectrogram_extractor = Spectrogram(n_fft=config.window_size, hop_length=config.hop_size, 
-            win_length=config.window_size, window=window, center=center, pad_mode=pad_mode, 
-            freeze_parameters=True)
-        # Logmel feature extractor
-        self.logmel_extractor = LogmelFilterBank(sr=config.sample_rate, n_fft=config.window_size, 
-            n_mels=config.mel_bins, fmin=config.fmin, fmax=config.fmax, ref=ref, amin=amin, top_db=top_db, 
-            freeze_parameters=True)
-        # Spec augmenter
-        self.spec_augmenter = SpecAugmentation(time_drop_width=64, time_stripes_num=2, 
-            freq_drop_width=8, freq_stripes_num=2) # 2 2
-        self.bn0 = nn.BatchNorm2d(self.config.mel_bins)
-
-
-        # split spctrogram into non-overlapping patches
-        self.patch_embed = PatchEmbed(
-            img_size=self.spec_size, patch_size=self.patch_size, in_chans=self.in_chans, 
-            embed_dim=self.embed_dim, norm_layer=self.norm_layer, patch_stride = patch_stride,
-            enable_fusion=self.enable_fusion, fusion_type=self.fusion_type
-            )
-
-        num_patches = self.patch_embed.num_patches
-        patches_resolution = self.patch_embed.grid_size
-        self.patches_resolution = patches_resolution
-
-        # absolute position embedding
-        if self.ape:
-            self.absolute_pos_embed = nn.Parameter(torch.zeros(1, num_patches, self.embed_dim))
-            trunc_normal_(self.absolute_pos_embed, std=.02)
-
-        self.pos_drop = nn.Dropout(p=self.drop_rate)
-
-        # stochastic depth
-        dpr = [x.item() for x in torch.linspace(0, self.drop_path_rate, sum(self.depths))]  # stochastic depth decay rule
-
-        # build layers
-        self.layers = nn.ModuleList()
-        for i_layer in range(self.num_layers):
-            layer = BasicLayer(dim=int(self.embed_dim * 2 ** i_layer),
-                input_resolution=(patches_resolution[0] // (2 ** i_layer),
-                                    patches_resolution[1] // (2 ** i_layer)),
-                depth=self.depths[i_layer],
-                num_heads=self.num_heads[i_layer],
-                window_size=self.window_size,
-                mlp_ratio=self.mlp_ratio,
-                qkv_bias=self.qkv_bias, qk_scale=self.qk_scale,
-                drop=self.drop_rate, attn_drop=self.attn_drop_rate,
-                drop_path=dpr[sum(self.depths[:i_layer]):sum(self.depths[:i_layer + 1])],
-                norm_layer=self.norm_layer,
-                downsample=PatchMerging if (i_layer < self.num_layers - 1) else None,
-                use_checkpoint=use_checkpoint,
-                norm_before_mlp=self.norm_before_mlp)
-            self.layers.append(layer)
-
-        self.norm = self.norm_layer(self.num_features)
-        self.avgpool = nn.AdaptiveAvgPool1d(1)
-        self.maxpool = nn.AdaptiveMaxPool1d(1)
-        
-        SF = self.spec_size // (2 ** (len(self.depths) - 1)) // self.patch_stride[0] // self.freq_ratio
-        self.tscam_conv = nn.Conv2d(
-            in_channels = self.num_features,
-            out_channels = self.num_classes,
-            kernel_size = (SF,3),
-            padding = (0,1)
-        )
-        self.head = nn.Linear(num_classes, num_classes)
-
-        if (self.enable_fusion) and (self.fusion_type in ['daf_1d','aff_1d','iaff_1d']):
-            self.mel_conv1d = nn.Sequential(
-                nn.Conv1d(64, 64, kernel_size=5, stride=3, padding=2),
-                nn.BatchNorm1d(64)
-            )
-            if self.fusion_type == 'daf_1d':
-                self.fusion_model = DAF()
-            elif self.fusion_type == 'aff_1d':
-                self.fusion_model = AFF(channels=64, type='1D')
-            elif self.fusion_type == 'iaff_1d':
-                self.fusion_model = iAFF(channels=64, type='1D')
-                
-        self.apply(self._init_weights)
-
-    def _init_weights(self, m):
-        if isinstance(m, nn.Linear):
-            trunc_normal_(m.weight, std=.02)
-            if isinstance(m, nn.Linear) and m.bias is not None:
-                nn.init.constant_(m.bias, 0)
-        elif isinstance(m, nn.LayerNorm):
-            nn.init.constant_(m.bias, 0)
-            nn.init.constant_(m.weight, 1.0)
-
-    @torch.jit.ignore
-    def no_weight_decay(self):
-        return {'absolute_pos_embed'}
-
-    @torch.jit.ignore
-    def no_weight_decay_keywords(self):
-        return {'relative_position_bias_table'}
-
-
-    def forward_features(self, x, longer_idx = None):
-        # A deprecated optimization for using a hierarchical output from different blocks
-
-        frames_num = x.shape[2]        
-        x = self.patch_embed(x, longer_idx = longer_idx)
-        if self.ape:
-            x = x + self.absolute_pos_embed
-        x = self.pos_drop(x)
-        for i, layer in enumerate(self.layers):
-            x, attn = layer(x)
-        # for x
-        x = self.norm(x)
-        B, N, C = x.shape
-        SF = frames_num // (2 ** (len(self.depths) - 1)) // self.patch_stride[0]
-        ST = frames_num // (2 ** (len(self.depths) - 1)) // self.patch_stride[1]
-        x = x.permute(0,2,1).contiguous().reshape(B, C, SF, ST)
-        B, C, F, T = x.shape
-        # group 2D CNN
-        c_freq_bin = F // self.freq_ratio
-        x = x.reshape(B, C, F // c_freq_bin, c_freq_bin, T)
-        x = x.permute(0,1,3,2,4).contiguous().reshape(B, C, c_freq_bin, -1)
-        # get latent_output
-        fine_grained_latent_output = torch.mean(x, dim = 2)
-        fine_grained_latent_output = interpolate(fine_grained_latent_output.permute(0,2,1).contiguous(), 8 * self.patch_stride[1]) 
-        
-        latent_output = self.avgpool(torch.flatten(x,2))
-        latent_output = torch.flatten(latent_output, 1)
-
-        # display the attention map, if needed
-
-        x = self.tscam_conv(x)
-        x = torch.flatten(x, 2) # B, C, T
- 
-        fpx = interpolate(torch.sigmoid(x).permute(0,2,1).contiguous(), 8 * self.patch_stride[1]) 
-            
-        x = self.avgpool(x)
-        x = torch.flatten(x, 1)
-
-        output_dict = {
-            'framewise_output': fpx, # already sigmoided
-            'clipwise_output': torch.sigmoid(x),
-            'fine_grained_embedding': fine_grained_latent_output,
-            'embedding': latent_output
-        }
-
-        return output_dict
-
-    def crop_wav(self, x, crop_size, spe_pos = None):
-        time_steps = x.shape[2]
-        tx = torch.zeros(x.shape[0], x.shape[1], crop_size, x.shape[3]).to(x.device)
-        for i in range(len(x)):
-            if spe_pos is None:
-                crop_pos = random.randint(0, time_steps - crop_size - 1)
-            else:
-                crop_pos = spe_pos
-            tx[i][0] = x[i, 0, crop_pos:crop_pos + crop_size,:]
-        return tx
-
-    # Reshape the wavform to a img size, if you want to use the pretrained swin transformer model
-    def reshape_wav2img(self, x):
-        B, C, T, F = x.shape
-        target_T = int(self.spec_size * self.freq_ratio)
-        target_F = self.spec_size // self.freq_ratio
-        assert T <= target_T and F <= target_F, "the wav size should less than or equal to the swin input size"
-        # to avoid bicubic zero error
-        if T < target_T:
-            x = nn.functional.interpolate(x, (target_T, x.shape[3]), mode="bicubic", align_corners=True)
-        if F < target_F:
-            x = nn.functional.interpolate(x, (x.shape[2], target_F), mode="bicubic", align_corners=True)
-        x = x.permute(0,1,3,2).contiguous()
-        x = x.reshape(x.shape[0], x.shape[1], x.shape[2], self.freq_ratio, x.shape[3] // self.freq_ratio)
-        # print(x.shape)
-        x = x.permute(0,1,3,2,4).contiguous()
-        x = x.reshape(x.shape[0], x.shape[1], x.shape[2] * x.shape[3], x.shape[4])
-        return x
-    
-    # Repeat the wavform to a img size, if you want to use the pretrained swin transformer model
-    def repeat_wat2img(self, x, cur_pos):
-        B, C, T, F = x.shape
-        target_T = int(self.spec_size * self.freq_ratio)
-        target_F = self.spec_size // self.freq_ratio
-        assert T <= target_T and F <= target_F, "the wav size should less than or equal to the swin input size"
-        # to avoid bicubic zero error
-        if T < target_T:
-            x = nn.functional.interpolate(x, (target_T, x.shape[3]), mode="bicubic", align_corners=True)
-        if F < target_F:
-            x = nn.functional.interpolate(x, (x.shape[2], target_F), mode="bicubic", align_corners=True)  
-        x = x.permute(0,1,3,2).contiguous() # B C F T
-        x = x[:,:,:,cur_pos:cur_pos + self.spec_size]
-        x = x.repeat(repeats = (1,1,4,1))
-        return x
-
-    def forward_generator(self, x: torch.Tensor, mixup_lambda = None, infer_mode = False, device=None):# out_feat_keys: List[str] = None):
-
-        n = int(x.shape[1]/480000)
-        assert n * 480000 == x.shape[1]
-        x = rearrange(x, 'b (n t) -> (b n) t', n=n)
-        if not self.enable_fusion:
-            # x = x["waveform"].to(device=device, non_blocking=True)
-            x = x.to(device=device, non_blocking=True)
-            x = self.spectrogram_extractor(x)   # (batch_size, 1, time_steps, freq_bins)
-            x = self.logmel_extractor(x)    # (batch_size, 1, time_steps, mel_bins)
-            x = x.transpose(1, 3)
-            x = self.bn0(x)
-            x = x.transpose(1, 3)
-            if self.training:
-                x = self.spec_augmenter(x)
-
-            if self.training and mixup_lambda is not None:
-                x = do_mixup(x, mixup_lambda)
-                
-            x = self.reshape_wav2img(x)
-            # output_dict = self.forward_features(x)
-        
-        # A deprecated optimization for using a hierarchical output from different blocks
-        longer_idx = None
-        frames_num = x.shape[2]        
-        x = self.patch_embed(x, longer_idx = longer_idx)
-        if self.ape:
-            x = x + self.absolute_pos_embed
-        x = self.pos_drop(x)
-        for i, layer in enumerate(self.layers[:3]): # depth: [2,2,12,2]
-            if i == 2:
-                for blk in layer.blocks:
-                    x, attn = blk(x)
-                    # 512
-                    x = rearrange(x, '(b n) t c -> b (n t) c', n=n)
-                    x = x if (new_x:=(yield x)) is None else new_x
-                    x = rearrange(x, 'b (n t) c -> (b n) t c', n=n)
-            else:
-                x, attn = layer(x)
-
-
-        
-    def forward(self, x: torch.Tensor, mixup_lambda = None, infer_mode = False, device=None):# out_feat_keys: List[str] = None):
-
-        n = int(x.shape[1] / 480000)
-        assert n * 480000 == x.shape[1]
-        x = rearrange(x, 'b (n t) -> (b n) t', n = n)
-        if not self.enable_fusion:
-            # x = x["waveform"].to(device=device, non_blocking=True)
-            x = x.to(device=device, non_blocking=True)
-            x = self.spectrogram_extractor(x)   # (batch_size, 1, time_steps, freq_bins)
-            x = self.logmel_extractor(x)    # (batch_size, 1, time_steps, mel_bins)
-            x = x.transpose(1, 3)
-            x = self.bn0(x)
-            x = x.transpose(1, 3)
-            if self.training:
-                x = self.spec_augmenter(x)
-
-            if self.training and mixup_lambda is not None:
-                x = do_mixup(x, mixup_lambda)
-                
-            x = self.reshape_wav2img(x)
-            # x = self.forward_features(x)
-            
-        longer_idx = None
-        frames_num = x.shape[2]        
-        x = self.patch_embed(x, longer_idx = longer_idx)
-        if self.ape:
-            x = x + self.absolute_pos_embed
-        x = self.pos_drop(x)
-        for i, layer in enumerate(self.layers):
-            x, attn = layer(x)
-        # for x
-        x = self.norm(x)
-        x = rearrange(x, '(b n) t c -> b (n t) c', n = n)
-        return x
-    
-        # B, N, C = x.shape
-        # SF = frames_num // (2 ** (len(self.depths) - 1)) // self.patch_stride[0]
-        # ST = frames_num // (2 ** (len(self.depths) - 1)) // self.patch_stride[1]
-        # x = x.permute(0,2,1).contiguous().reshape(B, C, SF, ST)
-        # B, C, F, T = x.shape
-        # # group 2D CNN
-        # c_freq_bin = F // self.freq_ratio
-        # x = x.reshape(B, C, F // c_freq_bin, c_freq_bin, T)
-        # x = x.permute(0,1,3,2,4).contiguous().reshape(B, C, c_freq_bin, -1)
-        # # get latent_output
-        # fine_grained_latent_output = torch.mean(x, dim = 2)
-        # fine_grained_latent_output = interpolate(fine_grained_latent_output.permute(0,2,1).contiguous(), 8 * self.patch_stride[1]) 
-        
-        # latent_output = self.avgpool(torch.flatten(x,2))
-        # latent_output = torch.flatten(latent_output, 1)
-
-        # # display the attention map, if needed
-
-        # x = self.tscam_conv(x)
-        # x = torch.flatten(x, 2) # B, C, T
- 
-        # fpx = interpolate(torch.sigmoid(x).permute(0,2,1).contiguous(), 8 * self.patch_stride[1]) 
-            
-        # x = self.avgpool(x)
-        # x = torch.flatten(x, 1)
-        # return x
-
-def create_htsat_model(audio_cfg, enable_fusion=False, fusion_type='None'):
-    try:
-
-        assert audio_cfg.model_name in ["tiny", "base", "large"], "model name for HTS-AT is wrong!"
-        if audio_cfg.model_name == "tiny":
-            model = HTSAT_Swin_Transformer(
-                spec_size=256,
-                patch_size=4,
-                patch_stride=(4,4),
-                num_classes=audio_cfg.class_num,
-                embed_dim=96,
-                depths=[2,2,6,2],
-                num_heads=[4,8,16,32],
-                window_size=8,
-                config = audio_cfg,
-                enable_fusion = enable_fusion,
-                fusion_type = fusion_type
-            )
-        elif audio_cfg.model_name == "base":
-            model = HTSAT_Swin_Transformer(
-                spec_size=256,
-                patch_size=4,
-                patch_stride=(4,4),
-                num_classes=audio_cfg.class_num,
-                embed_dim=128,
-                depths=[2,2,12,2],
-                num_heads=[4,8,16,32],
-                window_size=8,
-                config = audio_cfg,
-                enable_fusion = enable_fusion,
-                fusion_type = fusion_type
-            )
-        elif audio_cfg.model_name == "large":
-            model = HTSAT_Swin_Transformer(
-                spec_size=256,
-                patch_size=4,
-                patch_stride=(4,4),
-                num_classes=audio_cfg.class_num,
-                embed_dim=256,
-                depths=[2,2,12,2],
-                num_heads=[4,8,16,32],
-                window_size=8,
-                config = audio_cfg,
-                enable_fusion = enable_fusion,
-                fusion_type = fusion_type
-            )
-        
-        return model
-    except:
-        raise RuntimeError(f'Import Model for {audio_cfg.model_name} not found, or the audio cfg parameters are not enough.')
-        

src/mae_vit.py

@@ -1,303 +0,0 @@
-import torch
-from mmcls.models import VisionTransformer
-from torch import nn
-from torch.utils.checkpoint import checkpoint
-import copy
-
-def build_2d_sincos_position_embedding(patches_resolution,
-                                       embed_dims,
-                                       temperature=10000.,
-                                       cls_token=False):
-    """The function is to build position embedding for model to obtain the
-    position information of the image patches."""
-
-    if isinstance(patches_resolution, int):
-        patches_resolution = (patches_resolution, patches_resolution)
-
-    h, w = patches_resolution
-    grid_w = torch.arange(w, dtype=torch.float32)
-    grid_h = torch.arange(h, dtype=torch.float32)
-    grid_w, grid_h = torch.meshgrid(grid_w, grid_h)
-    assert embed_dims % 4 == 0, \
-        'Embed dimension must be divisible by 4.'
-    pos_dim = embed_dims // 4
-
-    omega = torch.arange(pos_dim, dtype=torch.float32) / pos_dim
-    omega = 1. / (temperature**omega)
-    out_w = torch.einsum('m,d->md', [grid_w.flatten(), omega])
-    out_h = torch.einsum('m,d->md', [grid_h.flatten(), omega])
-
-    pos_emb = torch.cat(
-        [
-            torch.sin(out_w),
-            torch.cos(out_w),
-            torch.sin(out_h),
-            torch.cos(out_h)
-        ],
-        dim=1,
-    )[None, :, :]
-
-    if cls_token:
-        cls_token_pe = torch.zeros([1, 1, embed_dims], dtype=torch.float32)
-        pos_emb = torch.cat([cls_token_pe, pos_emb], dim=1)
-
-    return pos_emb
-
-
-
-class MAEViT(VisionTransformer):
-    """Vision Transformer for MAE pre-training.
-
-    A PyTorch implement of: `An Image is Worth 16x16 Words: Transformers
-    for Image Recognition at Scale <https://arxiv.org/abs/2010.11929>`_
-
-    Args:
-        arch (str | dict): Vision Transformer architecture
-            Default: 'b'
-        img_size (int | tuple): Input image size
-        patch_size (int | tuple): The patch size
-        out_indices (Sequence | int): Output from which stages.
-            Defaults to -1, means the last stage.
-        drop_rate (float): Probability of an element to be zeroed.
-            Defaults to 0.
-        drop_path_rate (float): stochastic depth rate. Defaults to 0.
-        norm_cfg (dict): Config dict for normalization layer.
-            Defaults to ``dict(type='LN')``.
-        final_norm (bool): Whether to add a additional layer to normalize
-            final feature map. Defaults to True.
-        output_cls_token (bool): Whether output the cls_token. If set True,
-            `with_cls_token` must be True. Defaults to True.
-        interpolate_mode (str): Select the interpolate mode for position
-            embeding vector resize. Defaults to "bicubic".
-        patch_cfg (dict): Configs of patch embeding. Defaults to an empty dict.
-        layer_cfgs (Sequence | dict): Configs of each transformer layer in
-            encoder. Defaults to an empty dict.
-        mask_ratio (bool): The ratio of total number of patches to be masked.
-            Defaults to 0.75.
-        init_cfg (dict, optional): Initialization config dict.
-            Defaults to None.
-    """
-
-    arch_zoo = {
-        **dict.fromkeys(
-            ['mocov3-s', 'mocov3-small'], {
-                'embed_dims': 384,
-                'num_layers': 12,
-                'num_heads': 12,
-                'feedforward_channels': 1536,
-            }),
-        **dict.fromkeys(
-            ['b', 'base'], {
-                'embed_dims': 768,
-                'num_layers': 12,
-                'num_heads': 12,
-                'feedforward_channels': 3072
-            }),
-    }
-
-
-
-    def __init__(self,
-                 arch='b',
-                 img_size=224,
-                 patch_size=16,
-                 out_indices=-1,
-                 drop_rate=0,
-                 drop_path_rate=0,
-                 norm_cfg=dict(type='LN', eps=1e-6),
-                 final_norm=True,
-                 output_cls_token=False,
-                 interpolate_mode='bicubic',
-                 patch_cfg=dict(),
-                 layer_cfgs=dict(),
-                 gradientCKPT=False,
-                 mask_ratio=0.75,
-                 init_cfg=None):
-        super().__init__(
-            arch=arch,
-            img_size=img_size,
-            patch_size=patch_size,
-            out_indices=out_indices,
-            drop_rate=drop_rate,
-            drop_path_rate=drop_path_rate,
-            norm_cfg=norm_cfg,
-            final_norm=final_norm,
-            output_cls_token=output_cls_token,
-            interpolate_mode=interpolate_mode,
-            patch_cfg=patch_cfg,
-            layer_cfgs=layer_cfgs,
-            init_cfg=init_cfg)
-        self.gradientCKPT = gradientCKPT
-        self.pos_embed.requires_grad = False
-        self.mask_ratio = mask_ratio
-        self.num_patches = self.patch_resolution[0] * self.patch_resolution[1]
-        # self.mask_embedding = copy.deepcopy(self.patch_embed)
-        # self.mask_embedding.norm = None
-
-    def init_weights(self):
-        super(MAEViT, self).init_weights()
-        if not (isinstance(self.init_cfg, dict)
-                and self.init_cfg['type'] == 'Pretrained'):
-            # initialize position  embedding in backbone
-            pos_embed = build_2d_sincos_position_embedding(
-                self.patch_resolution,
-                self.pos_embed.shape[-1],
-                cls_token=True)
-            self.pos_embed.data.copy_(pos_embed.float())
-
-            w = self.patch_embed.projection.weight.data
-            torch.nn.init.xavier_uniform_(w.view([w.shape[0], -1]))
-
-            torch.nn.init.normal_(self.cls_token, std=.02)
-
-            self.apply(self._init_weights)
-
-        # mask_embedding transfers pixel level mask to token level
-        # self.mask_embedding.apply(self._init_mask_embedding)
-        # for para in self.mask_embedding.parameters():
-        #     para.requires_grad = False
-
-    def _init_mask_embedding(self,m):
-        if hasattr(m,'weight'):
-            nn.init.constant_(m.weight,1.0)
-        if hasattr(m, 'bias'):
-            nn.init.constant_(m.bias,0)
-
-    def _init_weights(self, m):
-
-        if isinstance(m, nn.Linear):
-            torch.nn.init.xavier_uniform_(m.weight)
-            if isinstance(m, nn.Linear) and m.bias is not None:
-                nn.init.constant_(m.bias, 0)
-        elif isinstance(m, nn.LayerNorm):
-            nn.init.constant_(m.bias, 0)
-            nn.init.constant_(m.weight, 1.0)
-
-    def random_masking(self, x, mask_ratio=0.75, attn_mask=None):
-        """Generate the mask for MAE Pre-training.
-
-        Args:
-            x (torch.tensor): Image with data augmentation applied.
-            mask_ratio (float): The mask ratio of total patches.
-                Defaults to 0.75.
-
-        Returns:
-            tuple[Tensor, Tensor, Tensor]: masked image, mask and the ids
-                to restore original image.
-
-            - x_masked (Tensor): masked image.
-            - mask (Tensor): mask used to mask image.
-            - ids_restore (Tensor): ids to restore original image.
-        """
-        N, L, D = x.shape  # batch, length, dim
-        len_keep = int(L * (1 - mask_ratio))
-
-        noise = torch.rand(N, L, device=x.device)  # noise in [0, 1]
-
-        # sort noise for each sample
-        ids_shuffle = torch.argsort(
-            noise, dim=1)  # ascend: small is keep, large is remove
-        ids_restore = torch.argsort(ids_shuffle, dim=1)
-
-        # keep the first subset
-        ids_keep = ids_shuffle[:, :len_keep]
-        x_masked = torch.gather(
-            x, dim=1, index=ids_keep.unsqueeze(-1).repeat(1, 1, D))
-        # modified_attn_mask = None if attn_mask is None else torch.gather(attn_mask,dim=1, index=ids_keep)
-
-        # generate the binary mask: 0 is keep, 1 is remove
-        mask = torch.ones([N, L], device=x.device)
-        mask[:, :len_keep] = 0
-        # unshuffle to get the binary mask
-        mask = torch.gather(mask, dim=1, index=ids_restore)
-
-        return x_masked, mask, ids_restore #, modified_attn_mask
-
-    def generate_mask(self, pixel_level_attn_mask):
-        '''
-        pixel_level_attn_mask: (0,1) attn mask with the same shape as img
-        '''
-        if pixel_level_attn_mask is None: return None
-        # H, W = patch_resolution
-        # B, C = pixel_level_attn_mask.shape[:2]
-        # attn_mask = torch.ones((B,C,H,W),device=pixel_level_attn_mask) 
-        # H_splited = torch.chunk(pixel_level_attn_mask, H, -2)
-        # HW_splited_mask = (torch.chunk(Hs, W, -1) for Hs in H_splited)
-
-        #         if HW_splited_mask[:,:,hi,wi].sum().item() == 0:
-        #             attn_mask[:,:,hi,wi] = 0
-
-        # mask_patches = self.mask_embedding(pixel_level_attn_mask)[0]
-        # attn_mask = mask_patches.sum(-1) != 0
-
-        # return attn_mask
-
-    def extract_feat(self, img ,attn_mask=None):
-        x, *_ = self.forward(img,attn_mask)
-        if self.output_cls_token:
-            return x[:,0,:]
-        else:
-            return torch.mean(x,dim=1)
-
-    def forward(self, x, attn_mask=None):
-        if attn_mask is not None: assert self.output_cls_token
-        
-        B = x.shape[0]
-        x = self.patch_embed(x)[0]
-        # add pos embed w/o cls token
-        x = x + self.pos_embed[:, 1:1+x.shape[1], :]
-        # masking: length -> length * mask_ratio
-        if True:
-            assert self.mask_ratio == 0.
-        else:
-            x, mask, ids_restore = self.random_masking(x, self.mask_ratio)
-
-        # append cls token
-        cls_token = self.cls_token + self.pos_embed[:, :1, :]
-        cls_tokens = cls_token.expand(B, -1, -1)
-        x = torch.cat((cls_tokens, x), dim=1)
-        x = self.drop_after_pos(x)
-        # if attn_mask is not None: 
-        #     attn_mask = torch.concat((torch.ones((B,1),device=attn_mask.device) , attn_mask),dim=1)
-
-        for i, layer in enumerate(self.layers):
-            if self.gradientCKPT:
-                x = checkpoint(layer,x) # ,attn_mask
-            else:
-                x = layer(x) # ,attn_mask
-            if i == len(self.layers) - 1 and self.final_norm:
-                x = self.norm1(x)
-        if True: 
-            return x
-        else:
-            return (x, mask, ids_restore)
-
-    def forward_generator(self, x, attn_mask=None):
-        if attn_mask is not None: assert self.output_cls_token
-        
-        B = x.shape[0]
-        x = self.patch_embed(x)[0]
-        # add pos embed w/o cls token
-        x = x + self.pos_embed[:, 1:1+x.shape[1], :]
-
-        # append cls token
-        cls_token = self.cls_token + self.pos_embed[:, :1, :]
-        cls_tokens = cls_token.expand(B, -1, -1)
-        x = torch.cat((cls_tokens, x), dim=1)
-        x = self.drop_after_pos(x)
-
-        for i, layer in enumerate(self.layers):
-            if self.gradientCKPT:
-                x = checkpoint(layer,x) # ,attn_mask
-            else:
-                x = layer(x) # ,attn_mask
-
-            if i == len(self.layers) - 1 and self.final_norm:
-                x = self.norm1(x)
-         
-            x = x if (new_x:=(yield x)) is None else new_x 
-
-            debug = False
-            if debug:
-                print(f'layer {i}-th forwarded')
- 

src/resampler.py

@@ -1,115 +0,0 @@
-# This file may have been modified by Bytedance Ltd. and/or its affiliates (“Bytedance's Modifications”).
-# All Bytedance's Modifications are Copyright (year) Bytedance Ltd. and/or its affiliates.
-
-import torch
-from torch import nn, einsum
-from einops import rearrange, repeat
-from einops_exts import rearrange_many, repeat_many
-
-
-def FeedForward(dim, mult=4):
-    inner_dim = int(dim * mult)
-    return nn.Sequential(
-        nn.LayerNorm(dim),
-        nn.Linear(dim, inner_dim, bias=False),
-        nn.GELU(),
-        nn.Linear(inner_dim, dim, bias=False)
-    )
-
-
-class PerceiverAttention(nn.Module):
-    def __init__(
-            self,
-            vision_width,
-            text_width,
-            dim_head=64,
-            heads=8
-    ):
-        super().__init__()
-
-        self.vision_width = vision_width
-        self.text_width = text_width
-
-        self.scale = dim_head ** -0.5
-        self.heads = heads
-        inner_dim = dim_head * heads
-
-        self.norm_media = nn.LayerNorm(vision_width)
-        self.norm_latents = nn.LayerNorm(text_width)
-
-        self.to_q = nn.Linear(text_width, inner_dim, bias=False)
-        self.to_kv = nn.Linear(vision_width, inner_dim * 2, bias=False)
-        self.to_out = nn.Linear(inner_dim, text_width, bias=False)
-
-    def forward(self, x, latents):
-        """
-        einstein notation
-        b - batch
-        t - time
-        n - sequence
-        d - dimension
-        """
-        x = self.norm_media(x)
-        latents = self.norm_latents(latents)
-
-        b, m, h = *x.shape[:2], self.heads
-
-        q = self.to_q(latents)
-
-        kv_input = x
-        k, v = self.to_kv(kv_input).chunk(2, dim=-1)
-
-        q, k, v = rearrange_many((q, k, v), 'b t n (h d) -> b h t n d', h=h)
-
-        q = q * self.scale
-
-        # attention
-        sim = einsum('... i d, ... j d  -> ... i j', q, k)
-
-        sim = sim - sim.amax(dim=-1, keepdim=True).detach()
-        attn = sim.softmax(dim=-1)
-
-        out = einsum('... i j, ... j d -> ... i d', attn, v)
-        out = rearrange(out, 'b h t n d -> b t n (h d)', h=h)
-        return self.to_out(out)
-
-
-class PerceiverResampler(nn.Module):
-    def __init__(
-            self,
-            vision_width,
-            text_width,
-            depth,
-            dim_head=64,
-            heads=8,
-            num_latents=64,
-            ff_mult=4,
-    ):
-        super().__init__()
-        self.latents = nn.Parameter(torch.randn(num_latents, text_width))
-
-        self.layers = nn.ModuleList([])
-        for _ in range(depth):
-            self.layers.append(nn.ModuleList([
-                PerceiverAttention(vision_width=vision_width, text_width=text_width, dim_head=dim_head, heads=heads),
-                FeedForward(dim=text_width, mult=ff_mult)
-            ]))
-
-        self.norm = nn.LayerNorm(text_width)
-
-    def forward(self, vision_embeds=None, vision_atts=None):
-        x = vision_embeds
-
-        if x.ndim == 3:
-            x = rearrange(x, 'b n d -> b 1 n d')
-
-        latents = repeat(self.latents, 'n d -> b m n d', b=x.shape[0], m=x.shape[1])
-
-        for attn, ff in self.layers:
-            latents = attn(x, latents) + latents
-            latents = ff(latents) + latents
-
-        v2t_feats = self.norm(latents).squeeze(dim=1)  # for image, squeeze dim=1
-        v2t_atts = torch.ones(v2t_feats.shape[:2], dtype=torch.long, device=v2t_feats.device)
-
-        return v2t_feats, v2t_atts

src/spectprompt.py

@@ -1,577 +0,0 @@
-import json
-import os
-import pdb
-from mmcv.cnn.bricks import padding
-import torch
-from torch import nn, einsum
-from typing import Optional, Dict, Tuple
-from src.mae_vit import MAEViT
-from src.htsat import HTSAT_Swin_Transformer, create_htsat_model
-from src.LMdecoder import LMDecoder, LMDecoder_qlora
-from src.vision_transformer import VisionTransformer
-from einops import rearrange, repeat
-from einops_exts import rearrange_many
-import inspect
-
-class ArgsHandler:
-    def __init__(self, module, funcname, fargs, fkargs):
-        self.fargs = list(fargs)
-        self.fkargs = fkargs
-        func = getattr(module, funcname)
-        fal_repr = f"{funcname}_argnames_list"
-        if (argns_list:=getattr(module, fal_repr, None)) is None:
-            self.func_sig = inspect.signature(func)
-            self.argnames_list = list(self.func_sig.parameters.keys())
-            setattr(module, fal_repr, self.argnames_list)
-        else:
-            self.argnames_list = argns_list
-
-    def get_arg(self, arg_name):
-        if arg_name in self.fkargs:
-            arg = self.fkargs[arg_name]
-        else:
-            arg = self.fargs[self.argnames_list.index(arg_name)]
-        return arg
-
-    def set_arg(self, arg_name, arg_value):
-        if arg_name in self.fkargs:
-            self.fkargs[arg_name] = arg_value
-        else:
-            self.fargs[self.argnames_list.index(arg_name)] = arg_value
-
-    def return_all_args(self,):
-        return tuple(self.fargs), self.fkargs
-
-class SquaredReLU(nn.Module):
-    """ squared ReLU activation function"""
-    def __init__(self):
-        super().__init__()
-
-    def forward(self, x):
-        return torch.pow(torch.relu(x), 2)
-
-def FeedForward(dim, out_dim, mult=4, act='gelu'):
-    """
-    lucidrains implementation, slightly modified with the act parameter.
-    """
-
-    acts = dict(
-        gelu=nn.GELU,
-        sqrelu=SquaredReLU,
-        relu=nn.ReLU
-    )
-
-    assert act in acts, f"act. can only be one of {acts.keys()}"
-
-    inner_dim = int(dim * mult)
-    return nn.Sequential(
-        nn.LayerNorm(dim),
-        nn.Linear(dim, inner_dim, bias=False),
-        acts[act](),
-        nn.Linear(inner_dim, out_dim, bias=False)
-    )
-
-
-class PerceiverAttentionLayer(nn.Module):
-    def __init__(
-            self,
-            *,
-            feat_dim,
-            latent_dim,
-            dim_head=64,
-            heads=8
-        ):
-        super().__init__()
-        self.scale = dim_head ** -0.5
-        self.heads = heads
-        self.dim_head = dim_head
-
-        inner_dim = dim_head * heads
-
-        # trainable components of PerceiverAttentionLayer
-        self.norm_media = nn.LayerNorm(feat_dim)
-        self.norm_latents = nn.LayerNorm(latent_dim)
-
-        self.to_q = nn.Linear(latent_dim, inner_dim, bias=False)
-        self.to_k = nn.Linear(feat_dim, inner_dim, bias=False)
-        self.to_v = nn.Linear(feat_dim, inner_dim, bias=False)
-        self.to_out = nn.Linear(inner_dim, latent_dim, bias=False)
-
-    def forward(self, features, latents):
-        """
-        Latent vectors are cross-attending to the visual features x.
-        :param x:       Tensor (n_batch, n_features, dim)
-                        visual features
-        :param latents: Tensor (n_batch, n_latents, dim)
-                        latent learnt vectors from which the queries are computed.
-                        Actually the same, just replicated in n_batch and n_frames dimension.
-        :return:        Tensor (n_batch, n_latents, dim)
-        """
-        assert features.ndim == 3
-        assert latents.ndim == 3
-        assert features.shape[0] == latents.shape[0]
-        #assert features.shape[2] == latents.shape[2]
-
-        n_heads = self.heads
-        n_batch, n_features, dim = features.shape
-        n_queries = latents.shape[1]
-
-        # layer normalization, as usual
-        x = self.norm_media(features)
-        latents = self.norm_latents(latents)
-
-        # queries
-        # compute the queries from the latents, for all attention heads simultaneously.
-        q = self.to_q(latents)
-        q = rearrange(q, 'b q (h d) -> b h q d', h=n_heads)
-        assert q.shape == torch.Size([n_batch, n_heads, n_queries, self.dim_head])
-
-        # keys and values for all attention heads
-            
-        '''
-        kv_input = torch.cat((x, latents), dim=-2)
-        n_features_latents = n_features + n_queries
-        '''
-
-        kv_input = x
-        n_features_latents = n_features
-
-        # keys, values
-        k = self.to_k(kv_input)
-        v = self.to_v(kv_input)
-        # batch, features, (heads, dim)
-
-        # split so we have an extra dimension for the heads
-        # q, k, v = rearrange_many((q, k, v), 'b t n (h d) -> b h t n d', h=h)
-        k, v = rearrange_many((k, v), 'b f (h d) -> b h f d', h=n_heads)
-        assert v.shape == torch.Size([n_batch, n_heads, n_features_latents, self.dim_head])
-
-        # scale queries?
-        q = q * self.scale
-
-        # attention
-
-        # attention scores
-        # sim = einsum('... i d, ... j d  -> ... i j', q, k)
-        sim = einsum('b h q d, b h f d -> b h q f', q, k)
-
-        # Is this for numerical stability? Does not affect the result of the softmax operation
-        sim = sim - sim.amax(dim=-1, keepdim=True).detach()
-        alphas = sim.softmax(dim=-1)
-
-        # out = einsum('... i j, ... j d -> ... i d', alphas, v)
-        out = einsum('b h q f, b h f v -> b h q v', alphas, v)
-
-        # out = rearrange(out, 'b h t n d -> b t n (h d)', h=h)
-        out = rearrange(out, 'b h q v -> b q (h v)')
-        return self.to_out(out)
-
-
-class SpectPrompt(nn.Module):
-    """
-
-    Args:
-        backbone (dict): Config dict for encoder. Defaults to None.
-        neck (dict): Config dict for encoder. Defaults to None.
-        head (dict): Config dict for loss functions. Defaults to None.
-        init_cfg (dict, optional): Config dict for weight initialization.
-            Defaults to None.
-    """
-
-    def __init__(self,
-                 backbone: dict,
-                 neck: dict,
-                 live_long_learning:bool=False, # TODO: costumize para or module
-                 ) -> None:
-        super().__init__()
-        assert backbone is not None
-        bk_name = backbone.pop('name')
-        self.bk_name = bk_name
-        if bk_name == 'MAEViT':
-            ckpt_path = backbone.pop('ckpt') if 'ckpt' in backbone else None
-            self.backbone = MAEViT(**backbone)
-            if ckpt_path is not None:
-                ckpt = torch.load( ckpt_path,'cpu')
-                self.backbone.load_state_dict(ckpt['state_dict'])
-                
-        elif bk_name == 'HTSAT':
-            ckpt_path = backbone.pop('ckpt') if 'ckpt' in backbone else None
-            self.backbone = create_htsat_model(backbone)
-            if ckpt_path is not None:
-                ckpt = torch.load( ckpt_path,'cpu')
-                self.backbone.load_state_dict(ckpt['state_dict'])
-        elif bk_name == 'qformer':
-            raise NotImplemented        
-        else:
-            raise NotImplemented
-
-
-
-        # neck["num_patches"] = self.backbone.num_patches
-        # neck["patch_resolution"] = self.backbone.patch_resolution
-        assert neck is not None
-        nk_name = neck.pop('name')
-        if nk_name == 'LMDecoder':
-            self.neck = LMDecoder(**neck)
-        elif nk_name == 'LMDecoder_qlora':
-            self.neck = LMDecoder_qlora(**neck)
-        else: 
-            raise NotImplemented
-        self.config = self.neck.LMconfig # TODO
-
-        '''
-        self.ae_proj = nn.Linear(
-            768,  self.config.hidden_size
-        )
-        '''
-        
-        ## TODO
-
-        #self.neck.lm.apply(lambda m:m.gradient_checkpointing=True)
-        self.neck.lm.model.gradient_checkpointing = False
-
-        self.register_buffer('ones', torch.ones((1,4096), dtype=torch.long), persistent=False)
-        self.graft_adapter()
-        self.init_weights()
-        
-        if False:
-            self.patch_llm()
-        self.first_run = True
-    
-    def graft_adapter(self):
-        adapter_latent_len = 32
-        self.adapter_latent_len = adapter_latent_len
-        self.adapter_latent = nn.Parameter(torch.rand((1,adapter_latent_len, self.config.hidden_size), \
-                                                     dtype=torch.float))
-        resampler_latent_len = 32
-        self.resampler_latent_len = resampler_latent_len
-        self.resampler_latent = nn.Parameter(torch.rand((1,resampler_latent_len, self.config.hidden_size), \
-                                                     dtype=torch.float))
-        ## TODO
-        # self.adapter.pre_bn = torch.nn.BatchNorm1d(4096, affine=True)
-
-        self.adapter = nn.ModuleList([])
-        
-        ff_mult = 4
-        heads=8
-        dim_head=512
-        act='gelu'
-
-        lm_dim = self.config.hidden_size
-        if self.bk_name == 'HTSAT':
-            feat_dim = 1024
-            depth = len(self.backbone.layers[2].blocks)
-        else:
-            feat_dim = 768
-            depth = int(len(self.neck.lm.model.layers)/2) # 16
-        for idx in range(depth):
-            self.adapter.append(nn.ModuleList([
-                Adapter(input_size=self.config.hidden_size),
-                # PerceiverAttentionLayer(feat_dim=feat_dim, latent_dim=lm_dim, dim_head=dim_head, heads=heads),
-                # FeedForward(dim=lm_dim, out_dim=lm_dim, mult=1, act=act),
-                #FeedForward(dim=self.dim, out_dim=768, mult=ff_mult, act=act) if idx != depth-1 else nn.Identity()
-            ])) 
-
-        self.samplers = nn.ModuleList([]) # add
-        for _ in range(3):
-            self.samplers.append(nn.ModuleList([
-                PerceiverAttentionLayer(feat_dim=feat_dim, latent_dim=lm_dim, dim_head=64, heads=heads),
-                FeedForward(dim=lm_dim, out_dim=lm_dim, mult=4),
-            ]))
-        self.norm = nn.LayerNorm(lm_dim)
-
-        # self.agate_list = nn.ParameterList([])
-        # for i in range(len(self.neck.lm.model.layers)):
-        #     self.agate_list.append(nn.Parameter(torch.zeros(lm_dim)))
-
-
-        
-    def init_weights(self):
-        try:
-            super().init_weights()
-        except:
-            pass
-            # import traceback
-            # traceback.print_exc()
-        if getattr(self, 'adapter_latent', None) is not None:
-            self.adapter_latent.data.normal_(mean=0.0, std=0.02)
-        if getattr(self, 'resampler_latent', None) is not None:
-            self.adapter_latent.data.normal_(mean=0.0, std=0.02)
-
-    def forward_resampler(self, x):
-        # b, 768, 512
-        latents = repeat(self.resampler_latent, 'b n d -> (bs b) n d', bs=x.shape[0])
-        for attn, ff in self.samplers:
-            latents = attn(x, latents) + latents
-            latents = ff(latents) + latents
-        v2t_feats = self.norm(latents) # 
-        # v2t_atts = torch.ones(v2t_feats.shape[:2], dtype=torch.long, device=v2t_feats.device)
-        return v2t_feats # bs, 32, dim_llm
-
-
-    def hook_adapter(self, audio_embedding, lm, v2t_feats):
-        
-        class PHooker:
-            # model = self.backbone
-            # mgtr = self.backbone.forward_generator(spectrogram)
-            adapter = self.adapter
-            y = v2t_feats
-            handles_list = list()
-            cnter = 0
-            def layer_prehook(self, m, margs, mkargs):
-                ahl = ArgsHandler(m, 'forward', margs, mkargs)
-                
-                # print(self.cnter)
-                
-                # if self.cnter>=16:
-                #     self.cnter+=1
-                #     return None
-                adapt = self.adapter[self.cnter][0]
-
-                hs = ahl.get_arg("hidden_states")
-                adapter_residual = hs
-                neo_hs = adapt(hs, adapter_residual)
-
-                self.cnter+=1
-                ahl.set_arg("hidden_states", neo_hs)
-                return ahl.return_all_args()
-            def first_layer_prehook(self, m, margs, mkargs):
-                ahl = ArgsHandler(m, 'forward', margs, mkargs)
-                neo_lm_latents = self.y #  torch.Size([128, 32, 4096])
-                hs = ahl.get_arg("hidden_states") # torch.Size([128, 87, 4096])
-                hs_msk = self.lm_ahl.get_arg("input_ids") < 0 # torch.Size([128, 87]) [False,, True*32, False,,]
-                # __import__('pdb').set_trace()
-                neo_hs = hs.masked_scatter(hs_msk.unsqueeze(-1), neo_lm_latents)  # resampler hooker直接替换
-                ahl.set_arg("hidden_states", neo_hs)
-                return ahl.return_all_args()
-
-            def lm_prehook(self, m, margs, mkargs):
-                self.lm_ahl = ArgsHandler(m, 'forward', margs, mkargs)
-                return None
-            def last_layer_hook(self, m, margs, mkargs):
-                # __import__('pdb').set_trace()
-                self.cnter = 0
-
-        if getattr(lm,'phooker',False):
-            for _ in lm.phooker.handles_list:
-                _.remove()
-            del lm.phooker
-            lm.phooker = None
-        phooker = PHooker()
-        phooker.handles_list.append(lm.register_forward_pre_hook(phooker.lm_prehook, with_kwargs=True))
-        # 第一层插入
-        phooker.handles_list.append(lm.model.layers[0].register_forward_pre_hook(phooker.first_layer_prehook, with_kwargs=True))
-       
-        for ii in range(1,len(lm.model.layers),2):
-            l = lm.model.layers[ii]
-            handle = l.register_forward_pre_hook(phooker.layer_prehook, with_kwargs=True)
-            phooker.handles_list.append(handle)
-        phooker.handles_list.append(lm.model.layers[-1].register_forward_pre_hook(phooker.last_layer_hook, with_kwargs=True))
-        lm.phooker = phooker 
-        return None
-
-
-
-    def prepare_ids(self, batch, audio_ids):
-        toker = self.neck.tokenizer
-        # for idx, l in enumerate(self.neck.lm.model.layers):
-        #     l.agate = self.agate_list[idx].clone() ## should clone the parameter
-         
-        with torch.no_grad():
-            
-            input_ids = batch['input_ids']
-            att_msk = batch['attention_mask']
-            au_crds = batch['audio_crds']
-            ans_crds = batch['ans_crds']
-            bsz = input_ids.shape[0]
-            # __import__('pdb').set_trace()
-            ## TODO
-            merged_ids, merged_msk, label_ids = list(), list(), list()
-            for i in range(bsz):
-                # cur_merged_ids = torch.cat([input_ids[i,:au_crds[i]], -1 * audio_ids[i] -1, input_ids[i,au_crds[i]:]])
-                cur_merged_ids = torch.cat([ -1 * audio_ids[i] -1, input_ids[i,au_crds[i]:]])
-                
-                # cur_au_msk = self.ones[:,:audio_ids.shape[1]][0].clone().type_as(att_msk).detach()
-                cur_au_msk = torch.ones(audio_ids.shape[1], device=audio_ids.device)
-                # cur_merged_msk = torch.cat([att_msk[i,:au_crds[i]], cur_au_msk, att_msk[i,au_crds[i]:]])
-                cur_merged_msk = torch.cat([ cur_au_msk, att_msk[i,au_crds[i]:]])
-                cur_label_ids = cur_merged_ids.clone().detach()
-                cur_label_ids[:audio_ids.shape[1]+ans_crds[i]] = -100
-
-                merged_ids.append(cur_merged_ids)
-                merged_msk.append(cur_merged_msk)
-                label_ids.append(cur_label_ids)
-
-            merged_ids = torch.stack(merged_ids, dim=0) 
-            merged_msk = torch.stack(merged_msk, dim=0) 
-            label_ids = torch.stack(label_ids, dim=0) 
-
-            assert merged_ids.shape[0] == bsz
-            assert merged_ids.shape == merged_msk.shape
-
-            label_msk = merged_msk.clone()
-            assert label_msk.shape == merged_msk.shape
-            assert merged_msk[:,-1].max() == 1
-
-            for i in range(len(ans_crds)):
-                label_ids[i,:audio_ids.shape[1]+ans_crds[i]].fill_(-100)
-            
-             
-            merged_labels = label_ids
-            merged_ids[merged_ids.eq(-100)] = toker.pad_token_id
-
-        return merged_ids, merged_msk, merged_labels
-
-    def forward(self, batch, **kwargs):
-        """Forward computation during training.
-
-        Args:
-            img (torch.Tensor): Input images of shape (N, C, H, W).
-            kwargs: Any keyword arguments to be used to forward.
-        Returns:
-            Dict[str, torch.Tensor]: A dictionary of loss components.
-        """
-
-        bsz = len(batch['input_ids'])
-        device = batch['input_ids'].device
-        float_type = next(self.parameters()).dtype
-        spectrogram = batch['spectrogram'].type(float_type)
-        audio_embedding = self.backbone(spectrogram).detach() # b, 768, 512
-        resampler_feats = self.forward_resampler(audio_embedding)
-        self.hook_adapter(audio_embedding, self.neck.lm, resampler_feats) # add hook
-        
-        # self.hook_resapmler(resampler_feats, self.neck.lm)
-        
-        audio_ids = torch.arange(self.adapter_latent.shape[1]).unsqueeze(0).repeat((bsz, 1)).long().to(device)
-        assert audio_ids.max() < 100
-        merged_ids, merged_msk, merged_labels = self.prepare_ids(batch, audio_ids)
-        
-        try:
-            assert merged_ids.shape == merged_labels.shape
-            outs = self.neck(input_ids=merged_ids.contiguous().long(),
-                    flatten_embs=self.adapter_latent.flatten(0,1), # 32, 4096
-                    # flatten_embs = resampler_feats.flatten(0,1), # b, 32, 4096
-                    attention_mask=merged_msk.contiguous().long(), 
-                    labels=merged_labels.contiguous().long(), use_cache=False)
-        except Exception as e:
-            import traceback
-            traceback.print_exc()
-            __import__('remote_pdb').set_trace()
-        #outs.hidden_logits = self.hidden_logits
-
-        ## TODO
-        if eval(os.environ.get("doing_eval", 'False')):
-            outs.merged_ids = merged_ids.cpu()
-            outs.merged_labels = merged_labels.cpu()
-
-        return outs
-
-
-    def forward_test(self, batch, **kwargs):
-        """Forward computation during training.
-
-        Args:
-            img (torch.Tensor): Input images of shape (N, C, H, W).
-            kwargs: Any keyword arguments to be used to forward.
-        Returns:
-            Dict[str, torch.Tensor]: A dictionary of loss components.
-        """
-
-        assert self.training == False
-
-        bsz = len(batch['input_ids'])
-        device = batch['input_ids'].device
-        float_type = next(self.parameters()).dtype
-        spectrogram = batch['spectrogram'].type(float_type)
-        audio_embedding = self.backbone(spectrogram).detach() # b, 768, 512
-        resampler_feats = self.forward_resampler(audio_embedding)
-        self.hook_adapter(audio_embedding, self.neck.lm, resampler_feats) # add hook
-        # self.extract_features(batch, self.neck.lm)
-        audio_ids = torch.arange(self.adapter_latent.shape[1]).unsqueeze(0).repeat((bsz, 1)).long().to(device)
-        assert audio_ids.max() < 100
-
-        merged_ids, merged_msk, merged_labels = self.prepare_ids(batch, audio_ids)
-        au_crds = batch['audio_crds']
-        ans_crds = batch['ans_crds']
-        
-        aid_len = audio_ids.shape[-1]
-        
-
-        toker = self.neck.tokenizer
-        with torch.no_grad():
-
-            ## TODO
-            pad_token = toker.encode(self.neck.tokenizer.eos_token)[0]
-            padded_merged_ids = self.ones[:, :aid_len+max(ans_crds)].repeat(bsz, 1).clone().detach() * pad_token
-            for i in range(bsz):
-            # for i in range(1):
-                assert au_crds[i] <= ans_crds[i]
-                cur_ids = merged_ids[i][:aid_len+ans_crds[i]]
-                padded_merged_ids[i][max(ans_crds)-ans_crds[i]:] = cur_ids
-        # __import__('pdb').set_trace()
-        outs = self.neck.generate(padded_merged_ids, self.adapter_latent.flatten(0,1))
-        #outs.hidden_logits = self.hidden_logits
-
-        return outs
-
-
-
-import torch
-from torch import nn
-
-from transformers.activations import ACT2FN
-
-class Adapter(nn.Module):
-    """
-    Implementation of a sequential bottleneck adapter block.
-    """
-    def __init__(
-        self,
-        input_size,
-        down_sample=None,
-    ):
-        super().__init__()
-
-        self.input_size = input_size
-
-        # if a downsample size is not passed, we just half the size of the original input
-        self.down_sample = down_sample
-        if down_sample is None:
-            self.down_sample = self.input_size // 2
-
-        self.adapter_norm_before = nn.LayerNorm(self.input_size)
-        self.adapter_down = nn.Linear(self.input_size, self.down_sample)
-        self.non_linearity = ACT2FN["silu"]
-
-        # Up projection to input size
-        self.adapter_up = nn.Linear(self.down_sample, self.input_size)
-
-        # Additional scaling factor (from He et al. (2021))
-        self.scaling = nn.Parameter(torch.ones(1))   
-
-        self.adapter_down.apply(self._init_weights)
-        self.adapter_up.apply(self._init_weights)
-
-    def forward(self, x, residual_input):  # , residual_input=None):
-
-        down = self.non_linearity(self.adapter_down(self.adapter_norm_before(x)))
-
-        up = self.adapter_up(down)
-        up = up * self.scaling
-        output = up
-
-        output = output + residual_input
-
-        return output
-
-    @staticmethod
-    def _init_weights(module):
-        """Initialize the weights."""
-        if isinstance(module, (nn.Linear, nn.Embedding)):
-            # std defaults to 0.02, this might need to be changed
-            module.weight.data.normal_(mean=0.0, std=0.02)
-        elif isinstance(module, nn.LayerNorm):
-            module.bias.data.zero_()
-            module.weight.data.fill_(1.0)
-        if isinstance(module, nn.Linear) and module.bias is not None:
-            module.bias.data.zero_()

src/stft.py

@@ -1,1111 +0,0 @@
-import math
-import argparse
-
-import librosa
-import numpy as np
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from torch.nn.parameter import Parameter
-
-
-class DFTBase(nn.Module):
-    def __init__(self):
-        r"""Base class for DFT and IDFT matrix.
-        """
-        super(DFTBase, self).__init__()
-
-    def dft_matrix(self, n):
-        (x, y) = np.meshgrid(np.arange(n), np.arange(n))
-        omega = np.exp(-2 * np.pi * 1j / n)
-        W = np.power(omega, x * y)  # shape: (n, n)
-        return W
-
-    def idft_matrix(self, n):
-        (x, y) = np.meshgrid(np.arange(n), np.arange(n))
-        omega = np.exp(2 * np.pi * 1j / n)
-        W = np.power(omega, x * y)  # shape: (n, n)
-        return W
-
-
-class DFT(DFTBase):
-    def __init__(self, n, norm):
-        r"""Calculate discrete Fourier transform (DFT), inverse DFT (IDFT, 
-        right DFT (RDFT) RDFT, and inverse RDFT (IRDFT.) 
-
-        Args:
-          n: fft window size
-          norm: None | 'ortho'
-        """
-        super(DFT, self).__init__()
-
-        self.W = self.dft_matrix(n)
-        self.inv_W = self.idft_matrix(n)
-
-        self.W_real = torch.Tensor(np.real(self.W))
-        self.W_imag = torch.Tensor(np.imag(self.W))
-        self.inv_W_real = torch.Tensor(np.real(self.inv_W))
-        self.inv_W_imag = torch.Tensor(np.imag(self.inv_W))
-
-        self.n = n
-        self.norm = norm
-
-    def dft(self, x_real, x_imag):
-        r"""Calculate DFT of a signal.
-
-        Args:
-            x_real: (n,), real part of a signal
-            x_imag: (n,), imag part of a signal
-
-        Returns:
-            z_real: (n,), real part of output
-            z_imag: (n,), imag part of output
-        """
-        z_real = torch.matmul(x_real, self.W_real) - torch.matmul(x_imag, self.W_imag)
-        z_imag = torch.matmul(x_imag, self.W_real) + torch.matmul(x_real, self.W_imag)
-        # shape: (n,)
-
-        if self.norm is None:
-            pass
-        elif self.norm == 'ortho':
-            z_real /= math.sqrt(self.n)
-            z_imag /= math.sqrt(self.n)
-
-        return z_real, z_imag
-
-    def idft(self, x_real, x_imag):
-        r"""Calculate IDFT of a signal.
-
-        Args:
-            x_real: (n,), real part of a signal
-            x_imag: (n,), imag part of a signal
-        Returns:
-            z_real: (n,), real part of output
-            z_imag: (n,), imag part of output
-        """
-        z_real = torch.matmul(x_real, self.inv_W_real) - torch.matmul(x_imag, self.inv_W_imag)
-        z_imag = torch.matmul(x_imag, self.inv_W_real) + torch.matmul(x_real, self.inv_W_imag)
-        # shape: (n,)
-
-        if self.norm is None:
-            z_real /= self.n
-        elif self.norm == 'ortho':
-            z_real /= math.sqrt(n)
-            z_imag /= math.sqrt(n)
-
-        return z_real, z_imag
-
-    def rdft(self, x_real):
-        r"""Calculate right RDFT of signal.
-
-        Args:
-            x_real: (n,), real part of a signal
-            x_imag: (n,), imag part of a signal
-
-        Returns:
-            z_real: (n // 2 + 1,), real part of output
-            z_imag: (n // 2 + 1,), imag part of output
-        """
-        n_rfft = self.n // 2 + 1
-        z_real = torch.matmul(x_real, self.W_real[..., 0 : n_rfft])
-        z_imag = torch.matmul(x_real, self.W_imag[..., 0 : n_rfft])
-        # shape: (n // 2 + 1,)
-
-        if self.norm is None:
-            pass
-        elif self.norm == 'ortho':
-            z_real /= math.sqrt(self.n)
-            z_imag /= math.sqrt(self.n)
-
-        return z_real, z_imag
-
-    def irdft(self, x_real, x_imag):
-        r"""Calculate IRDFT of signal.
-        
-        Args:
-            x_real: (n // 2 + 1,), real part of a signal
-            x_imag: (n // 2 + 1,), imag part of a signal
-
-        Returns:
-            z_real: (n,), real part of output
-            z_imag: (n,), imag part of output
-        """
-        n_rfft = self.n // 2 + 1
-
-        flip_x_real = torch.flip(x_real, dims=(-1,))
-        flip_x_imag = torch.flip(x_imag, dims=(-1,))
-        # shape: (n // 2 + 1,)
-
-        x_real = torch.cat((x_real, flip_x_real[..., 1 : n_rfft - 1]), dim=-1)
-        x_imag = torch.cat((x_imag, -1. * flip_x_imag[..., 1 : n_rfft - 1]), dim=-1)
-        # shape: (n,)
-
-        z_real = torch.matmul(x_real, self.inv_W_real) - torch.matmul(x_imag, self.inv_W_imag)
-        # shape: (n,)
-
-        if self.norm is None:
-            z_real /= self.n
-        elif self.norm == 'ortho':
-            z_real /= math.sqrt(n)
-
-        return z_real
-
-
-class STFT(DFTBase):
-    def __init__(self, n_fft=2048, hop_length=None, win_length=None,
-        window='hann', center=True, pad_mode='reflect', freeze_parameters=True):
-        r"""PyTorch implementation of STFT with Conv1d. The function has the 
-        same output as librosa.stft.
-
-        Args:
-            n_fft: int, fft window size, e.g., 2048
-            hop_length: int, hop length samples, e.g., 441
-            win_length: int, window length e.g., 2048
-            window: str, window function name, e.g., 'hann'
-            center: bool
-            pad_mode: str, e.g., 'reflect'
-            freeze_parameters: bool, set to True to freeze all parameters. Set
-                to False to finetune all parameters.
-        """
-        super(STFT, self).__init__()
-
-        assert pad_mode in ['constant', 'reflect']
-
-        self.n_fft = n_fft
-        self.hop_length = hop_length
-        self.win_length = win_length
-        self.window = window
-        self.center = center
-        self.pad_mode = pad_mode
-
-        # By default, use the entire frame.
-        if self.win_length is None:
-            self.win_length = n_fft
-
-        # Set the default hop, if it's not already specified.
-        if self.hop_length is None:
-            self.hop_length = int(self.win_length // 4)
-
-        fft_window = librosa.filters.get_window(window, self.win_length, fftbins=True)
-
-        # Pad the window out to n_fft size.
-        fft_window = librosa.util.pad_center(fft_window, size=n_fft)
-
-        # DFT & IDFT matrix.
-        self.W = self.dft_matrix(n_fft)
-
-        out_channels = n_fft // 2 + 1
-
-        self.conv_real = nn.Conv1d(in_channels=1, out_channels=out_channels,
-            kernel_size=n_fft, stride=self.hop_length, padding=0, dilation=1,
-            groups=1, bias=False)
-
-        self.conv_imag = nn.Conv1d(in_channels=1, out_channels=out_channels,
-            kernel_size=n_fft, stride=self.hop_length, padding=0, dilation=1,
-            groups=1, bias=False)
-
-        # Initialize Conv1d weights.
-        self.conv_real.weight.data.copy_(torch.Tensor(
-            np.real(self.W[:, 0 : out_channels] * fft_window[:, None]).T)[:, None, :])
-        # (n_fft // 2 + 1, 1, n_fft)
-
-        self.conv_imag.weight.data.copy_(torch.Tensor(
-            np.imag(self.W[:, 0 : out_channels] * fft_window[:, None]).T)[:, None, :])
-        # (n_fft // 2 + 1, 1, n_fft)
-
-        if freeze_parameters:
-            for param in self.parameters():
-                param.requires_grad = False
-
-    def forward(self, input):
-        r"""Calculate STFT of batch of signals.
-
-        Args: 
-            input: (batch_size, data_length), input signals.
-
-        Returns:
-            real: (batch_size, 1, time_steps, n_fft // 2 + 1)
-            imag: (batch_size, 1, time_steps, n_fft // 2 + 1)
-        """
-
-        x = input[:, None, :]   # (batch_size, channels_num, data_length)
-
-        if self.center:
-            x = F.pad(x, pad=(self.n_fft // 2, self.n_fft // 2), mode=self.pad_mode)
-
-        real = self.conv_real(x)
-        imag = self.conv_imag(x)
-        # (batch_size, n_fft // 2 + 1, time_steps)
-
-        real = real[:, None, :, :].transpose(2, 3)
-        imag = imag[:, None, :, :].transpose(2, 3)
-        # (batch_size, 1, time_steps, n_fft // 2 + 1)
-
-        return real, imag
-
-
-def magphase(real, imag):
-    r"""Calculate magnitude and phase from real and imag part of signals.
-
-    Args:
-        real: tensor, real part of signals
-        imag: tensor, imag part of signals
-
-    Returns:
-        mag: tensor, magnitude of signals
-        cos: tensor, cosine of phases of signals
-        sin: tensor, sine of phases of signals
-    """
-    mag = (real ** 2 + imag ** 2) ** 0.5
-    cos = real / torch.clamp(mag, 1e-10, np.inf)
-    sin = imag / torch.clamp(mag, 1e-10, np.inf)
-
-    return mag, cos, sin
-
-
-class ISTFT(DFTBase):
-    def __init__(self, n_fft=2048, hop_length=None, win_length=None,
-        window='hann', center=True, pad_mode='reflect', freeze_parameters=True, 
-        onnx=False, frames_num=None, device=None):
-        """PyTorch implementation of ISTFT with Conv1d. The function has the 
-        same output as librosa.istft.
-
-        Args:
-            n_fft: int, fft window size, e.g., 2048
-            hop_length: int, hop length samples, e.g., 441
-            win_length: int, window length e.g., 2048
-            window: str, window function name, e.g., 'hann'
-            center: bool
-            pad_mode: str, e.g., 'reflect'
-            freeze_parameters: bool, set to True to freeze all parameters. Set
-                to False to finetune all parameters.
-            onnx: bool, set to True when exporting trained model to ONNX. This
-                will replace several operations to operators supported by ONNX.
-            frames_num: None | int, number of frames of audio clips to be 
-                inferneced. Only useable when onnx=True.
-            device: None | str, device of ONNX. Only useable when onnx=True.
-        """
-        super(ISTFT, self).__init__()
-
-        assert pad_mode in ['constant', 'reflect']
-
-        if not onnx:
-            assert frames_num is None, "When onnx=False, frames_num must be None!"
-            assert device is None, "When onnx=False, device must be None!"
-
-        self.n_fft = n_fft
-        self.hop_length = hop_length
-        self.win_length = win_length
-        self.window = window
-        self.center = center
-        self.pad_mode = pad_mode
-        self.onnx = onnx
-
-        # By default, use the entire frame.
-        if self.win_length is None:
-            self.win_length = self.n_fft
-
-        # Set the default hop, if it's not already specified.
-        if self.hop_length is None:
-            self.hop_length = int(self.win_length // 4)
-
-        # Initialize Conv1d modules for calculating real and imag part of DFT.
-        self.init_real_imag_conv()
-
-        # Initialize overlap add window for reconstruct time domain signals.
-        self.init_overlap_add_window()
-
-        if self.onnx:
-            # Initialize ONNX modules.
-            self.init_onnx_modules(frames_num, device)
-        
-        if freeze_parameters:
-            for param in self.parameters():
-                param.requires_grad = False
-
-    def init_real_imag_conv(self):
-        r"""Initialize Conv1d for calculating real and imag part of DFT.
-        """
-        self.W = self.idft_matrix(self.n_fft) / self.n_fft
-
-        self.conv_real = nn.Conv1d(in_channels=self.n_fft, out_channels=self.n_fft,
-            kernel_size=1, stride=1, padding=0, dilation=1,
-            groups=1, bias=False)
-
-        self.conv_imag = nn.Conv1d(in_channels=self.n_fft, out_channels=self.n_fft,
-            kernel_size=1, stride=1, padding=0, dilation=1,
-            groups=1, bias=False)
-
-        ifft_window = librosa.filters.get_window(self.window, self.win_length, fftbins=True)
-        # (win_length,)
-
-        # Pad the window to n_fft
-        ifft_window = librosa.util.pad_center(ifft_window, size=self.n_fft)
-
-        self.conv_real.weight.data = torch.Tensor(
-            np.real(self.W * ifft_window[None, :]).T)[:, :, None]
-        # (n_fft // 2 + 1, 1, n_fft)
-
-        self.conv_imag.weight.data = torch.Tensor(
-            np.imag(self.W * ifft_window[None, :]).T)[:, :, None]
-        # (n_fft // 2 + 1, 1, n_fft)
-
-    def init_overlap_add_window(self):
-        r"""Initialize overlap add window for reconstruct time domain signals.
-        """
-        
-        ola_window = librosa.filters.get_window(self.window, self.win_length, fftbins=True)
-        # (win_length,)
-
-        ola_window = librosa.util.normalize(ola_window, norm=None) ** 2
-        ola_window = librosa.util.pad_center(ola_window, size=self.n_fft)
-        ola_window = torch.Tensor(ola_window)
-
-        self.register_buffer('ola_window', ola_window)
-        # (win_length,)
-
-    def init_onnx_modules(self, frames_num, device):
-        r"""Initialize ONNX modules.
-
-        Args:
-            frames_num: int
-            device: str | None
-        """
-
-        # Use Conv1d to implement torch.flip(), because torch.flip() is not 
-        # supported by ONNX.
-        self.reverse = nn.Conv1d(in_channels=self.n_fft // 2 + 1,
-            out_channels=self.n_fft // 2 - 1, kernel_size=1, bias=False)
-
-        tmp = np.zeros((self.n_fft // 2 - 1, self.n_fft // 2 + 1, 1))
-        tmp[:, 1 : -1, 0] = np.array(np.eye(self.n_fft // 2 - 1)[::-1])
-        self.reverse.weight.data = torch.Tensor(tmp)
-        # (n_fft // 2 - 1, n_fft // 2 + 1, 1)
-
-        # Use nn.ConvTranspose2d to implement torch.nn.functional.fold(), 
-        # because torch.nn.functional.fold() is not supported by ONNX.
-        self.overlap_add = nn.ConvTranspose2d(in_channels=self.n_fft,
-            out_channels=1, kernel_size=(self.n_fft, 1), stride=(self.hop_length, 1), bias=False)
-
-        self.overlap_add.weight.data = torch.Tensor(np.eye(self.n_fft)[:, None, :, None])
-        # (n_fft, 1, n_fft, 1)
-
-        if frames_num:
-            # Pre-calculate overlap-add window sum for reconstructing signals
-            # when using ONNX.
-            self.ifft_window_sum = self._get_ifft_window_sum_onnx(frames_num, device)
-        else:
-            self.ifft_window_sum = []
-
-    def forward(self, real_stft, imag_stft, length):
-        r"""Calculate inverse STFT.
-
-        Args:
-            real_stft: (batch_size, channels=1, time_steps, n_fft // 2 + 1)
-            imag_stft: (batch_size, channels=1, time_steps, n_fft // 2 + 1)
-            length: int
-        
-        Returns:
-            real: (batch_size, data_length), output signals.
-        """
-        assert real_stft.ndimension() == 4 and imag_stft.ndimension() == 4
-        batch_size, _, frames_num, _ = real_stft.shape
-
-        real_stft = real_stft[:, 0, :, :].transpose(1, 2)
-        imag_stft = imag_stft[:, 0, :, :].transpose(1, 2)
-        # (batch_size, n_fft // 2 + 1, time_steps)
-
-        # Get full stft representation from spectrum using symmetry attribute.
-        if self.onnx:
-            full_real_stft, full_imag_stft = self._get_full_stft_onnx(real_stft, imag_stft)
-        else:
-            full_real_stft, full_imag_stft = self._get_full_stft(real_stft, imag_stft)
-        # full_real_stft: (batch_size, n_fft, time_steps)
-        # full_imag_stft: (batch_size, n_fft, time_steps)
-
-        # Calculate IDFT frame by frame.
-        s_real = self.conv_real(full_real_stft) - self.conv_imag(full_imag_stft)
-        # (batch_size, n_fft, time_steps)
-
-        # Overlap add signals in frames to reconstruct signals.
-        if self.onnx:
-            y = self._overlap_add_divide_window_sum_onnx(s_real, frames_num)
-        else:
-            y = self._overlap_add_divide_window_sum(s_real, frames_num)
-        # y: (batch_size, audio_samples + win_length,)
-        
-        y = self._trim_edges(y, length)
-        # (batch_size, audio_samples,)
-            
-        return y
-
-    def _get_full_stft(self, real_stft, imag_stft):
-        r"""Get full stft representation from spectrum using symmetry attribute.
-
-        Args:
-            real_stft: (batch_size, n_fft // 2 + 1, time_steps)
-            imag_stft: (batch_size, n_fft // 2 + 1, time_steps)
-
-        Returns:
-            full_real_stft: (batch_size, n_fft, time_steps)
-            full_imag_stft: (batch_size, n_fft, time_steps)
-        """
-        full_real_stft = torch.cat((real_stft, torch.flip(real_stft[:, 1 : -1, :], dims=[1])), dim=1)
-        full_imag_stft = torch.cat((imag_stft, - torch.flip(imag_stft[:, 1 : -1, :], dims=[1])), dim=1)
-
-        return full_real_stft, full_imag_stft
-
-    def _get_full_stft_onnx(self, real_stft, imag_stft):
-        r"""Get full stft representation from spectrum using symmetry attribute
-        for ONNX. Replace several pytorch operations in self._get_full_stft() 
-        that are not supported by ONNX.
-
-        Args:
-            real_stft: (batch_size, n_fft // 2 + 1, time_steps)
-            imag_stft: (batch_size, n_fft // 2 + 1, time_steps)
-
-        Returns:
-            full_real_stft: (batch_size, n_fft, time_steps)
-            full_imag_stft: (batch_size, n_fft, time_steps)
-        """
-
-        # Implement torch.flip() with Conv1d.
-        full_real_stft = torch.cat((real_stft, self.reverse(real_stft)), dim=1)
-        full_imag_stft = torch.cat((imag_stft, - self.reverse(imag_stft)), dim=1)
-
-        return full_real_stft, full_imag_stft
-
-    def _overlap_add_divide_window_sum(self, s_real, frames_num):
-        r"""Overlap add signals in frames to reconstruct signals.
-
-        Args:
-            s_real: (batch_size, n_fft, time_steps), signals in frames
-            frames_num: int
-
-        Returns:
-            y: (batch_size, audio_samples)
-        """
-        
-        output_samples = (s_real.shape[-1] - 1) * self.hop_length + self.win_length
-        # (audio_samples,)
-
-        # Overlap-add signals in frames to signals. Ref: 
-        # asteroid_filterbanks.torch_stft_fb.torch_stft_fb() from
-        # https://github.com/asteroid-team/asteroid-filterbanks
-        y = torch.nn.functional.fold(input=s_real, output_size=(1, output_samples), 
-            kernel_size=(1, self.win_length), stride=(1, self.hop_length))
-        # (batch_size, 1, 1, audio_samples,)
-        
-        y = y[:, 0, 0, :]
-        # (batch_size, audio_samples)
-
-        # Get overlap-add window sum to be divided.
-        ifft_window_sum = self._get_ifft_window(frames_num)
-        # (audio_samples,)
-
-        # Following code is abandaned for divide overlap-add window, because
-        # not supported by half precision training and ONNX.
-        # min_mask = ifft_window_sum.abs() < 1e-11
-        # y[:, ~min_mask] = y[:, ~min_mask] / ifft_window_sum[None, ~min_mask]
-        # # (batch_size, audio_samples)
-
-        ifft_window_sum = torch.clamp(ifft_window_sum, 1e-11, np.inf)
-        # (audio_samples,)
-
-        y = y / ifft_window_sum[None, :]
-        # (batch_size, audio_samples,)
-
-        return y
-
-    def _get_ifft_window(self, frames_num):
-        r"""Get overlap-add window sum to be divided.
-
-        Args:
-            frames_num: int
-
-        Returns:
-            ifft_window_sum: (audio_samlpes,), overlap-add window sum to be 
-            divided.
-        """
-        
-        output_samples = (frames_num - 1) * self.hop_length + self.win_length
-        # (audio_samples,)
-
-        window_matrix = self.ola_window[None, :, None].repeat(1, 1, frames_num)
-        # (batch_size, win_length, time_steps)
-
-        ifft_window_sum = F.fold(input=window_matrix, 
-            output_size=(1, output_samples), kernel_size=(1, self.win_length), 
-            stride=(1, self.hop_length))
-        # (1, 1, 1, audio_samples)
-        
-        ifft_window_sum = ifft_window_sum.squeeze()
-        # (audio_samlpes,)
-
-        return ifft_window_sum
-
-    def _overlap_add_divide_window_sum_onnx(self, s_real, frames_num):
-        r"""Overlap add signals in frames to reconstruct signals for ONNX. 
-        Replace several pytorch operations in 
-        self._overlap_add_divide_window_sum() that are not supported by ONNX.
-
-        Args:
-            s_real: (batch_size, n_fft, time_steps), signals in frames
-            frames_num: int
-
-        Returns:
-            y: (batch_size, audio_samples)
-        """
-
-        s_real = s_real[..., None]
-        # (batch_size, n_fft, time_steps, 1)
-
-        # Implement overlap-add with Conv1d, because torch.nn.functional.fold()
-        # is not supported by ONNX.
-        y = self.overlap_add(s_real)[:, 0, :, 0]    
-        # y: (batch_size, samples_num)
-        
-        if len(self.ifft_window_sum) != y.shape[1]:
-            device = s_real.device
-
-            self.ifft_window_sum = self._get_ifft_window_sum_onnx(frames_num, device)
-            # (audio_samples,)
-
-        # Use torch.clamp() to prevent from underflow to make sure all 
-        # operations are supported by ONNX.
-        ifft_window_sum = torch.clamp(self.ifft_window_sum, 1e-11, np.inf)
-        # (audio_samples,)
-
-        y = y / ifft_window_sum[None, :]
-        # (batch_size, audio_samples,)
-        
-        return y
-
-    def _get_ifft_window_sum_onnx(self, frames_num, device):
-        r"""Pre-calculate overlap-add window sum for reconstructing signals when
-        using ONNX.
-
-        Args:
-            frames_num: int
-            device: str | None
-
-        Returns:
-            ifft_window_sum: (audio_samples,)
-        """
-        
-        ifft_window_sum = librosa.filters.window_sumsquare(window=self.window, 
-            n_frames=frames_num, win_length=self.win_length, n_fft=self.n_fft, 
-            hop_length=self.hop_length)
-        # (audio_samples,)
-
-        ifft_window_sum = torch.Tensor(ifft_window_sum)
-
-        if device:
-            ifft_window_sum = ifft_window_sum.to(device)
-
-        return ifft_window_sum
-
-    def _trim_edges(self, y, length):
-        r"""Trim audio.
-
-        Args:
-            y: (audio_samples,)
-            length: int
-
-        Returns:
-            (trimmed_audio_samples,)
-        """
-        # Trim or pad to length
-        if length is None:
-            if self.center:
-                y = y[:, self.n_fft // 2 : -self.n_fft // 2]
-        else:
-            if self.center:
-                start = self.n_fft // 2
-            else:
-                start = 0
-
-            y = y[:, start : start + length]
-
-        return y
-
-
-class Spectrogram(nn.Module):
-    def __init__(self, n_fft=2048, hop_length=None, win_length=None,
-        window='hann', center=True, pad_mode='reflect', power=2.0,
-        freeze_parameters=True):
-        r"""Calculate spectrogram using pytorch. The STFT is implemented with 
-        Conv1d. The function has the same output of librosa.stft
-        """
-        super(Spectrogram, self).__init__()
-
-        self.power = power
-
-        self.stft = STFT(n_fft=n_fft, hop_length=hop_length,
-            win_length=win_length, window=window, center=center,
-            pad_mode=pad_mode, freeze_parameters=True)
-
-    def forward(self, input):
-        r"""Calculate spectrogram of input signals.
-        Args: 
-            input: (batch_size, data_length)
-
-        Returns:
-            spectrogram: (batch_size, 1, time_steps, n_fft // 2 + 1)
-        """
-
-        (real, imag) = self.stft.forward(input)
-        # (batch_size, n_fft // 2 + 1, time_steps)
-
-        spectrogram = real ** 2 + imag ** 2
-
-        if self.power == 2.0:
-            pass
-        else:
-            spectrogram = spectrogram ** (self.power / 2.0)
-
-        return spectrogram
-
-
-class LogmelFilterBank(nn.Module):
-    def __init__(self, sr=22050, n_fft=2048, n_mels=64, fmin=0.0, fmax=None, 
-        is_log=True, ref=1.0, amin=1e-10, top_db=80.0, freeze_parameters=True):
-        r"""Calculate logmel spectrogram using pytorch. The mel filter bank is 
-        the pytorch implementation of as librosa.filters.mel 
-        """
-        super(LogmelFilterBank, self).__init__()
-
-        self.is_log = is_log
-        self.ref = ref
-        self.amin = amin
-        self.top_db = top_db
-        if fmax == None:
-            fmax = sr//2
-
-        self.melW = librosa.filters.mel(sr=sr, n_fft=n_fft, n_mels=n_mels,
-            fmin=fmin, fmax=fmax).T
-        # (n_fft // 2 + 1, mel_bins)
-
-        self.melW = nn.Parameter(torch.Tensor(self.melW).contiguous())
-
-        if freeze_parameters:
-            for param in self.parameters():
-                param.requires_grad = False
-
-    def forward(self, input):
-        r"""Calculate (log) mel spectrogram from spectrogram.
-
-        Args:
-            input: (*, n_fft), spectrogram
-        
-        Returns: 
-            output: (*, mel_bins), (log) mel spectrogram
-        """
-
-        # Mel spectrogram
-        mel_spectrogram = torch.matmul(input, self.melW)
-        # (*, mel_bins)
-
-        # Logmel spectrogram
-        if self.is_log:
-            output = self.power_to_db(mel_spectrogram)
-        else:
-            output = mel_spectrogram
-
-        return output
-
-
-    def power_to_db(self, input):
-        r"""Power to db, this function is the pytorch implementation of 
-        librosa.power_to_lb
-        """
-        ref_value = self.ref
-        log_spec = 10.0 * torch.log10(torch.clamp(input, min=self.amin, max=np.inf))
-        log_spec -= 10.0 * np.log10(np.maximum(self.amin, ref_value))
-
-        if self.top_db is not None:
-            if self.top_db < 0:
-                raise librosa.util.exceptions.ParameterError('top_db must be non-negative')
-            log_spec = torch.clamp(log_spec, min=log_spec.max().item() - self.top_db, max=np.inf)
-
-        return log_spec
-
-
-class Enframe(nn.Module):
-    def __init__(self, frame_length=2048, hop_length=512):
-        r"""Enframe a time sequence. This function is the pytorch implementation 
-        of librosa.util.frame
-        """
-        super(Enframe, self).__init__()
-
-        self.enframe_conv = nn.Conv1d(in_channels=1, out_channels=frame_length,
-            kernel_size=frame_length, stride=hop_length,
-            padding=0, bias=False)
-
-        self.enframe_conv.weight.data = torch.Tensor(torch.eye(frame_length)[:, None, :])
-        self.enframe_conv.weight.requires_grad = False
-
-    def forward(self, input):
-        r"""Enframe signals into frames.
-        Args:
-            input: (batch_size, samples)
-        
-        Returns: 
-            output: (batch_size, window_length, frames_num)
-        """
-        output = self.enframe_conv(input[:, None, :])
-        return output
-
-
-    def power_to_db(self, input):
-        r"""Power to db, this function is the pytorch implementation of 
-        librosa.power_to_lb.
-        """
-        ref_value = self.ref
-        log_spec = 10.0 * torch.log10(torch.clamp(input, min=self.amin, max=np.inf))
-        log_spec -= 10.0 * np.log10(np.maximum(self.amin, ref_value))
-
-        if self.top_db is not None:
-            if self.top_db < 0:
-                raise librosa.util.exceptions.ParameterError('top_db must be non-negative')
-            log_spec = torch.clamp(log_spec, min=log_spec.max() - self.top_db, max=np.inf)
-
-        return log_spec
-
-
-class Scalar(nn.Module):
-    def __init__(self, scalar, freeze_parameters):
-        super(Scalar, self).__init__()
-
-        self.scalar_mean = Parameter(torch.Tensor(scalar['mean']))
-        self.scalar_std = Parameter(torch.Tensor(scalar['std']))
-
-        if freeze_parameters:
-            for param in self.parameters():
-                param.requires_grad = False
-
-    def forward(self, input):
-        return (input - self.scalar_mean) / self.scalar_std
-
-
-def debug(select, device):
-    """Compare numpy + librosa and torchlibrosa results. For debug. 
-
-    Args:
-        select: 'dft' | 'logmel'
-        device: 'cpu' | 'cuda'
-    """
-
-    if select == 'dft':
-        n = 10
-        norm = None     # None | 'ortho'
-        np.random.seed(0)
-
-        # Data
-        np_data = np.random.uniform(-1, 1, n)
-        pt_data = torch.Tensor(np_data)
-
-        # Numpy FFT
-        np_fft = np.fft.fft(np_data, norm=norm)
-        np_ifft = np.fft.ifft(np_fft, norm=norm)
-        np_rfft = np.fft.rfft(np_data, norm=norm)
-        np_irfft = np.fft.ifft(np_rfft, norm=norm)
-
-        # Pytorch FFT
-        obj = DFT(n, norm)
-        pt_dft = obj.dft(pt_data, torch.zeros_like(pt_data))
-        pt_idft = obj.idft(pt_dft[0], pt_dft[1])
-        pt_rdft = obj.rdft(pt_data)
-        pt_irdft = obj.irdft(pt_rdft[0], pt_rdft[1])
-
-        print('Comparing librosa and pytorch implementation of DFT. All numbers '
-            'below should be close to 0.')
-        print(np.mean((np.abs(np.real(np_fft) - pt_dft[0].cpu().numpy()))))
-        print(np.mean((np.abs(np.imag(np_fft) - pt_dft[1].cpu().numpy()))))
-
-        print(np.mean((np.abs(np.real(np_ifft) - pt_idft[0].cpu().numpy()))))
-        print(np.mean((np.abs(np.imag(np_ifft) - pt_idft[1].cpu().numpy()))))
-
-        print(np.mean((np.abs(np.real(np_rfft) - pt_rdft[0].cpu().numpy()))))
-        print(np.mean((np.abs(np.imag(np_rfft) - pt_rdft[1].cpu().numpy()))))
-
-        print(np.mean(np.abs(np_data - pt_irdft.cpu().numpy())))
-
-    elif select == 'stft':
-        device = torch.device(device)
-        np.random.seed(0)
-
-        # Spectrogram parameters (the same as librosa.stft)
-        sample_rate = 22050
-        data_length = sample_rate * 1
-        n_fft = 2048
-        hop_length = 512
-        win_length = 2048
-        window = 'hann'
-        center = True
-        pad_mode = 'reflect'
-
-        # Data
-        np_data = np.random.uniform(-1, 1, data_length)
-        pt_data = torch.Tensor(np_data).to(device)
-
-        # Numpy stft matrix
-        np_stft_matrix = librosa.stft(y=np_data, n_fft=n_fft,
-            hop_length=hop_length, window=window, center=center).T
-
-        # Pytorch stft matrix
-        pt_stft_extractor = STFT(n_fft=n_fft, hop_length=hop_length,
-            win_length=win_length, window=window, center=center, pad_mode=pad_mode,
-            freeze_parameters=True)
-
-        pt_stft_extractor.to(device)
-
-        (pt_stft_real, pt_stft_imag) = pt_stft_extractor.forward(pt_data[None, :])
-
-        print('Comparing librosa and pytorch implementation of STFT & ISTFT. \
-            All numbers below should be close to 0.')
-        print(np.mean(np.abs(np.real(np_stft_matrix) - pt_stft_real.data.cpu().numpy()[0, 0])))
-        print(np.mean(np.abs(np.imag(np_stft_matrix) - pt_stft_imag.data.cpu().numpy()[0, 0])))
-
-        # Numpy istft
-        np_istft_s = librosa.istft(stft_matrix=np_stft_matrix.T,
-            hop_length=hop_length, window=window, center=center, length=data_length)
-
-        # Pytorch istft
-        pt_istft_extractor = ISTFT(n_fft=n_fft, hop_length=hop_length,
-            win_length=win_length, window=window, center=center, pad_mode=pad_mode,
-            freeze_parameters=True)
-        pt_istft_extractor.to(device)
-
-        # Recover from real and imag part
-        pt_istft_s = pt_istft_extractor.forward(pt_stft_real, pt_stft_imag, data_length)[0, :]
-
-        # Recover from magnitude and phase
-        (pt_stft_mag, cos, sin) = magphase(pt_stft_real, pt_stft_imag)
-        pt_istft_s2 = pt_istft_extractor.forward(pt_stft_mag * cos, pt_stft_mag * sin, data_length)[0, :]
-
-        print(np.mean(np.abs(np_istft_s - pt_istft_s.data.cpu().numpy())))
-        print(np.mean(np.abs(np_data - pt_istft_s.data.cpu().numpy())))
-        print(np.mean(np.abs(np_data - pt_istft_s2.data.cpu().numpy())))
-
-    elif select == 'logmel':
-        dtype = np.complex64
-        device = torch.device(device)
-        np.random.seed(0)
-
-        # Spectrogram parameters (the same as librosa.stft)
-        sample_rate = 22050
-        data_length = sample_rate * 1
-        n_fft = 2048
-        hop_length = 512
-        win_length = 2048
-        window = 'hann'
-        center = True
-        pad_mode = 'reflect'
-
-        # Mel parameters (the same as librosa.feature.melspectrogram)
-        n_mels = 128
-        fmin = 0.
-        fmax = sample_rate / 2.0
-
-        # Power to db parameters (the same as default settings of librosa.power_to_db
-        ref = 1.0
-        amin = 1e-10
-        top_db = 80.0
-
-        # Data
-        np_data = np.random.uniform(-1, 1, data_length)
-        pt_data = torch.Tensor(np_data).to(device)
-
-        print('Comparing librosa and pytorch implementation of logmel '
-            'spectrogram. All numbers below should be close to 0.')
-
-        # Numpy librosa
-        np_stft_matrix = librosa.stft(y=np_data, n_fft=n_fft, hop_length=hop_length,
-            win_length=win_length, window=window, center=center, dtype=dtype,
-            pad_mode=pad_mode)
-
-        np_pad = np.pad(np_data, int(n_fft // 2), mode=pad_mode)
-
-        np_melW = librosa.filters.mel(sr=sample_rate, n_fft=n_fft, n_mels=n_mels,
-            fmin=fmin, fmax=fmax).T
-
-        np_mel_spectrogram = np.dot(np.abs(np_stft_matrix.T) ** 2, np_melW)
-
-        np_logmel_spectrogram = librosa.power_to_db(
-            np_mel_spectrogram, ref=ref, amin=amin, top_db=top_db)
-
-        # Pytorch
-        stft_extractor = STFT(n_fft=n_fft, hop_length=hop_length,
-            win_length=win_length, window=window, center=center, pad_mode=pad_mode,
-            freeze_parameters=True)
-
-        logmel_extractor = LogmelFilterBank(sr=sample_rate, n_fft=n_fft,
-            n_mels=n_mels, fmin=fmin, fmax=fmax, ref=ref, amin=amin,
-            top_db=top_db, freeze_parameters=True)
-
-        stft_extractor.to(device)
-        logmel_extractor.to(device)
-
-        pt_pad = F.pad(pt_data[None, None, :], pad=(n_fft // 2, n_fft // 2), mode=pad_mode)[0, 0]
-        print(np.mean(np.abs(np_pad - pt_pad.cpu().numpy())))
-
-        pt_stft_matrix_real = stft_extractor.conv_real(pt_pad[None, None, :])[0]
-        pt_stft_matrix_imag = stft_extractor.conv_imag(pt_pad[None, None, :])[0]
-        print(np.mean(np.abs(np.real(np_stft_matrix) - pt_stft_matrix_real.data.cpu().numpy())))
-        print(np.mean(np.abs(np.imag(np_stft_matrix) - pt_stft_matrix_imag.data.cpu().numpy())))
-
-        # Spectrogram
-        spectrogram_extractor = Spectrogram(n_fft=n_fft, hop_length=hop_length,
-            win_length=win_length, window=window, center=center, pad_mode=pad_mode,
-            freeze_parameters=True)
-
-        spectrogram_extractor.to(device)
-
-        pt_spectrogram = spectrogram_extractor.forward(pt_data[None, :])
-        pt_mel_spectrogram = torch.matmul(pt_spectrogram, logmel_extractor.melW)
-        print(np.mean(np.abs(np_mel_spectrogram - pt_mel_spectrogram.data.cpu().numpy()[0, 0])))
-
-        # Log mel spectrogram
-        pt_logmel_spectrogram = logmel_extractor.forward(pt_spectrogram)
-        print(np.mean(np.abs(np_logmel_spectrogram - pt_logmel_spectrogram[0, 0].data.cpu().numpy())))
-
-    elif select == 'enframe':
-        device = torch.device(device)
-        np.random.seed(0)
-
-        # Spectrogram parameters (the same as librosa.stft)
-        sample_rate = 22050
-        data_length = sample_rate * 1
-        hop_length = 512
-        win_length = 2048
-
-        # Data
-        np_data = np.random.uniform(-1, 1, data_length)
-        pt_data = torch.Tensor(np_data).to(device)
-
-        print('Comparing librosa and pytorch implementation of '
-            'librosa.util.frame. All numbers below should be close to 0.')
-
-        # Numpy librosa
-        np_frames = librosa.util.frame(np_data, frame_length=win_length,
-            hop_length=hop_length)
-
-        # Pytorch
-        pt_frame_extractor = Enframe(frame_length=win_length, hop_length=hop_length)
-        pt_frame_extractor.to(device)
-
-        pt_frames = pt_frame_extractor(pt_data[None, :])
-        print(np.mean(np.abs(np_frames - pt_frames.data.cpu().numpy())))
-
-    elif select == 'default':
-        device = torch.device(device)
-        np.random.seed(0)
-
-        # Spectrogram parameters (the same as librosa.stft)
-        sample_rate = 22050
-        data_length = sample_rate * 1
-        hop_length = 512
-        win_length = 2048
-
-        # Mel parameters (the same as librosa.feature.melspectrogram)
-        n_mels = 128
-
-        # Data
-        np_data = np.random.uniform(-1, 1, data_length)
-        pt_data = torch.Tensor(np_data).to(device)
-
-        feature_extractor = nn.Sequential(
-            Spectrogram(
-                hop_length=hop_length,
-                win_length=win_length,
-            ), LogmelFilterBank(
-                sr=sample_rate,
-                n_mels=n_mels,
-                is_log=False, #Default is true
-            ))
-
-        feature_extractor.to(device)
-
-        print(
-            'Comparing default mel spectrogram from librosa to the pytorch implementation.'
-        )
-
-        # Numpy librosa
-        np_melspect = librosa.feature.melspectrogram(np_data,
-                                                     hop_length=hop_length,
-                                                     sr=sample_rate,
-                                                     win_length=win_length,
-                                                     n_mels=n_mels).T
-        #Pytorch
-        pt_melspect = feature_extractor(pt_data[None, :]).squeeze()
-        passed = np.allclose(pt_melspect.data.to('cpu').numpy(), np_melspect)
-        print(f"Passed? {passed}")
-
-
-
-if __name__ == '__main__':
-
-    parser = argparse.ArgumentParser(description='')
-    parser.add_argument('--device', type=str, default='cpu', choices=['cpu', 'cuda'])
-    args = parser.parse_args()
-
-    device = args.device
-    norm = None     # None | 'ortho'
-    np.random.seed(0)
-
-    # Spectrogram parameters (the same as librosa.stft)
-    sample_rate = 22050
-    data_length = sample_rate * 1
-    n_fft = 2048
-    hop_length = 512
-    win_length = 2048
-    window = 'hann'
-    center = True
-    pad_mode = 'reflect'
-
-    # Mel parameters (the same as librosa.feature.melspectrogram)
-    n_mels = 128
-    fmin = 0.
-    fmax = sample_rate / 2.0
-
-    # Power to db parameters (the same as default settings of librosa.power_to_db
-    ref = 1.0
-    amin = 1e-10
-    top_db = 80.0
-
-    # Data
-    np_data = np.random.uniform(-1, 1, data_length)
-    pt_data = torch.Tensor(np_data).to(device)
-
-    # Pytorch
-    spectrogram_extractor = Spectrogram(n_fft=n_fft, hop_length=hop_length,
-        win_length=win_length, window=window, center=center, pad_mode=pad_mode,
-        freeze_parameters=True)
-
-    logmel_extractor = LogmelFilterBank(sr=sample_rate, n_fft=n_fft,
-        n_mels=n_mels, fmin=fmin, fmax=fmax, ref=ref, amin=amin, top_db=top_db,
-        freeze_parameters=True)
-
-    spectrogram_extractor.to(device)
-    logmel_extractor.to(device)
-
-    # Spectrogram
-    pt_spectrogram = spectrogram_extractor.forward(pt_data[None, :])
-
-    # Log mel spectrogram
-    pt_logmel_spectrogram = logmel_extractor.forward(pt_spectrogram)
-
-    # Uncomment for debug
-    if True:
-        debug(select='dft', device=device)
-        debug(select='stft', device=device)
-        debug(select='logmel', device=device)
-        debug(select='enframe', device=device)
-
-        try:
-            debug(select='default', device=device)
-        except:
-            raise Exception('Torchlibrosa does support librosa>=0.6.0, for \
-                comparison with librosa, please use librosa>=0.7.0!')

src/vision_transformer.py

@@ -1,176 +0,0 @@
-import math
-from functools import reduce
-from operator import mul
-from ipdb import set_trace
-
-import torch
-import torch.nn.functional as F
-import torch.nn as nn
-from mmcls.models.backbones import VisionTransformer as _VisionTransformer
-from mmcls.models.utils import to_2tuple
-from mmcv.cnn.bricks.transformer import PatchEmbed
-from torch.nn.modules.batchnorm import _BatchNorm
-
-
-def build_2d_sincos_position_embedding(patches_resolution,
-                                       embed_dims,
-                                       temperature=10000.,
-                                       cls_token=False):
-    """The function is to build position embedding for model to obtain the
-    position information of the image patches."""
-
-    if isinstance(patches_resolution, int):
-        patches_resolution = (patches_resolution, patches_resolution)
-
-    h, w = patches_resolution
-    grid_w = torch.arange(w, dtype=torch.float32)
-    grid_h = torch.arange(h, dtype=torch.float32)
-    grid_w, grid_h = torch.meshgrid(grid_w, grid_h)
-    assert embed_dims % 4 == 0, \
-        'Embed dimension must be divisible by 4.'
-    pos_dim = embed_dims // 4
-
-    omega = torch.arange(pos_dim, dtype=torch.float32) / pos_dim
-    omega = 1. / (temperature**omega)
-    out_w = torch.einsum('m,d->md', [grid_w.flatten(), omega])
-    out_h = torch.einsum('m,d->md', [grid_h.flatten(), omega])
-
-    pos_emb = torch.cat(
-        [
-            torch.sin(out_w),
-            torch.cos(out_w),
-            torch.sin(out_h),
-            torch.cos(out_h)
-        ],
-        dim=1,
-    )[None, :, :]
-
-    if cls_token:
-        cls_token_pe = torch.zeros([1, 1, embed_dims], dtype=torch.float32)
-        pos_emb = torch.cat([cls_token_pe, pos_emb], dim=1)
-
-    return pos_emb
-
-
-class VisionTransformer(_VisionTransformer):
-    """Vision Transformer.
-
-    A pytorch implement of: `An Images is Worth 16x16 Words: Transformers for
-    Image Recognition at Scale <https://arxiv.org/abs/2010.11929>`_.
-
-    Part of the code is modified from:
-    `<https://github.com/facebookresearch/moco-v3/blob/main/vits.py>`_.
-
-    Args:
-        stop_grad_conv1 (bool, optional): whether to stop the gradient of
-            convolution layer in `PatchEmbed`. Defaults to False.
-        frozen_stages (int): Stages to be frozen (stop grad and set eval mode).
-            -1 means not freezing any parameters. Defaults to -1.
-        norm_eval (bool): Whether to set norm layers to eval mode, namely,
-            freeze running stats (mean and var). Note: Effect on Batch Norm
-            and its variants only. Defaults to False.
-        init_cfg (dict or list[dict], optional): Initialization config dict.
-            Defaults to None.
-    """
-
-    arch_zoo = {
-        **dict.fromkeys(
-            ['mocov3-s', 'mocov3-small'], {
-                'embed_dims': 384,
-                'num_layers': 12,
-                'num_heads': 12,
-                'feedforward_channels': 1536,
-            }),
-        **dict.fromkeys(
-            ['b', 'base'], {
-                'embed_dims': 768,
-                'num_layers': 12,
-                'num_heads': 12,
-                'feedforward_channels': 3072
-            }),
-    }
-
-    def __init__(self,
-                 stop_grad_conv1=False,
-                 frozen_stages=-1,
-                 norm_eval=False,
-                 init_cfg=None,
-                 **kwargs):
-        super(VisionTransformer, self).__init__(init_cfg=init_cfg,)
-        self.patch_size = kwargs['patch_size']
-        self.frozen_stages = frozen_stages
-        self.norm_eval = norm_eval
-        self.init_cfg = init_cfg
-        
-        
-        if isinstance(self.patch_embed, PatchEmbed):
-            if stop_grad_conv1:
-                self.patch_embed.projection.weight.requires_grad = False
-                self.patch_embed.projection.bias.requires_grad = False
-
-        self._freeze_stages()
-
-    def init_weights(self):
-        super(VisionTransformer, self).init_weights()
-
-        if not (isinstance(self.init_cfg, dict)
-                and self.init_cfg['type'] == 'Pretrained'):
-
-            # Use fixed 2D sin-cos position embedding
-            pos_emb = build_2d_sincos_position_embedding(
-                patches_resolution=self.patch_resolution,
-                embed_dims=self.embed_dims,
-                cls_token=True)
-            self.pos_embed.data.copy_(pos_emb)
-            self.pos_embed.requires_grad = False
-
-            # xavier_uniform initialization for PatchEmbed
-            if isinstance(self.patch_embed, PatchEmbed):
-                val = math.sqrt(
-                    6. / float(3 * reduce(mul, to_2tuple(self.patch_size), 1) +
-                               self.embed_dims))
-                nn.init.uniform_(self.patch_embed.projection.weight, -val, val)
-                nn.init.zeros_(self.patch_embed.projection.bias)
-
-            # initialization for linear layers
-            for name, m in self.named_modules():
-                if isinstance(m, nn.Linear):
-                    if 'qkv' in name:
-                        # treat the weights of Q, K, V separately
-                        val = math.sqrt(
-                            6. /
-                            float(m.weight.shape[0] // 3 + m.weight.shape[1]))
-                        nn.init.uniform_(m.weight, -val, val)
-                    else:
-                        nn.init.xavier_uniform_(m.weight)
-                    nn.init.zeros_(m.bias)
-            nn.init.normal_(self.cls_token, std=1e-6)
-
-    def _freeze_stages(self):
-        """Freeze patch_embed layer, some parameters and stages."""
-        if self.frozen_stages >= 0:
-            self.patch_embed.eval()
-            for param in self.patch_embed.parameters():
-                param.requires_grad = False
-
-            self.cls_token.requires_grad = False
-            self.pos_embed.requires_grad = False
-
-        for i in range(1, self.frozen_stages + 1):
-            m = self.layers[i - 1]
-            m.eval()
-            for param in m.parameters():
-                param.requires_grad = False
-
-            if i == (self.num_layers) and self.final_norm:
-                for param in getattr(self, 'norm1').parameters():
-                    param.requires_grad = False
-
-    def train(self, mode=True):
-        super(VisionTransformer, self).train(mode)
-        self._freeze_stages()
-        if mode and self.norm_eval:
-            for m in self.modules():
-                # trick: eval have effect on BatchNorm only
-                if isinstance(m, _BatchNorm):
-                    m.eval()