Add files using upload-large-folder tool

128_Compmusic-Jingju_Audio_Recordings_Collection_english_version-music_captions/Jingju_Audio_Recordings_Collection_cut/京剧之星：黄炳强专辑/01-黄炳强-海瑞背纤：我自从到淳安正印执掌_2.flac

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

128_Compmusic-Jingju_Audio_Recordings_Collection_english_version-music_captions/Jingju_Audio_Recordings_Collection_cut/京剧之星：黄炳强专辑/05-黄炳强-朱痕记：听我妻赵锦棠言讲一遍_1.flac

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

128_Compmusic-Jingju_Audio_Recordings_Collection_english_version-music_captions/Jingju_Audio_Recordings_Collection_cut/京剧之星：黄炳强专辑/05-黄炳强-朱痕记：听我妻赵锦棠言讲一遍_2.flac

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

128_Compmusic-Jingju_Audio_Recordings_Collection_english_version-music_captions/Jingju_Audio_Recordings_Collection_cut/京剧之星：黄炳强专辑/06-黄炳强-朱痕记：见坟台不由人泪流满面_4.flac

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

128_Compmusic-Jingju_Audio_Recordings_Collection_english_version-music_captions/Jingju_Audio_Recordings_Collection_cut/京剧之星：黄炳强专辑/07-黄炳强-洪羊洞：为国家哪何曾半日闲空_1.flac

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

128_Compmusic-Jingju_Audio_Recordings_Collection_english_version-music_captions/Jingju_Audio_Recordings_Collection_cut/京剧之星：黄炳强专辑/08-黄炳强-洪羊洞：叹杨家投宋主心血用尽_1.flac

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

128_Compmusic-Jingju_Audio_Recordings_Collection_english_version-music_captions/Jingju_Audio_Recordings_Collection_cut/京剧之星：黄炳强专辑/10-黄炳强-文昭关：一轮明月照窗前_2.flac

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

128_Compmusic-Jingju_Audio_Recordings_Collection_english_version-music_captions/Jingju_Audio_Recordings_Collection_cut/京剧之星：黄炳强专辑/10-黄炳强-文昭关：一轮明月照窗前_3.flac

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

128_Compmusic-Jingju_Audio_Recordings_Collection_english_version-music_captions/Jingju_Audio_Recordings_Collection_cut/京剧之星：黄炳强专辑/11-黄炳强-文昭关：心中有事难合眼_2.flac

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

128_Compmusic-Jingju_Audio_Recordings_Collection_english_version-music_captions/Jingju_Audio_Recordings_Collection_cut/京剧之星：黄炳强专辑/14-黄炳强-鱼肠剑：站在街头用目觑_1.flac

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

128_Compmusic-Jingju_Audio_Recordings_Collection_english_version-music_captions/Jingju_Audio_Recordings_Collection_cut/京剧之星：黄炳强专辑/14-黄炳强-鱼肠剑：站在街头用目觑_5.flac

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

128_Compmusic-Jingju_Audio_Recordings_Collection_english_version-music_captions/Jingju_Audio_Recordings_Collection_cut/京剧之星：黄炳强专辑/15-黄炳强-鱼肠剑：富贵穷通不由己_2.flac

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

Beat-Transformer/README.md

@@ -0,0 +1,74 @@
+# Beat Transformer
+<a href="https://colab.research.google.com/drive/1IdrpMO1AivWmy-Bm8ktmMy14ED9jllux?usp=sharing)" rel="nofollow"><img src="https://camo.githubusercontent.com/84f0493939e0c4de4e6dbe113251b4bfb5353e57134ffd9fcab6b8714514d4d1/68747470733a2f2f636f6c61622e72657365617263682e676f6f676c652e636f6d2f6173736574732f636f6c61622d62616467652e737667" alt="Open In Colab" data-canonical-src="https://colab.research.google.com/assets/colab-badge.svg" style="max-width: 100%;"></a>
+
+Repository for paper: [Beat Transformer: Demixed Beat and Downbeat Tracking with Dilated Self-Attention](https://arxiv.org/abs/2209.07140) in Proceedings of the 23rd International Society for Music Information Retrieval Conference (ISMIR 2022), Bengaluru, India.
+
+Welcome to test our model on your own music at our [Google Colab](https://colab.research.google.com/drive/1IdrpMO1AivWmy-Bm8ktmMy14ED9jllux?usp=sharing).
+
+
+## Code and File Directory
+
+This repository is organized as follows:
+
+```
+root
+│
+└───checkpoint                          PyTorch model checkpoints
+    │   ···
+│   
+└───code
+    └───ablation_models                 ablation models
+        │   ···                            
+    │   DilatedTransformer.py           Beat Transformer model
+    │   DilatedTransformerLayer.py      Dilated Self-Attention
+    │   spectrogram_dataset.py          data loader
+    │   train.py                        training script
+    │   ...                             code for other utilities
+│   
+└───data
+    └───audio_lists                     Order info of pieces in each dataset
+        │   ···                     
+    │   demix_spectrogram_data.npz      demixed spectrogram data (33GB, to be downloaded)
+    │   full_beat_annotation.npz        beat/downbeat annotation
+│   
+└───preprocessing                       code for data pre-processing
+    │   ···
+│   
+└───save                                training log and more
+    │   ···
+```
+
+
+## How to run
+* To quickly reproduce the accuracy reported in our paper, simply run `./code/eight_fold_test.py`.
+* To quickly test our model with your own music, welcome to our [Google Colab](https://colab.research.google.com/drive/1IdrpMO1AivWmy-Bm8ktmMy14ED9jllux?usp=sharing).
+* If you wish to train our model from scratch, first download our [processed dataset](https://drive.google.com/file/d/1LamSAEY5QsnY57cF6qH_0niesGGKkHtI/view?usp=sharing) (33GB in total, including demixed spectrogram data of Ballroom, Hainsworth, Carnetic, Harmonix, SMC, and GTZAN). 
+* Executing `./code/train.sh` will train our model in 8-fold cross validation. If you wish to train one single fold, you can run `./code/train.py` after specifying `DEBUG_MODE`, `FOLD`, and `GPU`. When `DEBUG_MODE=1`, it will load a small portion of data to quickly run through with a smaller bach size.
+* We also release out ablation model architectures in `./code/ablation_models`. We release our data processing scripts in `./preprocessing/demixing.py`, where we call [Spleeter](https://github.com/deezer/spleeter) to demix each piece and save the demixed spectrogram.
+
+## Audio Data
+We use a total of 7 datasets for model training and testing. If you wish to acquire the audio data, you can follow the following guidelines:
+* Ballroom Dataset (audio) is available [here](http://mtg.upf.edu/ismir2004/contest/tempoContest/node5.html). There are 13 duplicated pieces and I discarded them in my experiments. For more information, see [here](https://github.com/CPJKU/BallroomAnnotations/blob/master/README.md).
+
+* Hainsworth Dataset (audio) is no longer accessible via the original link. Since Hainsworth is a well-known public dataset, I guess it's okay to share my copy. You can download Hainsworth [here](https://drive.google.com/file/d/1ctMDHAoeTBG5LSbtQIQBIv4vTI0oB0u1/view).
+
+* GTZAN Dataset (audio) is available on [Kaggle](https://www.kaggle.com/datasets/andradaolteanu/gtzan-dataset-music-genre-classification). You need a registered Kaggle account to download it.
+
+* SMC Dataset (audio) is available [here](https://joserzapata.github.io/publication/selective-sampling-beat-tracking/).
+
+* Carnatic Dataset (audio) is on [Zenodo](https://zenodo.org/record/1264394). You can download it by request.
+
+* Harmonix Dataset (mel-spectrogram) is available [here](https://github.com/urinieto/harmonixset). I used the Griffin-Lim algorithm in Librosa to convert mel-spectrogram to audio, which (however) is lossful. My conversion code is [here](https://github.com/zhaojw1998/Beat-Transformer/blob/main/preprocessing/harmonix_mel2wav.py).
+
+* RWC POP (audio) seems NOT royalty-free so I'm afraid I cannot share the audio. For more info about this dataset, you can go to its [official webpage](https://staff.aist.go.jp/m.goto/RWC-MDB/).
+
+For the beat/downbeat annotation of Ballroom, GTZAN, SMC, and Hainsworth, I used the annotation released by Sebastian Böck [here](https://github.com/superbock/ISMIR2019).
+
+
+
+## Contact
+Jingwei Zhao (PhD student in Data Science at NUS)
+
+jzhao@u.nus.edu
+
+Nov. 24, 2022

Beat-Transformer/code/DilatedTransformer.py

@@ -0,0 +1,167 @@
+import torch 
+from torch import nn 
+from DilatedTransformerLayer import DilatedTransformerLayer
+from torch.nn import TransformerEncoderLayer as torchTransformerEncoderLayer
+
+
+class Demixed_DilatedTransformerModel(nn.Module):
+    def __init__(self, attn_len=5, instr=5, ntoken=2, dmodel=128, nhead=2, d_hid=512, nlayers=9, norm_first=True, dropout=.1):
+        super(Demixed_DilatedTransformerModel, self).__init__()
+        self.nhead = nhead
+        self.nlayers = nlayers
+        self.attn_len = attn_len
+        self.head_dim = dmodel // nhead
+        self.dmodel = dmodel
+        assert self.head_dim * nhead == dmodel, "embed_dim must be divisible by num_heads"
+
+        self.conv1 = nn.Conv2d(in_channels=1, out_channels=32, kernel_size=(5, 3), stride=1, padding=(2, 0))#126
+        self.maxpool1 = nn.MaxPool2d(kernel_size=(1, 3), stride=(1, 3))#42
+        self.dropout1 = nn.Dropout(p=dropout)
+        
+        self.conv2 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=(1, 12), stride=1, padding=(0, 0))#31
+        self.maxpool2 = nn.MaxPool2d(kernel_size=(1, 3), stride=(1, 3))#10
+        self.dropout2 = nn.Dropout(p=dropout)
+        
+        self.conv3 = nn.Conv2d(in_channels=64, out_channels=dmodel, kernel_size=(3, 6), stride=1, padding=(1, 0))#5
+        self.maxpool3 = nn.MaxPool2d(kernel_size=(1, 3), stride=(1, 3))#1
+        self.dropout3 = nn.Dropout(p=dropout)
+        
+        self.Transformer_layers = nn.ModuleDict({})
+        for idx in range(nlayers):
+            self.Transformer_layers[f'time_attention_{idx}'] = DilatedTransformerLayer(dmodel, nhead, d_hid, dropout, Er_provided=False, attn_len=attn_len, norm_first=norm_first)
+            if (idx >= 3) and (idx <= 5):
+                self.Transformer_layers[f'instr_attention_{idx}'] = torchTransformerEncoderLayer(dmodel, nhead, d_hid, dropout, batch_first=True, norm_first=norm_first)
+            
+        self.out_linear = nn.Linear(dmodel, ntoken)
+
+        self.dropout_t = nn.Dropout(p=.5)
+        self.out_linear_t = nn.Linear(dmodel, 300)
+        
+
+    def forward(self, x):
+        #x: (batch, instr, time, dmodel), FloatTensor
+        batch, instr, time, melbin = x.shape
+        x = x.reshape(-1, 1, time, melbin)
+        x = self.conv1(x)
+        x = self.maxpool1(x)
+        x = torch.relu(x)
+        x = self.dropout1(x)
+
+        x = self.conv2(x)
+        x = self.maxpool2(x)
+        x = torch.relu(x)
+        x = self.dropout2(x)
+
+        x = self.conv3(x)
+        x = self.maxpool3(x)
+        x = torch.relu(x)
+        x = self.dropout3(x)    #(batch*instr, channel, time, 1)
+
+        x = x.reshape(-1, self.dmodel, time).transpose(1, 2)    #(batch*instr, time, channel=dmodel)
+        t = []
+
+        for layer in range(self.nlayers):
+            x, skip = self.Transformer_layers[f'time_attention_{layer}'](x, layer=layer)
+            skip = skip.reshape(batch, instr, time, self.dmodel)
+            t.append(skip.mean(1))
+  
+            if (layer >= 3) and (layer <= 5):
+                x = x.reshape(batch, instr, time, self.dmodel)
+                x = x.permute(0, 2, 1, 3)
+                x = x.reshape(-1, instr, self.dmodel)
+
+                x = self.Transformer_layers[f'instr_attention_{layer}'](x)
+
+                x = x.reshape(batch, time, instr, self.dmodel)
+                x = x.permute(0, 2, 1, 3)
+                x = x.reshape(-1, time, self.dmodel)
+            
+        x = torch.relu(x)
+        x = x.reshape(batch, instr, time, self.dmodel)
+        x = x.mean(1)
+        x = self.out_linear(x)
+
+        t = torch.stack(t, axis=-1).sum(dim=-1)
+        t = torch.relu(t)
+        t = self.dropout_t(t)
+        t = t.mean(dim=1) #(batch, dmodel)
+        t = self.out_linear_t(t)
+
+        return x, t
+
+    def inference(self, x):
+        #x: (batch, instr, time, dmodel), FloatTensor
+        #This inference method also outputs the cumulative attention matrix
+        batch, instr, time, melbin = x.shape
+        x = x.reshape(-1, 1, time, melbin)
+        x = self.conv1(x)
+        x = self.maxpool1(x)
+        x = torch.relu(x)
+        x = self.dropout1(x)
+
+        x = self.conv2(x)
+        x = self.maxpool2(x)
+        x = torch.relu(x)
+        x = self.dropout2(x)
+
+        x = self.conv3(x)
+        x = self.maxpool3(x)
+        x = torch.relu(x)
+        x = self.dropout3(x)    #(batch*instr, channel, time, 1)
+
+        x = x.reshape(-1, self.dmodel, time).transpose(1, 2)    #(batch*instr, time, channel=dmodel)
+        t = []
+
+        attn = [torch.eye(time, device=x.device).repeat(batch, self.nhead, 1, 1)]
+
+        for layer in range(self.nlayers):
+            x, skip, layer_attn = self.Transformer_layers[f'time_attention_{layer}'].inference(x, layer=layer)
+            skip = skip.reshape(batch, instr, time, self.dmodel)
+            t.append(skip.mean(1))
+
+            attn.append(torch.matmul(attn[-1], layer_attn.transpose(-2, -1)))
+  
+            if (layer >= 3) and (layer <= 5):
+                x = x.reshape(batch, instr, time, self.dmodel)
+                x = x.permute(0, 2, 1, 3)
+                x = x.reshape(-1, instr, self.dmodel)
+
+                x = self.Transformer_layers[f'instr_attention_{layer}'](x)
+
+                x = x.reshape(batch, time, instr, self.dmodel)
+                x = x.permute(0, 2, 1, 3)
+                x = x.reshape(-1, time, self.dmodel)
+            
+        x = torch.relu(x)
+        x = x.reshape(batch, instr, time, self.dmodel)
+        x = x.mean(1)
+        x = self.out_linear(x)
+
+        t = torch.stack(t, axis=-1).sum(dim=-1)
+        t = torch.relu(t)
+        t = self.dropout_t(t)
+        t = t.mean(dim=1) #(batch, dmodel)
+        t = self.out_linear_t(t)
+
+        return x, t, attn
+
+
+
+
+if __name__ == '__main__':
+    from spectrogram_dataset import audioDataset
+    from torch.utils.data import DataLoader
+
+    DEVICE = 'cuda:0'
+    model = Demixed_DilatedTransformerModel(attn_len=5, instr=5, ntoken=2, dmodel=256, nhead=8, d_hid=1024, nlayers=9, norm_first=True, dropout=.1)
+    model.to(DEVICE)
+    model.eval()
+
+    for name, param in model.state_dict().items():
+        print(name, param.shape)
+    # name: str
+    # param: Tensor
+
+    total = sum([param.nelement() for param in model.parameters()])
+    print(total)
+    #print("Number of parameter: %.2fM" % (total/1e6))

Beat-Transformer/code/DilatedTransformerLayer.py

@@ -0,0 +1,183 @@
+import math
+import torch 
+import torch.nn.functional as F 
+from torch import nn
+from torch.nn.modules.normalization import LayerNorm
+
+
+class DilatedMultiheadSelfAttentionWithRelativePositionalEmbedding(nn.Module):
+    def __init__(self, dmodel, num_heads, dropout=0, Er_provided=False, attn_len=5):
+        super(DilatedMultiheadSelfAttentionWithRelativePositionalEmbedding, self).__init__()
+        self.attn_len = attn_len
+        self.dmodel = dmodel
+        self.num_heads = num_heads
+        self.head_dim = dmodel // num_heads
+        assert self.head_dim * num_heads == dmodel, "embed_dim must be divisible by num_heads"
+
+        self.key = nn.Linear(dmodel, dmodel)
+        self.value = nn.Linear(dmodel, dmodel)
+        self.query = nn.Linear(dmodel, dmodel)
+        self.dropout = nn.Dropout(dropout)
+        self.Er_provided = Er_provided
+        
+        if not Er_provided:
+            self.Er = nn.Parameter(torch.randn(num_heads, self.head_dim, attn_len))
+
+
+    def forward(self, query, key, value, layer=0):
+        #query, key, and value: (batch, time, dmodel), float tensor
+
+        batch, time, d_model = query.shape
+
+        q = self.query(query).reshape(batch, time, self.num_heads, 1, self.head_dim).transpose(1, 2)  #(batch, num_head, time, 1, head_dim)
+        k = self.key(key).reshape(batch, time, self.num_heads, 1, self.head_dim).transpose(1, 2)  #(batch, num_head, time, 1, head_dim)
+        v = self.value(value).reshape(batch, time, self.num_heads, 1, self.head_dim).transpose(1, 2)  #(batch, num_head, time, 1, head_dim)
+
+        k = torch.cat(
+                        (
+                        self.kv_roll(k[:, 0: 4], layer, padding_value=0, shift=0),
+                        self.kv_roll(k[:, 4: 5], layer, padding_value=0, shift=-2),
+                        self.kv_roll(k[:, 5: 6], layer, padding_value=0, shift=-1),
+                        self.kv_roll(k[:, 6: 7], layer, padding_value=0, shift=1),
+                        self.kv_roll(k[:, 6: 7], layer, padding_value=0, shift=2)   #This should be k[:, 7: 8]. We had this bug during training so we keep it to fit the checkpoints.
+                        ),
+                    dim=1
+                    )   #we define 4 symmetrical heads and 4 skewed heads
+
+        v = torch.cat(
+                        (
+                        self.kv_roll(v[:, 0: 4], layer, padding_value=0, shift=0),
+                        self.kv_roll(v[:, 4: 5], layer, padding_value=0, shift=-2),
+                        self.kv_roll(v[:, 5: 6], layer, padding_value=0, shift=-1),
+                        self.kv_roll(v[:, 6: 7], layer, padding_value=0, shift=1),
+                        self.kv_roll(v[:, 7: 8], layer, padding_value=0, shift=2)
+                        ),
+                    dim=1
+                    )   #we define 4 symmetrical heads and 4 skewed heads
+        
+        Er_t = self.Er.unsqueeze(1).unsqueeze(0)  #(1, num_head, 1, head_dim, attn_len)
+
+        qk = torch.matmul(q, k.transpose(-2, -1))
+        attn_mask = torch.zeros_like(qk).masked_fill_((qk==0), float('-inf'))
+        attn = (qk + torch.matmul(q, Er_t)) / math.sqrt(self.head_dim)
+        attn = F.softmax(attn + attn_mask, dim=-1)
+
+        out = torch.matmul(attn, v) #(batch, num_head, time, 1, head_dim)
+        out = out.squeeze(-2).transpose(1, 2).reshape(batch, time, d_model)
+
+        return self.dropout(out), attn
+        
+
+
+    def kv_roll(self, tensor, layer, padding_value=0, shift=1):
+        #tensor: (batch, num_head, time, 1, head_dim)
+        batch, num_head, time, _, head_dim = tensor.shape
+
+        tensor = F.pad(tensor, (0, 0, 0, 0, (2**layer)*(self.attn_len//2), (2**layer)*(self.attn_len//2)), mode='constant', value=padding_value) 
+        #(batch, num_head, time+(2**layer)*(self.attn_len//2), 1, head_dim)
+
+        tensor = torch.cat([torch.roll(tensor, shifts=-i*(2**layer), dims=2) for i in range(shift, self.attn_len+shift)], dim=-2) 
+        #(batch, num_head, time+(2**layer)*(self.attn_len//2), attn_len, head_dim)
+
+        return tensor[:, :, :time, :, :]    #(batch, num_head, time, attn_len, head_dim)
+
+
+
+
+class DilatedTransformerLayer(nn.Module):
+    def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1, Er_provided=False, attn_len=5, norm_first=False, layer_norm_eps=1e-5):
+        super(DilatedTransformerLayer, self).__init__()
+        self.self_attn = DilatedMultiheadSelfAttentionWithRelativePositionalEmbedding(d_model, nhead, dropout, Er_provided, attn_len)
+        # Implementation of Feedforward model
+        self.linear1 = nn.Linear(d_model, dim_feedforward)
+        self.dropout = nn.Dropout(dropout)
+        self.linear2 = nn.Linear(dim_feedforward, d_model)
+
+        self.norm_first = norm_first
+        self.norm1 = LayerNorm(d_model, eps=layer_norm_eps)
+        self.norm2 = LayerNorm(d_model, eps=layer_norm_eps)
+        self.dropout1 = nn.Dropout(dropout)
+        self.dropout2 = nn.Dropout(dropout)
+
+        self.activation = F.gelu
+
+
+    def forward(self, x, layer=0):
+        #x: (batch, time, dmodel)
+        if self.norm_first:
+            x_ = self._sa_block(self.norm1(x), layer)[0]
+            x = x + x_
+            x = x + self._ff_block(self.norm2(x))
+        else:
+            x_ = self._sa_block(x, layer)[0]
+            x = self.norm1(x + x_)
+            x = self.norm2(x + self._ff_block(x))
+        return x, x_
+
+
+    def inference(self, x, layer=0):
+        #x: (batch, time, dmodel)
+        if self.norm_first:
+            x_, attn = self._sa_block(self.norm1(x), layer)
+            x = x + x_
+            x = x + self._ff_block(self.norm2(x))
+        else:
+            x_, attn = self._sa_block(x, layer)
+            x = self.norm1(x + x_)
+            x = self.norm2(x + self._ff_block(x))
+
+
+        attn = attn.squeeze(-2) #batch, num_head, time, attn_len
+        batch, num_head, time, attn_len = attn.shape
+        padded_attn_len = (attn_len-1) * (2**layer) + 1
+        tmp_output = torch.zeros(batch, num_head, time, padded_attn_len, device=x.device)
+        for i, j in enumerate(range(0, padded_attn_len, 2**layer)):
+            tmp_output[:, :, :, j] = attn[:, :, :, i]
+
+        attn = torch.zeros(batch, num_head, time, time+(padded_attn_len-1)*2, device=x.device)
+        for i in range(time):
+            attn[:, :, i, i: i+padded_attn_len] = tmp_output[:, :, i]
+
+        center = (padded_attn_len-1)
+        attn = torch.cat(
+                            [
+                                attn[:, 0: 4, :,  center - (2**layer) * 2:  center - (2**layer) * 2 + time],
+                                attn[:, 4: 5, :,  center - (2**layer) * 1:  center - (2**layer) * 1 + time],
+                                attn[:, 5: 6, :,  center - (2**layer) * 0:  center - (2**layer) * 0 + time],
+                                attn[:, 6: 7, :,  center - (2**layer) * 3:  center - (2**layer) * 3 + time],
+                                attn[:, 7: 8, :,  center - (2**layer) * 4:  center - (2**layer) * 4 + time]
+                            ],
+                            dim=1
+                        )   #restore the square attention matrix from dilated self-attention
+
+        return x, x_, attn
+
+
+    # self-attention block
+    def _sa_block(self, x, layer=0):
+        x, attn = self.self_attn(x, x, x, layer)
+        return self.dropout1(x), attn
+
+
+    # feed forward block
+    def _ff_block(self, x):
+        x = self.linear2(self.dropout(self.activation(self.linear1(x))))
+        return self.dropout2(x)
+
+
+
+
+if __name__ == '__main__':
+    BATCH=1
+    TIME=9
+    DMODEL=8
+    N_HEAD=4
+    ATTN_LEN=5
+    LAYER=1
+
+    x = torch.ones(BATCH, TIME, DMODEL)
+
+    model = DilatedMultiheadSelfAttentionWithRelativePositionalEmbedding(dmodel=DMODEL, num_heads=N_HEAD, attn_len=ATTN_LEN)
+
+    output, attn = model(x, x, x, layer=LAYER)
+    print(attn[0, 0, :, :, :])

Beat-Transformer/code/ablation_models/DilatedTransformerLayer.py

@@ -0,0 +1,183 @@
+import math
+import torch 
+import torch.nn.functional as F 
+from torch import nn
+from torch.nn.modules.normalization import LayerNorm
+
+
+class DilatedMultiheadSelfAttentionWithRelativePositionalEmbedding(nn.Module):
+    def __init__(self, dmodel, num_heads, dropout=0, Er_provided=False, attn_len=5):
+        super(DilatedMultiheadSelfAttentionWithRelativePositionalEmbedding, self).__init__()
+        self.attn_len = attn_len
+        self.dmodel = dmodel
+        self.num_heads = num_heads
+        self.head_dim = dmodel // num_heads
+        assert self.head_dim * num_heads == dmodel, "embed_dim must be divisible by num_heads"
+
+        self.key = nn.Linear(dmodel, dmodel)
+        self.value = nn.Linear(dmodel, dmodel)
+        self.query = nn.Linear(dmodel, dmodel)
+        self.dropout = nn.Dropout(dropout)
+        self.Er_provided = Er_provided
+        
+        if not Er_provided:
+            self.Er = nn.Parameter(torch.randn(num_heads, self.head_dim, attn_len))
+
+
+    def forward(self, query, key, value, layer=0):
+        #query, key, and value: (batch, time, dmodel), float tensor
+
+        batch, time, d_model = query.shape
+
+        q = self.query(query).reshape(batch, time, self.num_heads, 1, self.head_dim).transpose(1, 2)  #(batch, num_head, time, 1, head_dim)
+        k = self.key(key).reshape(batch, time, self.num_heads, 1, self.head_dim).transpose(1, 2)  #(batch, num_head, time, 1, head_dim)
+        v = self.value(value).reshape(batch, time, self.num_heads, 1, self.head_dim).transpose(1, 2)  #(batch, num_head, time, 1, head_dim)
+
+        k = torch.cat(
+                        (
+                        self.kv_roll(k[:, 0: 4], layer, padding_value=0, shift=0),
+                        self.kv_roll(k[:, 4: 5], layer, padding_value=0, shift=-2),
+                        self.kv_roll(k[:, 5: 6], layer, padding_value=0, shift=-1),
+                        self.kv_roll(k[:, 6: 7], layer, padding_value=0, shift=1),
+                        self.kv_roll(k[:, 6: 7], layer, padding_value=0, shift=2)   #This should be k[:, 7: 8]. We had this bug during training so we keep it to fit the checkpoints.
+                        ),
+                    dim=1
+                    )   #we define 4 symmetrical heads and 4 skewed heads
+
+        v = torch.cat(
+                        (
+                        self.kv_roll(v[:, 0: 4], layer, padding_value=0, shift=0),
+                        self.kv_roll(v[:, 4: 5], layer, padding_value=0, shift=-2),
+                        self.kv_roll(v[:, 5: 6], layer, padding_value=0, shift=-1),
+                        self.kv_roll(v[:, 6: 7], layer, padding_value=0, shift=1),
+                        self.kv_roll(v[:, 7: 8], layer, padding_value=0, shift=2)
+                        ),
+                    dim=1
+                    )   #we define 4 symmetrical heads and 4 skewed heads
+        
+        Er_t = self.Er.unsqueeze(1).unsqueeze(0)  #(1, num_head, 1, head_dim, attn_len)
+
+        qk = torch.matmul(q, k.transpose(-2, -1))
+        attn_mask = torch.zeros_like(qk).masked_fill_((qk==0), float('-inf'))
+        attn = (qk + torch.matmul(q, Er_t)) / math.sqrt(self.head_dim)
+        attn = F.softmax(attn + attn_mask, dim=-1)
+
+        out = torch.matmul(attn, v) #(batch, num_head, time, 1, head_dim)
+        out = out.squeeze(-2).transpose(1, 2).reshape(batch, time, d_model)
+
+        return self.dropout(out), attn
+        
+
+
+    def kv_roll(self, tensor, layer, padding_value=0, shift=1):
+        #tensor: (batch, num_head, time, 1, head_dim)
+        batch, num_head, time, _, head_dim = tensor.shape
+
+        tensor = F.pad(tensor, (0, 0, 0, 0, (2**layer)*(self.attn_len//2), (2**layer)*(self.attn_len//2)), mode='constant', value=padding_value) 
+        #(batch, num_head, time+(2**layer)*(self.attn_len//2), 1, head_dim)
+
+        tensor = torch.cat([torch.roll(tensor, shifts=-i*(2**layer), dims=2) for i in range(shift, self.attn_len+shift)], dim=-2) 
+        #(batch, num_head, time+(2**layer)*(self.attn_len//2), attn_len, head_dim)
+
+        return tensor[:, :, :time, :, :]    #(batch, num_head, time, attn_len, head_dim)
+
+
+
+
+class DilatedTransformerLayer(nn.Module):
+    def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1, Er_provided=False, attn_len=5, norm_first=False, layer_norm_eps=1e-5):
+        super(DilatedTransformerLayer, self).__init__()
+        self.self_attn = DilatedMultiheadSelfAttentionWithRelativePositionalEmbedding(d_model, nhead, dropout, Er_provided, attn_len)
+        # Implementation of Feedforward model
+        self.linear1 = nn.Linear(d_model, dim_feedforward)
+        self.dropout = nn.Dropout(dropout)
+        self.linear2 = nn.Linear(dim_feedforward, d_model)
+
+        self.norm_first = norm_first
+        self.norm1 = LayerNorm(d_model, eps=layer_norm_eps)
+        self.norm2 = LayerNorm(d_model, eps=layer_norm_eps)
+        self.dropout1 = nn.Dropout(dropout)
+        self.dropout2 = nn.Dropout(dropout)
+
+        self.activation = F.gelu
+
+
+    def forward(self, x, layer=0):
+        #x: (batch, time, dmodel)
+        if self.norm_first:
+            x_ = self._sa_block(self.norm1(x), layer)[0]
+            x = x + x_
+            x = x + self._ff_block(self.norm2(x))
+        else:
+            x_ = self._sa_block(x, layer)[0]
+            x = self.norm1(x + x_)
+            x = self.norm2(x + self._ff_block(x))
+        return x, x_
+
+
+    def inference(self, x, layer=0):
+        #x: (batch, time, dmodel)
+        if self.norm_first:
+            x_, attn = self._sa_block(self.norm1(x), layer)
+            x = x + x_
+            x = x + self._ff_block(self.norm2(x))
+        else:
+            x_, attn = self._sa_block(x, layer)
+            x = self.norm1(x + x_)
+            x = self.norm2(x + self._ff_block(x))
+
+
+        attn = attn.squeeze(-2) #batch, num_head, time, attn_len
+        batch, num_head, time, attn_len = attn.shape
+        padded_attn_len = (attn_len-1) * (2**layer) + 1
+        tmp_output = torch.zeros(batch, num_head, time, padded_attn_len, device=x.device)
+        for i, j in enumerate(range(0, padded_attn_len, 2**layer)):
+            tmp_output[:, :, :, j] = attn[:, :, :, i]
+
+        attn = torch.zeros(batch, num_head, time, time+(padded_attn_len-1)*2, device=x.device)
+        for i in range(time):
+            attn[:, :, i, i: i+padded_attn_len] = tmp_output[:, :, i]
+
+        center = (padded_attn_len-1)
+        attn = torch.cat(
+                            [
+                                attn[:, 0: 4, :,  center - (2**layer) * 2:  center - (2**layer) * 2 + time],
+                                attn[:, 4: 5, :,  center - (2**layer) * 1:  center - (2**layer) * 1 + time],
+                                attn[:, 5: 6, :,  center - (2**layer) * 0:  center - (2**layer) * 0 + time],
+                                attn[:, 6: 7, :,  center - (2**layer) * 3:  center - (2**layer) * 3 + time],
+                                attn[:, 7: 8, :,  center - (2**layer) * 4:  center - (2**layer) * 4 + time]
+                            ],
+                            dim=1
+                        )   #restore the square attention matrix from dilated self-attention
+
+        return x, x_, attn
+
+
+    # self-attention block
+    def _sa_block(self, x, layer=0):
+        x, attn = self.self_attn(x, x, x, layer)
+        return self.dropout1(x), attn
+
+
+    # feed forward block
+    def _ff_block(self, x):
+        x = self.linear2(self.dropout(self.activation(self.linear1(x))))
+        return self.dropout2(x)
+
+
+
+
+if __name__ == '__main__':
+    BATCH=1
+    TIME=9
+    DMODEL=8
+    N_HEAD=4
+    ATTN_LEN=5
+    LAYER=1
+
+    x = torch.ones(BATCH, TIME, DMODEL)
+
+    model = DilatedMultiheadSelfAttentionWithRelativePositionalEmbedding(dmodel=DMODEL, num_heads=N_HEAD, attn_len=ATTN_LEN)
+
+    output, attn = model(x, x, x, layer=LAYER)
+    print(attn[0, 0, :, :, :])

Beat-Transformer/code/ablation_models/music_transformer.py

@@ -0,0 +1,145 @@
+import math
+from numpy import transpose
+import torch 
+import torch.nn.functional as F 
+from torch import nn
+from torch.nn.modules.normalization import LayerNorm
+from torch.nn import Transformer
+import copy
+
+
+class MultiheadAttentionwithRelativePositionalEmbedding(nn.Module):
+    def __init__(self, dmodel, num_heads, dropout=0, Er_provided=False, max_len=3):
+        super(MultiheadAttentionwithRelativePositionalEmbedding, self).__init__()
+        self.L = 2 * max_len - 1
+        self.num_heads = num_heads
+        self.max_len = max_len
+        self.head_dim = dmodel // num_heads
+        assert self.head_dim * num_heads == dmodel, "embed_dim must be divisible by num_heads"
+
+        self.key = nn.Linear(dmodel, dmodel)
+        self.value = nn.Linear(dmodel, dmodel)
+        self.query = nn.Linear(dmodel, dmodel)
+        self.dropout = nn.Dropout(dropout)
+        self.Er_provided = Er_provided
+        self.num_heads = num_heads
+        
+        if not Er_provided:
+            self.Er = nn.Parameter(torch.randn(num_heads, self.L, self.head_dim))
+
+    def forward(self, query, key, value, Er=None, layer=0, attn_mask=None):
+        #x: (batch, len, dmodel)
+        #Srel: (num_head, tgt_len, src_len)
+        #attn_mask:  (batch, num_head, tgt_len, src_len): float tensor
+        bs, tgt_len, d_model = query.shape
+        _, src_len, _ = key.shape
+
+        q = self.query(query).reshape(bs, tgt_len, self.num_heads, self.head_dim).transpose(1, 2)  #(batch, num_head, tgt_len, head_dim)
+        k = self.key(key).reshape(bs, src_len, self.num_heads, self.head_dim).permute(0, 2, 3, 1)  #(batch, num_head, head_dim, src_len)
+        v = self.value(value).reshape(bs, src_len, self.num_heads, self.head_dim).transpose(1, 2)  #(batch, num_head, src_len, head_dim)
+
+        Er_t = torch.zeros(self.num_heads, 2*src_len-1, self.head_dim, device=query.device)
+        dilation_len = min(1 + (src_len-1)//(2**layer), self.max_len)
+        if not self.Er_provided:
+            Er_t[:, [src_len-1 + i*(2**layer) for i in range(-dilation_len+1, dilation_len)], :] = self.Er[:, self.max_len-dilation_len: self.max_len+dilation_len-1, :]
+        else:
+            Er_t[:, [src_len-1 + i*(2**layer) for i in range(-dilation_len+1, dilation_len)], :] = Er[:, self.max_len-dilation_len: self.max_len+dilation_len-1, :]
+        Er_t = Er_t.transpose(-2, -1)   #(num_head, head_dim, src_L)
+
+        QEr = torch.matmul(q, Er_t) #(num_head, num_head, tgt_len, src_L)
+        #print(QEr[0, 0])
+        Srel = self.skew(QEr, src_len) #(num_head, num_head, tgt_len, src_len)
+        #print('Srel', Srel[1, 1])
+
+        attn = (torch.matmul(q, k) + Srel) / math.sqrt(self.head_dim) #(batch, num_head, tgt_len, src_len)
+        
+        if attn_mask is not None:
+            #print(attn.shape, attn_mask.shape)
+            attn += attn_mask
+            #for i in range(attn.shape[0]):
+            #    print(attn_mask[i, 0])
+        attn = F.softmax(attn, dim=-1)
+
+        out = torch.matmul(attn, v) #(batch, num_head, tgt_len, head_dim)
+        out = out.transpose(1, 2).reshape(bs, tgt_len, d_model) #(batch, tgt_len, d_model)
+
+        return self.dropout(out), attn
+        
+    def skew(self, QEr, src_len):
+        #QEr: (batch, num_heads, tgt_len, src_L)
+        bs, num_heads, tgt_len, src_L = QEr.shape
+        QEr = F.pad(QEr, (0, 1))    #(batch, num_heads, tgt_len, src_L+1)
+        QEr = QEr.reshape(bs, num_heads, -1)   #(batch, num_heads, tgt_len*(src_L+1))
+        QEr = F.pad(QEr, (0, src_L-tgt_len))    #(batch, num_heads, (tgt_len+1)*src_L)
+        QEr = QEr.reshape(bs, num_heads, tgt_len+1, src_L)
+        QEr = QEr[:, :, :tgt_len, -src_len:]    #(batch, num_heads, tgt_len, src_len)
+        return QEr
+
+
+class TransformerEncoderLayer(nn.Module):
+    def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1, Er_provided=False, max_len=3, layer_norm_eps=1e-5, norm_first=False):
+        super(TransformerEncoderLayer, self).__init__()
+        self.self_attn = MultiheadAttentionwithRelativePositionalEmbedding(d_model, nhead, dropout, Er_provided, max_len)
+        # Implementation of Feedforward model
+        self.linear1 = nn.Linear(d_model, dim_feedforward)
+        self.dropout = nn.Dropout(dropout)
+        self.linear2 = nn.Linear(dim_feedforward, d_model)
+
+        self.norm_first = norm_first
+        self.norm1 = LayerNorm(d_model, eps=layer_norm_eps)
+        self.norm2 = LayerNorm(d_model, eps=layer_norm_eps)
+        self.dropout1 = nn.Dropout(dropout)
+        self.dropout2 = nn.Dropout(dropout)
+
+        self.activation = F.gelu
+
+    def forward(self, x, Er=None, layer=0, src_mask=None):
+        #x: (batch, len, dmodel)
+        #Er: (num_head, tgt_len, src_len)
+        #key_padding_mask: (batch, num_head, tgt_len, src_len), bool tensor
+        #attn_mask:  (batch, num_head, tgt_len, src_len): float tensor
+        if self.norm_first:
+            x = x + self._sa_block(self.norm1(x), Er, layer, src_mask)
+            x = x + self._ff_block(self.norm2(x))
+        else:
+            x = self.norm1(x + self._sa_block(x, Er, layer, src_mask))
+            x = self.norm2(x + self._ff_block(x))
+        return x
+
+    # self-attention block
+    def _sa_block(self, x, Er=None, layer=0, attn_mask=None):
+        x = self.self_attn(x, x, x, Er, layer, attn_mask=attn_mask)[0]
+        return self.dropout1(x)
+
+    # feed forward block
+    def _ff_block(self, x):
+        x = self.linear2(self.dropout(self.activation(self.linear1(x))))
+        return self.dropout2(x)
+
+
+
+def generate_dilation_self_attention_mask(batch, num_head, seq_len, max_len, layer):
+        attn_mask = torch.eye(seq_len).repeat(batch, num_head, 1, 1)
+        mask_temp = torch.eye(seq_len).repeat(batch, num_head, 1, 1)
+        for i in range(1, max_len):
+            attn_mask[:, :, : -i*(2**layer), i*(2**layer):] += mask_temp[:, :, i*(2**layer):, i*(2**layer):]
+            attn_mask[:, :, i*(2**layer):, : -i*(2**layer)] += mask_temp[:, :, i*(2**layer):, i*(2**layer):]
+        attn_mask = (1-attn_mask).masked_fill((attn_mask == 0), -float('inf'))
+        return attn_mask
+
+
+
+
+if __name__ == '__main__':
+    MAX_LEN=3
+    LAYER=0
+
+    model = MultiheadAttentionwithRelativePositionalEmbedding(dmodel=12, num_heads=6, max_len=MAX_LEN)
+
+    x = torch.ones(3, 8, 12)
+
+    attn_mask = generate_dilation_self_attention_mask(3, 6, 8, MAX_LEN, LAYER)
+    #print(attn_mask[1, 1, :, :].numpy())
+
+    output, attn = model(x, x, x, attn_mask=attn_mask, layer=LAYER)
+    #print(attn[1, 1])

Beat-Transformer/code/ablation_models/non_demix_model.py

@@ -0,0 +1,261 @@
+import torch 
+from torch import nn 
+from DilatedTransformerLayer import DilatedTransformerLayer
+
+
+class DilatedTransformerModel(nn.Module):
+    def __init__(self, attn_len=5, ntoken=2, dmodel=128, nhead=2, d_hid=512, nlayers=9, norm_first=True, dropout=.1):
+        super(DilatedTransformerModel, self).__init__()
+        self.nhead = nhead
+        self.nlayers = nlayers
+        self.attn_len = attn_len
+        self.head_dim = dmodel // nhead
+        assert self.head_dim * nhead == dmodel, "embed_dim must be divisible by num_heads"
+
+        #self.Er = nn.Parameter(torch.randn(nlayers, nhead, self.head_dim, attn_len))
+
+        self.conv1 = nn.Conv2d(in_channels=1, out_channels=32, kernel_size=(5, 3), stride=1, padding=(2, 0))#126
+        #self.conv1 = nn.Conv2d(in_channels=1, out_channels=32, kernel_size=(3, 3), stride=1, padding=(1, 0))#79
+        self.maxpool1 = nn.MaxPool2d(kernel_size=(1, 3), stride=(1, 3))#26
+        self.dropout1 = nn.Dropout(p=dropout)
+        
+        self.conv2 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=(1, 12), stride=1, padding=(0, 0))#31
+        #self.conv2 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=(1, 12), stride=1, padding=(0, 0))#15
+        self.maxpool2 = nn.MaxPool2d(kernel_size=(1, 3), stride=(1, 3))#5
+        self.dropout2 = nn.Dropout(p=dropout)
+        
+        self.conv3 = nn.Conv2d(in_channels=64, out_channels=dmodel, kernel_size=(3, 6), stride=1, padding=(1, 0))#5
+        #self.conv3 = nn.Conv2d(in_channels=64, out_channels=dmodel, kernel_size=(3, 3), stride=1, padding=(1, 0))#3
+        self.maxpool3 = nn.MaxPool2d(kernel_size=(1, 3), stride=(1, 3))#1
+        self.dropout3 = nn.Dropout(p=dropout)
+        
+        self.Transformer_layers = nn.ModuleDict({})
+        for idx in range(nlayers):
+            self.Transformer_layers[f'Transformer_layer_{idx}'] = DilatedTransformerLayer(dmodel, nhead, d_hid, dropout, Er_provided=False, attn_len=attn_len, norm_first=norm_first)
+
+        self.out_linear = nn.Linear(dmodel, ntoken)
+
+        self.dropout_t = nn.Dropout(p=.5)
+        self.out_linear_t = nn.Linear(dmodel, 300)
+        
+
+    def forward(self, x):
+        #x: (batch, time, dmodel), FloatTensor
+        x = x.unsqueeze(1)  #(batch, channel, time, dmodel)
+        x = self.conv1(x)
+        x = self.maxpool1(x)
+        x = torch.relu(x)
+        x = self.dropout1(x)
+
+        x = self.conv2(x)
+        x = self.maxpool2(x)
+        x = torch.relu(x)
+        x = self.dropout2(x)
+
+        x = self.conv3(x)
+        x = self.maxpool3(x)
+        x = torch.relu(x)
+        x = self.dropout3(x)    #(batch, channel, time, 1)
+        x = x.transpose(1, 3).squeeze(1).contiguous()    #(batch, time, channel=dmodel)
+        
+        batch, time, dmodel = x.shape
+        t = []
+        for layer in range(self.nlayers):
+            x, skip = self.Transformer_layers[f'Transformer_layer_{layer}'](x, layer=layer)
+            t.append(skip)
+
+        x = torch.relu(x)
+        x = self.out_linear(x)
+
+        t = torch.stack(t, axis=-1).sum(dim=-1)
+        t = torch.relu(t)
+        t = self.dropout_t(t)
+        t = t.mean(dim=1) #(batch, dmodel)
+        t = self.out_linear_t(t)
+
+        return x, t
+
+    def inference(self, x):
+        #x: (batch, time, dmodel), FloatTensor
+        x = x.unsqueeze(1)  #(batch, channel, time, dmodel)
+        x = self.conv1(x)
+        x = self.maxpool1(x)
+        x = torch.relu(x)
+        x = self.dropout1(x)
+
+        x = self.conv2(x)
+        x = self.maxpool2(x)
+        x = torch.relu(x)
+        x = self.dropout2(x)
+
+        x = self.conv3(x)
+        x = self.maxpool3(x)
+        x = torch.relu(x)
+        x = self.dropout3(x)    #(batch, channel, time, 1)
+        x = x.transpose(1, 3).squeeze(1).contiguous()    #(batch, time, channel=dmodel)
+        
+        batch, time, dmodel = x.shape
+        t = []
+        attn = [torch.eye(time, device=x.device).repeat(batch, self.nhead, 1, 1)]
+        for layer in range(self.nlayers):
+            x, skip, layer_attn = self.Transformer_layers[f'Transformer_layer_{layer}'].inference(x, layer=layer)
+            t.append(skip)
+            attn.append(torch.matmul(attn[-1], layer_attn.transpose(-2, -1)))
+
+
+        x = torch.relu(x)
+        x = self.out_linear(x)
+
+        t = torch.stack(t, axis=-1).sum(dim=-1)
+        t = torch.relu(t)
+        t = self.dropout_t(t)
+        t = t.mean(dim=1) #(batch, dmodel)
+        t = self.out_linear_t(t)
+
+        return x, t, attn
+
+
+if __name__ == '__main__':
+    from non_demix_spectrogram_dataset import audioDataset
+    from torch.utils.data import DataLoader
+    from tqdm import tqdm
+    import numpy as np
+    import madmom
+    from utils import AverageMeter
+    SAMPLE_SIZE = int(44100 / 1024 * 180)
+    INSTR =5
+    FPS = 44100 / 1024
+    NUM_FOLDS = 8
+    #model
+    NORM_FIRST=True
+    ATTN_LEN=5
+    NTOKEN=2
+    DMODEL=256
+    NHEAD=8
+    DHID=512
+    NLAYER=9
+    DROPOUT=.1
+
+    DEVICE=f'cuda:{0}'
+    TRAIN_BATCH_SIZE = 1
+
+    DATASET_PATH = './data/demix_spectrogram_data.npz'
+    ANNOTATION_PATH = './data/full_beat_annotation.npz'
+    DATA_TO_LOAD = ['gtzan']
+    TEST_ONLY = ['gtzan']
+
+    model = DilatedTransformerModel(attn_len=ATTN_LEN,
+                                    ntoken=NTOKEN, 
+                                    dmodel=DMODEL, 
+                                    nhead=NHEAD, 
+                                    d_hid=DHID, 
+                                    nlayers=NLAYER, 
+                                    norm_first=NORM_FIRST,
+                                    dropout=DROPOUT
+                                    )
+    model.load_state_dict(torch.load("/mnt/c/Users/zhaoj/Desktop/trf_param_018.pt", map_location=torch.device(DEVICE)))
+    model.to(DEVICE)
+
+
+    dataset = audioDataset(data_to_load=DATA_TO_LOAD,
+                        test_only_data = TEST_ONLY,
+                        data_path = DATASET_PATH, 
+                        annotation_path = ANNOTATION_PATH,
+                        fps = FPS,
+                        sample_size = SAMPLE_SIZE,
+                        num_folds = 1)
+    _, _, test_set = dataset.get_fold(fold=0)
+    #loader = DataLoader(val_set, batch_size=1, shuffle=False)
+    loader = DataLoader(test_set, batch_size=1, shuffle=False)
+
+
+    beat_DBN_meter = AverageMeter()
+    downbeat_DBN_meter = AverageMeter()
+
+    beat_tracker = madmom.features.beats.DBNBeatTrackingProcessor(min_bpm=55.0, max_bpm=215.0, fps=FPS, 
+                                                                    transition_lambda=100, 
+                                                                    observation_lambda=6, 
+                                                                    num_tempi=None, 
+                                                                    threshold=0.2)
+
+    downbeat_tracker = madmom.features.downbeats.DBNDownBeatTrackingProcessor(beats_per_bar=[3, 4], min_bpm=55.0, max_bpm=215.0, fps=FPS, 
+                                                                    transition_lambda=100, 
+                                                                    observation_lambda=6, 
+                                                                    num_tempi=None, 
+                                                                    threshold=0.2)
+
+    activations = {}
+    beat_gt = {}
+    downbeat_gt = {}
+
+    count = 0
+    with torch.no_grad():
+        for idx, (dataset_key, data, beat, downbeat, tempo, root) in tqdm(enumerate(loader), total=len(loader)):
+            #data
+            data = data.float().to(DEVICE)
+            print(data.shape)
+            pred, _ = model(data)
+            beat_pred = torch.sigmoid(pred[0, :, 0]).detach().cpu().numpy()
+            downbeat_pred = torch.sigmoid(pred[0, :, 1]).detach().cpu().numpy()
+
+            beat = torch.nonzero(beat[0]>.5)[:, 0].detach().numpy() / (FPS)
+            downbeat = torch.nonzero(downbeat[0]>.5)[:, 0].detach().numpy() / (FPS)
+
+            dataset_key = dataset_key[0]
+            root = root[0]
+            if not dataset_key in activations:
+                activations[dataset_key] = []
+                beat_gt[dataset_key] = []
+                downbeat_gt[dataset_key] = []
+            activations[dataset_key].append(np.stack((beat_pred, downbeat_pred), axis=0))
+            beat_gt[dataset_key].append(beat)
+            downbeat_gt[dataset_key].append(downbeat)
+
+            #count += 1
+            #if count == 50:
+            #    break
+
+    for dataset_key in activations:
+        print(f'inferencing on {dataset_key} ...')
+        beat_error = 0
+        downbeat_error = 0
+        for i in tqdm(range(len(activations[dataset_key]))):
+            pred = activations[dataset_key][i]
+            #print(pred.shape)
+            beat = beat_gt[dataset_key][i]
+            downbeat = downbeat_gt[dataset_key][i]
+
+            try:
+                dbn_beat_pred = beat_tracker(pred[0])
+                beat_score_DBN = madmom.evaluation.beats.BeatEvaluation(dbn_beat_pred, beat)
+                beat_DBN_meter.update(f'{dataset_key}-fmeasure', beat_score_DBN.fmeasure)
+                beat_DBN_meter.update(f'{dataset_key}-cmlt', beat_score_DBN.cmlt)
+                beat_DBN_meter.update(f'{dataset_key}-amlt', beat_score_DBN.amlt)
+                
+            except Exception as e:
+                #print(f'beat inference encounter exception {e}')
+                beat_error += 1
+
+
+            try:
+                combined_act = np.concatenate((np.maximum(pred[0] - pred[1], np.zeros(pred[0].shape))[:, np.newaxis], pred[1][:, np.newaxis]), axis=-1)   #(T, 2)
+                #print(combined_act.shape)
+                dbn_downbeat_pred = downbeat_tracker(combined_act)
+                dbn_downbeat_pred = dbn_downbeat_pred[dbn_downbeat_pred[:, 1]==1][:, 0]
+
+                downbeat_score_DBN = madmom.evaluation.beats.BeatEvaluation(dbn_downbeat_pred, downbeat)
+                downbeat_DBN_meter.update(f'{dataset_key}-fmeasure', downbeat_score_DBN.fmeasure)
+                downbeat_DBN_meter.update(f'{dataset_key}-cmlt', downbeat_score_DBN.cmlt)
+                downbeat_DBN_meter.update(f'{dataset_key}-amlt', downbeat_score_DBN.amlt)
+            except Exception as e:
+                #print(f'downbeat inference encounter exception {e}')
+                downbeat_error += 1
+        print(f'beat error: {beat_error}; downbeat error: {downbeat_error}')
+
+    print('DBN beat detection')
+    for key in beat_DBN_meter.avg.keys():
+        print('\t', key, beat_DBN_meter.avg[key])
+
+    print('DBN downbeat detection')
+    for key in downbeat_DBN_meter.avg.keys():
+        print('\t', key, downbeat_DBN_meter.avg[key])

Beat-Transformer/code/ablation_models/non_demix_spectrogram_dataset.py

@@ -0,0 +1,393 @@
+import os
+import time
+import madmom
+import torch
+import librosa
+import numpy as np
+from torch.utils.data import Dataset
+from scipy.ndimage import maximum_filter1d
+from tqdm import tqdm
+from matplotlib import pyplot as plt
+import librosa.display
+from scipy.interpolate import interp1d
+from scipy.signal import argrelmax
+
+
+
+class dataset_processing(Dataset):
+    def __init__(self, full_data, 
+                    full_annotation, 
+                    audio_files,
+                    mode='train', 
+                    fold=0, 
+                    fps=44100/1024,
+                    sample_size = 512,
+                    num_folds=8,
+                    mask_value=-1,
+                    test_only = []  
+                    ):
+        self.fold = fold
+        self.num_folds = num_folds
+        self.fps = fps
+        self.mode = mode
+        self.sample_size = sample_size
+        self.MASK_VALUE = mask_value
+
+        self.data = []
+        self.beats = []
+        self.downbeats = []
+        self.tempi = []
+        self.root = []
+
+        if self.mode == 'train':
+            self.dataset_name = []
+            self.train_clip(full_data, full_annotation, test_only=test_only)
+        
+        elif self.mode == 'validation' or self.mode == 'test':
+            self.dataset_name = []
+            self.audio_files = []
+            self.val_and_test_clip(full_data, full_annotation, audio_files, test_only=test_only)
+
+        full_data = None
+        full_annotation = None
+            
+    def train_clip(self, full_data, full_annotation, num_tempo_bins=300, test_only=[]):
+        for fold_idx in tqdm(range(self.num_folds)):
+            if (fold_idx != self.fold) and (fold_idx != (self.fold+1)%self.num_folds):
+                for key in full_data:
+                    if key == test_only:
+                        continue
+                    #print(f'processing {key} under fold {fold_idx}')
+                    for song_idx in range(len(full_data[key][fold_idx])):
+                        song = full_data[key][fold_idx][song_idx]   #(t, 5, mel)
+                        annotation = full_annotation[key][fold_idx][song_idx]
+                        try:
+                            #print(annotation, annotation.shape)
+                            if len(annotation.shape) == 2:
+                                beat = madmom.utils.quantize_events(annotation[:, 0], fps=self.fps, length=len(song))
+                            else:
+                                beat = madmom.utils.quantize_events(annotation[:], fps=self.fps, length=len(song))
+                            beat = np.maximum(beat, maximum_filter1d(beat, size=3) * 0.5)
+                            beat = np.maximum(beat, maximum_filter1d(beat, size=3) * 0.5)
+                        except:
+                            beat = np.ones(len(song), dtype='float32') * self.MASK_VALUE
+                            print(f'beat load error at {key} dataset, skip it')
+                        
+                        try:
+                            downbeat = annotation[annotation[:, 1] == 1][:, 0]
+                            downbeat = madmom.utils.quantize_events(downbeat, fps=self.fps, length=len(song))
+                            downbeat = np.maximum(downbeat, maximum_filter1d(downbeat, size=3) * 0.5)
+                            downbeat = np.maximum(downbeat, maximum_filter1d(downbeat, size=3) * 0.5)
+                        except:
+                            downbeat = np.ones(len(song), dtype='float32') * self.MASK_VALUE
+                            if not ((key == 'smc') or (key == 'musicnet')):
+                                print(f'downbeat load error at {key} dataset, skip it')
+
+                        try:
+                            #tempo = self.infer_tempo(annotation[:, 0])
+                            #tempo = np.array([int(np.round(tempo))])
+                            tempo = np.zeros(num_tempo_bins, dtype='float32')
+                            if len(annotation.shape) == 2:
+                                tempo[int(np.round(self.infer_tempo(annotation[:, 0])))] = 1
+                            else:
+                                tempo[int(np.round(self.infer_tempo(annotation[:])))] = 1
+                            tempo = np.maximum(tempo, maximum_filter1d(tempo, size=3) * 0.5)
+                            tempo = np.maximum(tempo, maximum_filter1d(tempo, size=3) * 0.5)
+                            tempo = tempo/sum(tempo)
+                            #tempo += np.maximum(tempo, maximum_filter1d(tempo, size=3) * 0.25)
+                        except:
+                            #tempo = np.array([self.MASK_VALUE]) 
+                            tempo = np.ones(num_tempo_bins, dtype='float32') * self.MASK_VALUE
+          
+                        if self.sample_size is None:
+                                self.dataset_name.append(key)
+                                self.data.append(song)
+                                self.beats.append(beat)
+                                self.downbeats.append(downbeat)
+                                self.tempi.append(tempo)
+                        else:
+                            if len(song) <= self.sample_size:
+                                self.dataset_name.append(key)
+                                self.data.append(song)
+                                self.beats.append(beat)
+                                self.downbeats.append(downbeat)
+                                self.tempi.append(tempo)
+                            else:
+                                for i in range(0, len(song)-self.sample_size+1, self.sample_size):
+                                    self.dataset_name.append(key)
+                                    self.data.append(song[i: i+self.sample_size])
+                                    self.beats.append(beat[i: i+self.sample_size])
+                                    self.downbeats.append(downbeat[i: i+self.sample_size])
+                                    self.tempi.append(tempo)
+                                if i + self.sample_size < len(song):
+                                    self.dataset_name.append(key)
+                                    self.data.append(song[len(song)-self.sample_size:])
+                                    self.beats.append(beat[len(song)-self.sample_size:])
+                                    self.downbeats.append(downbeat[len(song)-self.sample_size:])
+                                    self.tempi.append(tempo)
+
+
+        #print(len(self.data), len(self.beats), len(self.downbeats))
+
+    def val_and_test_clip(self, full_data, full_annotation, audio_files, num_tempo_bins=300, test_only=[]):
+        if self.mode == 'validation':
+            fold_idx = (self.fold+1)%self.num_folds
+        elif self.mode == 'test':
+            fold_idx = self.fold
+        for key in tqdm(full_data, total=len(full_data)):
+            #print(f'processing {key}')
+            if ((self.mode == 'validation') and (key in test_only)):
+                continue
+            for song_idx in range(len(full_data[key][fold_idx])):
+                song = full_data[key][fold_idx][song_idx]
+                annotation = full_annotation[key][fold_idx][song_idx]
+                audio_file = audio_files[key][fold_idx][song_idx]
+                try:
+                    if len(annotation.shape) == 2:
+                        beat = madmom.utils.quantize_events(annotation[:, 0], fps=self.fps, length=len(song))
+                    else: 
+                        beat = madmom.utils.quantize_events(annotation[:], fps=self.fps, length=len(song))
+                    beat = np.maximum(beat, maximum_filter1d(beat, size=3) * 0.5)
+                    beat = np.maximum(beat, maximum_filter1d(beat, size=3) * 0.5)
+                except:
+                    beat = np.ones(len(song), dtype='float32') * self.MASK_VALUE
+                    print(f'beat load error at {key} dataset, skip it')
+
+                try:
+                    downbeat = annotation[annotation[:, 1] == 1][:, 0]
+                    downbeat = madmom.utils.quantize_events(downbeat, fps=self.fps, length=len(song))
+                    downbeat = np.maximum(downbeat, maximum_filter1d(downbeat, size=3) * 0.5)
+                    downbeat = np.maximum(downbeat, maximum_filter1d(downbeat, size=3) * 0.5)
+                except:
+                    downbeat = np.ones(len(song), dtype='float32') * self.MASK_VALUE
+                    if not ((key == 'smc') or (key == 'musicnet')):
+                        print(f'downbeat load error at {key} dataset, skip it')
+
+                try:
+                    #tempo = self.infer_tempo(annotation[:, 0])
+                    #tempo = np.array([int(np.round(tempo))])
+                    tempo = np.zeros(num_tempo_bins, dtype='float32')
+                    if len(annotation.shape) == 2:
+                        tempo[int(np.round(self.infer_tempo(annotation[:, 0])))] = 1
+                    else:
+                        tempo[int(np.round(self.infer_tempo(annotation[:])))] = 1
+                    tempo = np.maximum(tempo, maximum_filter1d(tempo, size=3) * 0.5)
+                    tempo = np.maximum(tempo, maximum_filter1d(tempo, size=3) * 0.5)
+                    tempo = tempo/sum(tempo)
+                except:
+                    #tempo = np.array([self.MASK_VALUE]) 
+                    tempo = np.ones(num_tempo_bins, dtype='float32') * self.MASK_VALUE
+                
+                if self.sample_size is None:
+                        self.dataset_name.append(key)
+                        self.root.append(audio_file)
+                        self.data.append(song)
+                        self.beats.append(beat)
+                        self.downbeats.append(downbeat)
+                        self.tempi.append(tempo)
+                else:
+                    eval_sample_size = int(44100/1024 * 420)
+                    if len(song) <= eval_sample_size:
+                        self.dataset_name.append(key)
+                        self.root.append(audio_file)
+                        self.data.append(song)
+                        self.beats.append(beat)
+                        self.downbeats.append(downbeat)
+                        self.tempi.append(tempo)
+                    else:
+                        for i in range(0, len(song)-eval_sample_size+1, eval_sample_size):
+                            self.dataset_name.append(key)
+                            self.root.append(audio_file)
+                            self.data.append(song[i: i+eval_sample_size])
+                            self.beats.append(beat[i: i+eval_sample_size])
+                            self.downbeats.append(downbeat[i: i+eval_sample_size])
+                            self.tempi.append(tempo)
+                        if i + eval_sample_size < len(song):
+                            self.dataset_name.append(key)
+                            self.root.append(audio_file)
+                            self.data.append(song[len(song)-eval_sample_size:])
+                            self.beats.append(beat[len(song)-eval_sample_size:])
+                            self.downbeats.append(downbeat[len(song)-eval_sample_size:])
+                            self.tempi.append(tempo)
+
+    def infer_tempo(self, beats, hist_smooth=4, no_tempo=-1):
+        ibis = np.diff(beats) * self.fps
+        bins = np.bincount(np.round(ibis).astype(int))
+        # if no beats are present, there is no tempo
+        if not bins.any():
+            return no_tempo
+        # smooth histogram bins
+        if hist_smooth > 0:
+            bins = madmom.audio.signal.smooth(bins, hist_smooth)
+        #print(bins)
+        intervals = np.arange(len(bins))       
+        # create interpolation function
+        interpolation_fn = interp1d(intervals, bins, 'quadratic')
+        # generate new intervals with 1000x the resolution
+        intervals = np.arange(intervals[0], intervals[-1], 0.001)
+        tempi = 60.0 * self.fps / intervals
+        # apply quadratic interpolation
+        bins = interpolation_fn(intervals)
+        peaks = argrelmax(bins, mode='wrap')[0]
+        if len(peaks) == 0:
+            # no peaks, no tempo
+            return no_tempo
+        else:
+            # report only the strongest tempo
+            sorted_peaks = peaks[np.argsort(bins[peaks])[::-1]]
+            return tempi[sorted_peaks][0]
+                
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, index):
+        x = np.sum(self.data[index], axis=1).transpose(1, 0) #(dmodel, T)
+        x = librosa.power_to_db(x, ref=np.max)
+        x = x.T
+        return self.dataset_name[index], x, self.beats[index], self.downbeats[index], self.tempi[index], self.root[index]
+        
+
+
+
+
+class audioDataset(object):
+    def __init__(self, data_to_load=['ballroom', 'carnetic', 'gtzan', 'hainsworth', 'smc', 'harmonix'],
+                        test_only_data = ['hainsworth'],
+                        data_path="/data1/zhaojw/dataset/linear_spectrogram_data.npz", 
+                        annotation_path="/data1/zhaojw/dataset/beat_annotation.npz",
+                        fps=44100/1024,
+                        SEED = 0,
+                        num_folds=8,
+                        mask_value = -1,
+                        sample_size = 512
+                ):
+
+        self.fps = fps
+        self.sample_size = sample_size
+        self.mask_value = mask_value
+        self.num_folds = num_folds
+        self.test_only_data = test_only_data
+
+        load_linear_spectr = np.load(data_path, allow_pickle=True)
+        load_annotation = np.load(annotation_path, allow_pickle=True)
+
+        self.full_data = {}
+        self.full_annotation = {}
+        self.audio_files = {}
+        for key in load_linear_spectr:
+            if key in data_to_load:
+                time1 = time.time()
+                print(f'loading {key} dataset ...')
+                data = load_linear_spectr[key]
+                annotation = load_annotation[key]
+                assert(len(data) == len(annotation))
+
+                with open(f'./data/audio_lists/{key}.txt', 'r') as f:
+                    audio_root = f.readlines()
+                audio_root = [item.replace('\n', '') for item in audio_root]
+                assert(len(data) == len(audio_root))
+                print(f'finish loading {key} with shape {data.shape}, using {time.time()-time1}s.')
+                #fold split
+                self.full_data[key] = {}
+                self.full_annotation[key] = {}
+                self.audio_files[key] = {}
+                if key in self.test_only_data:
+                    FOLD_SIZE = len(data) // num_folds
+                    np.random.seed(SEED)
+                    np.random.shuffle(data)
+                    np.random.seed(SEED)
+                    np.random.shuffle(annotation)
+                    np.random.seed(SEED)
+                    np.random.shuffle(audio_root)
+                    for i in range(num_folds):
+                        self.full_data[key][i] = data[:]
+                        self.full_annotation[key][i] = annotation[:]
+                        self.audio_files[key][i] = audio_root[:]
+                else:
+                    FOLD_SIZE = len(data) // num_folds
+                    np.random.seed(SEED)
+                    np.random.shuffle(data)
+                    np.random.seed(SEED)
+                    np.random.shuffle(annotation)
+                    np.random.seed(SEED)
+                    np.random.shuffle(audio_root)
+                    for i in range(num_folds-1):
+                        self.full_data[key][i] = data[i*FOLD_SIZE: (i+1)*FOLD_SIZE]
+                        self.full_annotation[key][i] = annotation[i*FOLD_SIZE: (i+1)*FOLD_SIZE]
+                        self.audio_files[key][i] = audio_root[i*FOLD_SIZE: (i+1)*FOLD_SIZE]
+                    self.full_data[key][num_folds-1] = data[(num_folds-1)*FOLD_SIZE: len(data)]
+                    self.full_annotation[key][num_folds-1] = annotation[(num_folds-1)*FOLD_SIZE: len(annotation)]
+                    self.audio_files[key][num_folds-1] = audio_root[(num_folds-1)*FOLD_SIZE: len(audio_root)]
+                data = None
+                annotation = None
+
+    def get_fold(self, fold=0):
+        print('processing train_set')
+        train_set = dataset_processing(full_data=self.full_data, 
+                                        full_annotation=self.full_annotation, 
+                                        audio_files=None,
+                                        mode='train', 
+                                        fps=self.fps,
+                                        fold=fold, 
+                                        sample_size = self.sample_size,
+                                        num_folds=self.num_folds,
+                                        mask_value=self.mask_value,
+                                        test_only=self.test_only_data
+                                        )
+
+        print('processing val_set')
+        val_set = dataset_processing(full_data=self.full_data, 
+                                        full_annotation=self.full_annotation, 
+                                        audio_files=self.audio_files,
+                                        mode='validation', 
+                                        fps=self.fps,
+                                        fold=fold, 
+                                        sample_size=self.sample_size,
+                                        num_folds=self.num_folds,
+                                        mask_value=self.mask_value,
+                                        test_only=self.test_only_data
+                                        )
+
+        print('processing test_set')
+        test_set = dataset_processing(full_data=self.full_data, 
+                                        full_annotation=self.full_annotation, 
+                                        audio_files=self.audio_files,
+                                        mode='test', 
+                                        fps=self.fps,
+                                        fold=fold, 
+                                        sample_size=self.sample_size,
+                                        num_folds=self.num_folds,
+                                        mask_value=self.mask_value,
+                                        test_only=self.test_only_data
+                                        )
+        return train_set, val_set, test_set
+
+
+    
+if __name__ == '__main__':
+    from torch.utils.data import DataLoader
+    #data_to_load=['ballroom', 'carnetic', 'gtzan', 'hainsworth', 'smc', 'harmonix']
+    dataset = audioDataset(data_to_load=['smc'],
+                        test_only_data = ['gtzan'],
+                        data_path = "./data/demix_spectrogram_data.npz", 
+                        annotation_path = "./data/full_beat_annotation.npz",
+                        fps = 44100/1024,
+                        sample_size = None,
+                        num_folds = 8)
+    # Fold Splitting
+    train_set, val_set, test_set = dataset.get_fold(fold=0)
+    #train_loader = DataLoader(train_set, batch_size=1, shuffle=True)
+    #val_loader = DataLoader(val_set, batch_size=1, shuffle=False)
+    test_loader = DataLoader(test_set, batch_size=1, shuffle=False)
+    #for i, (key, data, beat, downbeat, tempo) in enumerate(val_data):
+    for i, (key, data, beat, downbeat, tempo, root) in enumerate(test_loader):
+        print('key:', key)
+        print('data:', data.shape)
+        print('beat:', beat.shape)
+        #print('beat:', torch.nonzero(beat))
+        print('downbeat:', downbeat.shape)
+        print('tempo:', tempo.shape)
+        print('audio_root:', root)
+        #print('downbeat:', torch.nonzero(downbeat))
+        break
+    

Beat-Transformer/code/ablation_models/tcn.py

@@ -0,0 +1,121 @@
+import torch
+import torch.nn as nn
+
+
+class residual_block(nn.Module):
+    def __init__(self, i, in_channels, num_filter, kernel_size, dropout):
+        super(residual_block, self).__init__()
+        self.res = nn.Conv1d(in_channels=in_channels, out_channels=num_filter, kernel_size=1, padding='same')
+        self.conv1 = nn.Conv1d(in_channels=in_channels, out_channels=num_filter, kernel_size=kernel_size, dilation=i, padding='same')
+        self.conv2 = nn.Conv1d(in_channels=in_channels, out_channels=num_filter, kernel_size=kernel_size, dilation=i*2, padding='same')
+        self.elu = nn.ELU()
+        self.spatial_dropout = nn.Dropout2d(p=dropout)
+        self.conv_final = nn.Conv1d(in_channels=num_filter * 2, out_channels=num_filter, kernel_size=1, padding='same')
+
+    def forward(self, x):
+        #x: (B, F, T)
+        x_res = self.res(x)
+        x_1 = self.conv1(x)
+        x_2 = self.conv2(x)
+        x = torch.cat([x_1, x_2], dim=1)
+        x = self.elu(x).unsqueeze(-1) #(B, F, T, 1)
+        x = self.spatial_dropout(x).squeeze(-1) #(B, F, T)
+        x = self.conv_final(x)
+        return x + x_res, x
+
+
+class TCN(nn.Module):
+    def __init__(self, num_layers=11, dropout=.1, kernel_size=5, n_token=2):
+        super(TCN, self).__init__()
+        self.nlayers = num_layers
+
+        self.conv1 = nn.Conv2d(in_channels=1, out_channels=20, kernel_size=3, stride=1, padding=(2, 0))
+        self.maxpool1 = nn.MaxPool2d(kernel_size=(1, 3), stride=(1, 3))
+        self.dropout1 = nn.Dropout(p=dropout)
+
+        self.conv2 = nn.Conv2d(in_channels=20, out_channels=20, kernel_size=(1, 12), stride=1, padding=0)
+        self.maxpool2 = nn.MaxPool2d(kernel_size=(1, 3), stride=(1, 3))
+        self.dropout2 = nn.Dropout(p=dropout)
+
+        self.conv3 = nn.Conv2d(in_channels=20, out_channels=20, kernel_size=3, stride=1, padding=0)
+        self.maxpool3 = nn.MaxPool2d(kernel_size=(1, 3), stride=(1, 3))
+        self.dropout3 = nn.Dropout(p=dropout)
+
+        self.tcn_layers = nn.ModuleDict({})
+        for layer in range(num_layers):
+            self.tcn_layers[f'TCN_layer_{layer}'] = residual_block(i=2**layer, in_channels=20, num_filter=20, kernel_size=kernel_size, dropout=dropout)
+
+        self.out_linear = nn.Linear(20, n_token)
+
+        self.dropout_t = nn.Dropout(p=.5)
+        self.out_linear_t = nn.Linear(20, 300)
+
+        
+    def forward(self, x):
+        # x: spectrogram of size (B, T, mel_bin)
+        x = x.unsqueeze(1)  #(B, 1, T, mel_bin)
+        x = self.conv1(x)
+        x = self.maxpool1(x)
+        x = self.dropout1(x)
+
+        x = self.conv2(x)
+        x = self.maxpool2(x)
+        x = self.dropout2(x)
+
+        x = self.conv3(x)
+        x = self.maxpool3(x)
+        x = self.dropout3(x)    #(B, 20, T, 1)
+        x = x.squeeze(-1) #(B, 20, T)
+
+        t = []
+        for layer in range(self.nlayers):
+            x, skip = self.tcn_layers[f'TCN_layer_{layer}'](x)  #x: B, 20, T; skip: B, 20, T
+            t.append(skip)
+
+        x = torch.relu(x).transpose(-2, -1)
+        x = self.out_linear(x)
+
+        t = torch.stack(t, axis=-1).sum(dim=-1)
+        t = torch.relu(t)
+        t = self.dropout_t(t)
+        t = t.mean(dim=-1) #(batch, 20)
+        t = self.out_linear_t(t)
+
+        return x, t
+
+
+if __name__ == '__main__':
+    from spectrogram_dataset import audioDataset
+    from torch.utils.data import DataLoader
+
+    DEVICE = 'cuda:2'
+    model = TCN(num_layers=11, dropout=.15)
+    model.to(DEVICE)
+    model.eval()
+    dataset = audioDataset(data_to_load=['smc'],
+                            data_path = "/data1/zhaojw/dataset/madmom_data_100fps.npz", 
+                            annotation_path = "/data1/zhaojw/dataset/beat_annotation.npz",
+                            fps = 100,
+                            sample_size = None,
+                            downsample_size=1,
+                            hop_size = 128,
+                            fold = 0,
+                            num_folds = 8)
+    
+    print(len(dataset.train_set), len(dataset.val_set), len(dataset.test_set))
+    train_data = DataLoader(dataset.train_set, batch_size=1, shuffle=True)
+    val_data = DataLoader(dataset.val_set, batch_size=1, shuffle=False)
+
+    #for i, (key, instr, data, mask, beat, downbeat) in enumerate(val_data):
+    for i, (key, data, beat, downbeat, tempo) in enumerate(val_data):
+        print(key)
+
+        data = data.float().cuda(DEVICE)#B, time, mel
+        print(f'data: {data.shape}')
+        print(f'beat: {beat.shape}')
+        print(f'downbeat: {downbeat.shape}')
+        print(f'tempo: {tempo.shape}')
+
+        x, t = model(data)
+        print(f'out: {x.shape}, {t.shape}')
+        break

Beat-Transformer/code/ablation_models/tcn_demix_model.py

@@ -0,0 +1,187 @@
+import torch 
+from torch import nn 
+from music_transformer import TransformerEncoderLayer
+import torch.nn.functional as F 
+import math
+import sys
+
+from tcn import residual_block
+
+
+class DemixedTCN(nn.Module):
+    def __init__(self, attn_len=5, instr=5, ntoken=2, dmodel=128, nhead=2, d_hid=512, nlayers=9, norm_first=True, dropout=.1):
+        super(DemixedTCN, self).__init__()
+        self.nhead = nhead
+        self.nlayers = nlayers
+        self.attn_len = attn_len
+        self.head_dim = dmodel // nhead
+        self.dmodel = dmodel
+        assert self.head_dim * nhead == dmodel, "embed_dim must be divisible by num_heads"
+
+        #self.Er = nn.Parameter(torch.randn(nhead, self.head_dim, attn_len))
+        #instr_pe = self.generate_instr_pe(ninstr, dmodel)
+        #self.register_buffer('instr_pe', instr_pe)
+
+        self.conv1 = nn.Conv2d(in_channels=1, out_channels=32, kernel_size=(5, 3), stride=1, padding=(2, 0))#126
+        self.maxpool1 = nn.MaxPool2d(kernel_size=(1, 3), stride=(1, 3))#42
+        self.dropout1 = nn.Dropout(p=dropout)
+        
+        self.conv2 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=(1, 12), stride=1, padding=(0, 0))#31
+        self.maxpool2 = nn.MaxPool2d(kernel_size=(1, 3), stride=(1, 3))#10
+        self.dropout2 = nn.Dropout(p=dropout)
+        
+        self.conv3 = nn.Conv2d(in_channels=64, out_channels=dmodel, kernel_size=(3, 6), stride=1, padding=(1, 0))#5
+        self.maxpool3 = nn.MaxPool2d(kernel_size=(1, 3), stride=(1, 3))#1
+        self.dropout3 = nn.Dropout(p=dropout)
+
+        self.head_er = nn.Parameter(torch.randn(nhead, self.head_dim, 1))
+        
+        self.Transformer_layers = nn.ModuleDict({})
+        for idx in range(nlayers):
+            #self.Transformer_layers[f'time_attention_{idx}'] = DilatedTransformerLayer(dmodel, nhead, d_hid, dropout, Er_provided=False, attn_len=attn_len, norm_first=norm_first)
+            self.Transformer_layers[f'time_attention_{idx}'] = residual_block(2**idx, dmodel, dmodel, attn_len, dropout)
+            
+            
+            if (idx >= 3) and (idx <= 5):
+                self.Transformer_layers[f'instr_attention_{idx}'] = TransformerEncoderLayer(dmodel, nhead, d_hid, dropout, Er_provided=False, max_len=instr, norm_first=norm_first)
+            
+        self.out_linear = nn.Linear(dmodel, ntoken)
+
+        self.dropout_t = nn.Dropout(p=.5)
+        self.out_linear_t = nn.Linear(dmodel, 300)
+        
+
+    def forward(self, x):
+        #x: (batch, instr, time, dmodel), FloatTensor
+        #batch, time, dmodel = x.shape
+        batch, instr, time, melbin = x.shape
+        x = x.reshape(-1, 1, time, melbin)
+        x = self.conv1(x)
+        x = self.maxpool1(x)
+        x = torch.relu(x)
+        x = self.dropout1(x)
+
+        x = self.conv2(x)
+        x = self.maxpool2(x)
+        x = torch.relu(x)
+        x = self.dropout2(x)
+
+        x = self.conv3(x)
+        x = self.maxpool3(x)
+        x = torch.relu(x)
+        x = self.dropout3(x)    #(batch*instr, channel, time, 1)
+
+        x = x.reshape(-1, self.dmodel, time).transpose(1, 2)    #(batch*instr, time, channel=dmodel)
+        t = []
+
+        for layer in range(self.nlayers):
+            x = x.transpose(-1, -2)
+            x, skip = self.Transformer_layers[f'time_attention_{layer}'](x)
+
+            x = x.transpose(-1, -2)
+            skip = skip.transpose(-1, -2).reshape(batch, instr, time, self.dmodel)
+            #skip = skip.reshape(batch, instr, time, self.dmodel)
+            t.append(skip.mean(1))
+  
+            if (layer >= 3) and (layer <= 5):
+                x = x.reshape(batch, instr, time, self.dmodel)
+                x = x.permute(0, 2, 1, 3)
+                x = x.reshape(-1, instr, self.dmodel)
+
+                #x = self.Transformer_layers[f'instr_attention_{layer}'](x, layer=layer)
+                x = self.Transformer_layers[f'instr_attention_{layer}'](x)
+
+                x = x.reshape(batch, time, instr, self.dmodel)
+                x = x.permute(0, 2, 1, 3)
+                x = x.reshape(-1, time, self.dmodel)
+            
+        x = torch.relu(x)
+        x = x.reshape(batch, instr, time, self.dmodel)
+        x = x.mean(1)
+        x = self.out_linear(x)
+
+        t = torch.stack(t, axis=-1).sum(dim=-1)
+        t = torch.relu(t)
+        t = self.dropout_t(t)
+        t = t.mean(dim=1) #(batch, dmodel)
+        t = self.out_linear_t(t)
+
+        return x, t
+
+    def inference(self, x):
+        #x: (batch, instr, time, dmodel), FloatTensor
+        #batch, time, dmodel = x.shape
+        batch, instr, time, melbin = x.shape
+        x = x.reshape(-1, 1, time, melbin)
+        x = self.conv1(x)
+        x = self.maxpool1(x)
+        x = torch.relu(x)
+        x = self.dropout1(x)
+
+        x = self.conv2(x)
+        x = self.maxpool2(x)
+        x = torch.relu(x)
+        x = self.dropout2(x)
+
+        x = self.conv3(x)
+        x = self.maxpool3(x)
+        x = torch.relu(x)
+        x = self.dropout3(x)    #(batch*instr, channel, time, 1)
+
+        x = x.reshape(-1, self.dmodel, time).transpose(1, 2)    #(batch*instr, time, channel=dmodel)
+        t = []
+
+        attn = [torch.eye(time, device=x.device).repeat(batch, self.nhead, 1, 1)]
+
+        for layer in range(self.nlayers):
+            x, skip, layer_attn = self.Transformer_layers[f'time_attention_{layer}'].inference(x, layer=layer, head_er=self.head_er)
+            skip = skip.reshape(batch, instr, time, self.dmodel)
+            t.append(skip.mean(1))
+
+            attn.append(torch.matmul(attn[-1], layer_attn.transpose(-2, -1)))
+  
+            if (layer >= 3) and (layer <= 5):
+                x = x.reshape(batch, instr, time, self.dmodel)
+                x = x.permute(0, 2, 1, 3)
+                x = x.reshape(-1, instr, self.dmodel)
+
+                #x = self.Transformer_layers[f'instr_attention_{layer}'](x, layer=layer)
+                x = self.Transformer_layers[f'instr_attention_{layer}'](x)
+
+                x = x.reshape(batch, time, instr, self.dmodel)
+                x = x.permute(0, 2, 1, 3)
+                x = x.reshape(-1, time, self.dmodel)
+            
+        x = torch.relu(x)
+        x = x.reshape(batch, instr, time, self.dmodel)
+        x = x.mean(1)
+        x = self.out_linear(x)
+
+        t = torch.stack(t, axis=-1).sum(dim=-1)
+        t = torch.relu(t)
+        t = self.dropout_t(t)
+        t = t.mean(dim=1) #(batch, dmodel)
+        t = self.out_linear_t(t)
+
+        return x, t, attn
+
+
+
+
+if __name__ == '__main__':
+    from spectrogram_dataset import audioDataset
+    from torch.utils.data import DataLoader
+
+    DEVICE = 'cpu'
+    model = DemixedTCN(attn_len=5, instr=5, ntoken=2, dmodel=256, nhead=8, d_hid=1024, nlayers=9, norm_first=True, dropout=.1)
+    model.to(DEVICE)
+    model.eval()
+
+    for name, param in model.state_dict().items():
+        print(name, param.shape)
+    # name: str
+    # param: Tensor
+
+    total = sum([param.nelement() for param in model.parameters()])
+    print(total)
+    #print("Number of parameter: %.2fM" % (total/1e6))

Beat-Transformer/code/ablation_models/utils.py

@@ -0,0 +1,301 @@
+import numpy as np
+import json, sys, os
+from torch import nn
+import torch
+from torch.distributions import kl_divergence, Normal
+from torch.optim.lr_scheduler import ExponentialLR
+import random
+import madmom
+
+class AverageMeter(object):
+    """Computes and stores the average and current value"""
+    def __init__(self):
+        self.reset()
+
+    def reset(self):
+        self.val = {}
+        self.avg = {}
+        self.sum = {}
+        self.count = {}
+
+    def update(self, key, val, n=1):
+        if not key in self.val:
+            self.val[key] = val
+            self.sum[key] = val * n
+            self.count[key] = n
+            self.avg[key] = self.sum[key] / self.count[key]
+        else:
+            self.val[key] = val
+            self.sum[key] += val * n
+            self.count[key] += n
+            self.avg[key] = self.sum[key] / self.count[key]
+
+def binary_accuracy(beat_pred, beat_gt):
+    #beat: (B, T)
+    weight = (1 - torch.as_tensor(beat_gt == -1, dtype=torch.int32))
+    beat_pred = torch.as_tensor((torch.sigmoid(beat_pred) >= 0.5), dtype=torch.int32)
+    beat_gt = torch.as_tensor((beat_gt > 0.6), dtype=torch.int32)
+    positives = torch.as_tensor((beat_pred == beat_gt), dtype=torch.int32)
+    positives = positives * weight
+    binary_accuracy = positives.sum() / (weight.sum() + 1e-4)
+    return binary_accuracy
+
+def beat_accuracy(beat_pred, beat_gt, fps):
+    #beat_pred: (B, L), estimation result
+    weight = (1 - torch.as_tensor(beat_gt == -1, dtype=torch.int32))
+    beat_pred = torch.sigmoid(beat_pred) * weight
+    beat_pred = torch.as_tensor((beat_pred - 0.5) > 0, dtype=torch.int32).detach().cpu().numpy()
+    #beat_pred = (beat_pred / fps)
+    beat_gt = torch.as_tensor((beat_gt - 0.5) > 0, dtype=torch.int32).detach().cpu().numpy()
+    #beat_gt = (beat_gt / fps)
+    #print(beat_gt)
+    batch_score = []
+    for idx in range(beat_pred.shape[0]):
+        #if (beat_gt[idx] == 0).all():
+        #    continue
+        if np.sum(beat_gt[idx]) < 2:
+            continue
+        beat_pred_batch = np.nonzero(beat_pred[idx])[0] / fps
+        beat_gt_batch = np.nonzero(beat_gt[idx])[0] / fps
+        #print(beat_gt_batch)
+        score = madmom.evaluation.beats.BeatEvaluation(beat_pred_batch, beat_gt_batch)
+        batch_score.append(score)
+    batch_score = madmom.evaluation.beats.BeatMeanEvaluation(batch_score)
+    return {"fmeasure": batch_score.fmeasure, \
+            #"cemgil": batch_score.cemgil, \
+            #"cmlc": batch_score.cmlc, \
+            "cmlt": batch_score.cmlt, \
+            #"amlc": batch_score.amlc, \
+            "amlt": batch_score.amlt}
+    
+
+def infer_beat_with_DBN(beat_pred, beat_gt, dbn_model, fps):
+    #beat_pred: (B, L), estimation result
+    weight = (1 - torch.as_tensor(beat_gt == -1, dtype=torch.int32))
+    beat_pred = (torch.sigmoid(beat_pred) * weight).detach().cpu().numpy()
+    #beat_pred = (beat_pred / fps)
+    beat_gt = torch.as_tensor((beat_gt - 0.5) > 0, dtype=torch.int32).detach().cpu().numpy()
+    batch_score = []
+    for idx in range(beat_pred.shape[0]):
+        #if (beat_gt[idx] == 0).all():
+        #    continue
+        if np.sum(beat_gt[idx]) < 2:
+            continue
+        try:
+            beat_pred_batch = dbn_model(beat_pred[idx])
+        except:
+            return {"fmeasure": 0, "cmlt": 0, "amlt": 0}
+        beat_gt_batch = np.nonzero(beat_gt[idx])[0] / fps
+        score = madmom.evaluation.beats.BeatEvaluation(beat_pred_batch, beat_gt_batch)
+        batch_score.append(score)
+    batch_score = madmom.evaluation.beats.BeatMeanEvaluation(batch_score)
+    return {"fmeasure": batch_score.fmeasure if not np.isnan(batch_score.fmeasure) else 0, \
+            #"cemgil": batch_score.cemgil, \
+            #"cmlc": batch_score.cmlc, \
+            "cmlt": batch_score.cmlt if not np.isnan(batch_score.cmlt) else 0, \
+            #"amlc": batch_score.amlc, \
+            "amlt": batch_score.amlt if not np.isnan(batch_score.amlt) else 0}
+
+
+def infer_downbeat_with_DBN(beat_pred, downbeat_pred, downbeat_gt, dbn_model, fps):
+    #beat_pred: (B, L), estimation result
+    beat_pred = torch.sigmoid(beat_pred).detach().cpu()
+    downbeat_pred = torch.sigmoid(downbeat_pred).detach().cpu()
+    combined_act = torch.cat((torch.maximum(beat_pred - downbeat_pred, torch.zeros(beat_pred.shape)).unsqueeze(-1), downbeat_pred.unsqueeze(-1)), dim=-1)
+    #beat_pred = (beat_pred / fps)
+    weight = (1 - torch.as_tensor(downbeat_gt == -1, dtype=torch.int32)).unsqueeze(-1).detach().cpu()
+    combined_act = (combined_act * weight).numpy()
+
+    beat_gt = torch.as_tensor((downbeat_gt - 0.5) > 0, dtype=torch.int32).detach().cpu().numpy()
+    batch_score = []
+    for idx in range(beat_pred.shape[0]):
+        #if (beat_gt[idx] == 0).all():
+        #    continue
+        if np.sum(beat_gt[idx]) < 2:
+            continue
+        try:
+            beat_pred_batch = dbn_model(combined_act[idx])
+            beat_pred_batch = beat_pred_batch[beat_pred_batch[:, 1]==1][:, 0]
+        except:
+            return {"fmeasure": 0, "cmlt": 0, "amlt": 0}
+        beat_gt_batch = np.nonzero(beat_gt[idx])[0] / fps
+        score = madmom.evaluation.beats.BeatEvaluation(beat_pred_batch, beat_gt_batch)
+        batch_score.append(score)
+    batch_score = madmom.evaluation.beats.BeatMeanEvaluation(batch_score)
+    return {"fmeasure": batch_score.fmeasure if not np.isnan(batch_score.fmeasure) else 0, \
+            #"cemgil": batch_score.cemgil, \
+            #"cmlc": batch_score.cmlc, \
+            "cmlt": batch_score.cmlt if not np.isnan(batch_score.cmlt) else 0, \
+            #"amlc": batch_score.amlc, \
+            "amlt": batch_score.amlt if not np.isnan(batch_score.amlt) else 0}
+
+
+
+def load_dataset_path(fn='model_config.json'):
+    with open(fn) as f:
+        paths = json.load(f)['dataset_path']
+
+    train_val_path = paths['hpc_data_path']
+    return train_val_path
+
+def load_params_dict(key, fn='model_config.json'):
+    with open(fn) as f:
+        dict = json.load(f)[key]
+    return dict
+
+
+def count_parameters(model):
+    return sum(p.numel() for p in model.parameters() if p.requires_grad)
+
+
+def init_weights(m):
+    for name, param in m.named_parameters():
+        if 'weight' in name:
+            nn.init.normal_(param.data, mean=0, std=0.01)
+        else:
+            nn.init.constant_(param.data, 0)
+
+def standard_normal(shape):
+    N = Normal(torch.zeros(shape), torch.ones(shape))
+    if torch.cuda.is_available():
+        N.loc = N.loc.cuda()
+        N.scale = N.scale.cuda()
+    return N
+
+
+def loss_function_vae(recon_pitch, pitch, dist, pitch_criterion, normal,
+                  weights=(1, .1)):
+    # bs = dist.mean.size(0)
+    #print(recon_pitch.shape, pitch.shape, recon_rhythm.shape, rhythm.shape)
+    pitch_loss = pitch_criterion(recon_pitch, pitch)
+    kl_div = kl_divergence(dist, normal).mean()
+    loss = weights[0] * pitch_loss + weights[1] * kl_div
+    return loss, pitch_loss, kl_div
+
+def loss_function_discr(recon_mask, mask_gt, dist, mask_criterion, normal,
+                  weights=(1, .1)):
+    # bs = dist.mean.size(0)
+    #print(recon_pitch.shape, pitch.shape, recon_rhythm.shape, rhythm.shape)
+    mask_loss = mask_criterion(recon_mask, mask_gt)
+    kl_div = kl_divergence(dist, normal).mean()
+    loss = weights[0] * mask_loss + weights[1] * kl_div
+    return loss, mask_loss, kl_div
+
+def get_complement(mask_gt):
+    #mask_gt: (BT, 128)
+    complement = torch.zeros(mask_gt.shape).long().cuda()
+    for i in range(mask_gt.shape[0]):
+        if random.random() < 0.5:
+            low = max(mask_gt[i].max(0)[-1].item() - 5, 0)
+            high = min(mask_gt[i].max(0)[-1].item() + 6, 127)
+        else:
+            low = max(mask_gt[i].max(0)[-1].item() - 6, 0)
+            high = min(mask_gt[i].max(0)[-1].item() + 5, 127)
+        #print(low, high)
+        complement[i, low: high+1] = 1.
+    return complement - mask_gt
+
+
+# Useful function for how long epochs take
+def epoch_time(start_time, end_time):
+    elapsed_time = end_time - start_time
+    elapsed_mins = int(elapsed_time / 60)
+    elapsed_secs = int(elapsed_time - (elapsed_mins * 60))
+    return elapsed_mins, elapsed_secs
+
+
+class MinExponentialLR(ExponentialLR):
+    def __init__(self, optimizer, gamma, minimum, last_epoch=-1):
+        self.min = minimum
+        super(MinExponentialLR, self).__init__(optimizer, gamma, last_epoch=-1)
+
+    def get_lr(self):
+        return [
+            max(base_lr * self.gamma ** self.last_epoch, self.min)
+            for base_lr in self.base_lrs
+        ]
+
+
+def scheduled_sampling(i, high=0.7, low=0.05):
+    x = 10 * (i - 0.5)
+    z = 1 / (1 + np.exp(x))
+    y = (high - low) * z + low
+    return y
+
+
+
+def piano_roll_to_target(pr):
+    #  pr: (32, 128, 3), dtype=bool
+
+    # Assume that "not (first_layer or second layer) = third_layer"
+    pr[:, :, 1] = np.logical_not(np.logical_or(pr[:, :, 0], pr[:, :, 2]))
+    # To int dtype can make addition work
+    pr = pr.astype(int)
+    # Initialize a matrix to store the duration of a note on the (32, 128) grid
+    pr_matrix = np.zeros((32, 128))
+
+    for i in range(31, -1, -1):
+        # At each iteration
+        # 1. Assure that the second layer accumulates the note duration
+        # 2. collect the onset notes in time step i, and mark it on the matrix.
+
+        # collect
+        onset_idx = np.where(pr[i, :, 0] == 1)[0]
+        pr_matrix[i, onset_idx] = pr[i, onset_idx, 1] + 1
+        if i == 0:
+            break
+        # Accumulate
+        # pr[i - 1, :, 1] += pr[i, :, 1]
+        # pr[i - 1, onset_idx, 1] = 0  # the onset note should be set 0.
+        pr[i, onset_idx, 1] = 0  # the onset note should be set 0.
+        pr[i - 1, :, 1] += pr[i, :, 1]
+
+    return pr_matrix
+
+
+def target_to_3dtarget(pr_mat, max_note_count=11, max_pitch=107, min_pitch=22,
+                       pitch_pad_ind=88, dur_pad_ind=2,
+                       pitch_sos_ind=86, pitch_eos_ind=87):
+    """
+    :param pr_mat: (32, 128) matrix. pr_mat[t, p] indicates a note of pitch p,
+    started at time step t, has a duration of pr_mat[t, p] time steps.
+    :param max_note_count: the maximum number of notes in a time step,
+    including <sos> and <eos> tokens.
+    :param max_pitch: the highest pitch in the dataset.
+    :param min_pitch: the lowest pitch in the dataset.
+    :param pitch_pad_ind: see return value.
+    :param dur_pad_ind: see return value.
+    :param pitch_sos_ind: sos token.
+    :param pitch_eos_ind: eos token.
+    :return: pr_mat3d is a (32, max_note_count, 6) matrix. In the last dim,
+    the 0th column is for pitch, 1: 6 is for duration in binary repr. Output is
+    padded with <sos> and <eos> tokens in the pitch column, but with pad token
+    for dur columns.
+    """
+    pitch_range = max_pitch - min_pitch + 1  # including pad
+    pr_mat3d = np.ones((32, max_note_count, 6), dtype=int) * dur_pad_ind
+    pr_mat3d[:, :, 0] = pitch_pad_ind
+    pr_mat3d[:, 0, 0] = pitch_sos_ind
+    cur_idx = np.ones(32, dtype=int)
+    for t, p in zip(*np.where(pr_mat != 0)):
+        pr_mat3d[t, cur_idx[t], 0] = p - min_pitch
+        binary = np.binary_repr(int(pr_mat[t, p]) - 1, width=5)
+        pr_mat3d[t, cur_idx[t], 1: 6] = \
+            np.fromstring(' '.join(list(binary)), dtype=int, sep=' ')
+        cur_idx[t] += 1
+    pr_mat3d[np.arange(0, 32), cur_idx, 0] = pitch_eos_ind
+    return pr_mat3d
+
+
+def get_low_high_dur_count(pr_mat):
+    # pr_mat (32, 128)
+    # return the maximum duration
+    # return the pitch range
+    # return the number of notes at each column
+
+    pitch_range = np.where(pr_mat != 0)[1]
+    low_pitch = pitch_range.min()
+    high_pitch = pitch_range.max()
+    pitch_dur = pr_mat.max()
+    num_notes = np.count_nonzero(pr_mat, axis=-1)
+    return low_pitch, high_pitch, pitch_dur, num_notes

Beat-Transformer/code/eight_fold_test.py

@@ -0,0 +1,403 @@
+import os
+import pickle
+import torch
+import madmom
+import numpy as np
+from utils import AverageMeter
+from torch.utils.data import DataLoader
+from DilatedTransformer import Demixed_DilatedTransformerModel
+from spectrogram_dataset import audioDataset
+from tqdm import tqdm
+import shutil
+
+import warnings
+warnings.filterwarnings('ignore')
+
+
+FPS = 44100 / 1024
+NUM_FOLDS = 8
+DEVICE='cuda:0'
+#model
+NORM_FIRST=True
+ATTN_LEN=5
+INSTR=5
+NTOKEN=2
+DMODEL=256
+NHEAD=8
+DHID=1024
+NLAYER=9
+#directories
+DATASET_PATH = "./data/demix_spectrogram_data.npz"
+ANNOTATION_PATH = './data/full_beat_annotation.npz'
+DATA_TO_LOAD = ['ballroom']    #'ballroom', 'hainsworth', 'smc', 'carnetic', 'harmonix'
+TEST_ONLY = []
+DEMO_SAVE_ROOT = './save/inference'
+if not os.path.exists(DEMO_SAVE_ROOT):
+    os.makedirs(DEMO_SAVE_ROOT)
+
+
+PARAM_PATH = {
+    0: "./checkpoints/fold_0_trf_param.pt",
+    1: "./checkpoints/fold_1_trf_param.pt",
+    2: "./checkpoints/fold_2_trf_param.pt",
+    3: "./checkpoints/fold_3_trf_param.pt",
+    4: "./checkpoints/fold_4_trf_param.pt",
+    5: "./checkpoints/fold_5_trf_param.pt",
+    6: "./checkpoints/fold_6_trf_param.pt",
+    7: "./checkpoints/fold_7_trf_param.pt"
+}
+
+
+
+def infer_activation():
+    """
+    run the model to predict (down-)beat activations
+    """
+    dataset = audioDataset(data_to_load=DATA_TO_LOAD,
+                            test_only_data = TEST_ONLY,
+                            data_path = DATASET_PATH, 
+                            annotation_path = ANNOTATION_PATH,
+                            fps = FPS,
+                            sample_size = None,
+                            num_folds = NUM_FOLDS)
+
+    inference_pred = {}
+    beat_gt = {}
+    downbeat_gt = {}
+
+    for FOLD in range(NUM_FOLDS):
+        print(f'\nFold {FOLD}')
+        train_set, val_set, test_set = dataset.get_fold(fold=FOLD)
+        #loader = DataLoader(val_set, batch_size=1, shuffle=False)
+        loader = DataLoader(test_set, batch_size=1, shuffle=False)
+
+        model = Demixed_DilatedTransformerModel(attn_len=ATTN_LEN,
+                                                    instr=INSTR,
+                                                    ntoken=NTOKEN, 
+                                                    dmodel=DMODEL, 
+                                                    nhead=NHEAD, 
+                                                    d_hid=DHID, 
+                                                    nlayers=NLAYER, 
+                                                    norm_first=NORM_FIRST
+                                                    )
+        #model.load_state_dict(torch.load(os.path.join(MODEL_PATH, f'Fold_{FOLD}', 'model', 'trf_param_012.pt'), map_location=torch.device('cpu')))
+        model.load_state_dict(torch.load(PARAM_PATH[FOLD], map_location=torch.device('cpu'))['state_dict'])
+        model.to(DEVICE)
+        model.eval()
+
+        with torch.no_grad():
+            for idx, (dataset_key, data, beat, downbeat, tempo, root) in tqdm(enumerate(loader), total=len(loader)):
+                #data
+                data = data.float().to(DEVICE)
+                pred, _ = model(data)
+                beat_pred = torch.sigmoid(pred[0, :, 0]).detach().cpu().numpy()
+                downbeat_pred = torch.sigmoid(pred[0, :, 1]).detach().cpu().numpy()
+
+                beat = torch.nonzero(beat[0]>.5)[:, 0].detach().numpy() / (FPS)
+                downbeat = torch.nonzero(downbeat[0]>.5)[:, 0].detach().numpy() / (FPS)
+
+                dataset_key = dataset_key[0]
+                root = root[0]
+                if not dataset_key in inference_pred:
+                    inference_pred[dataset_key] = []
+                    beat_gt[dataset_key] = []
+                    downbeat_gt[dataset_key] = []
+                inference_pred[dataset_key].append(np.stack((beat_pred, downbeat_pred), axis=0))
+                beat_gt[dataset_key].append(beat)
+                downbeat_gt[dataset_key].append(downbeat)
+
+    #uncomment to save new activation inference
+    #print('saving prediction ...')
+    #with open(os.path.join(DEMO_SAVE_ROOT, 'inference_pred.pkl'), 'wb') as f:
+    #    pickle.dump( inference_pred, f)
+    #print('saving gt ...')
+    #with open(os.path.join(DEMO_SAVE_ROOT, 'beat_gt.pkl'), 'wb') as f:
+    #    pickle.dump(beat_gt, f)
+    #with open(os.path.join(DEMO_SAVE_ROOT, 'down_gt.pkl'), 'wb') as f:
+    #    pickle.dump(downbeat_gt, f)
+
+
+def inference_dbn():
+    """
+    run DBN to decode activations (saved by the last function) to (down-)beat timesteps and calculate accuracy w.r.t. groundtruth
+    """
+    beat_DBN_meter = AverageMeter()
+    downbeat_DBN_meter = AverageMeter()
+
+    beat_tracker = madmom.features.beats.DBNBeatTrackingProcessor(min_bpm=55.0, max_bpm=215.0, fps=FPS, 
+                                                                    transition_lambda=100, 
+                                                                    observation_lambda=6, 
+                                                                    num_tempi=None, 
+                                                                    threshold=0.2)
+
+    downbeat_tracker = madmom.features.downbeats.DBNDownBeatTrackingProcessor(beats_per_bar=[3, 4], min_bpm=55.0, max_bpm=215.0, fps=FPS, 
+                                                                    transition_lambda=100, 
+                                                                    observation_lambda=6, 
+                                                                    num_tempi=None, 
+                                                                    threshold=0.2)
+
+    print('loading activations ...')
+    with open(os.path.join(DEMO_SAVE_ROOT, 'inference_pred.pkl'), 'rb') as f:
+        activations = pickle.load(f)
+    with open(os.path.join(DEMO_SAVE_ROOT, 'beat_gt.pkl'), 'rb') as f:
+        beat_gt = pickle.load(f)
+    with open(os.path.join(DEMO_SAVE_ROOT, 'down_gt.pkl'), 'rb') as f:
+        downbeat_gt = pickle.load(f)
+    
+    for dataset_key in activations:
+        print(f'inferencing on {dataset_key} ...')
+        beat_error = 0
+        downbeat_error = 0
+        for i in tqdm(range(len(activations[dataset_key]))):
+            pred = activations[dataset_key][i]
+            #print(pred.shape)
+            beat = beat_gt[dataset_key][i]
+            downbeat = downbeat_gt[dataset_key][i]
+
+            try:
+                dbn_beat_pred = beat_tracker(pred[0])
+                beat_score_DBN = madmom.evaluation.beats.BeatEvaluation(dbn_beat_pred, beat)
+                beat_DBN_meter.update(f'{dataset_key}-fmeasure', beat_score_DBN.fmeasure)
+                beat_DBN_meter.update(f'{dataset_key}-cmlt', beat_score_DBN.cmlt)
+                beat_DBN_meter.update(f'{dataset_key}-amlt', beat_score_DBN.amlt)
+                
+            except Exception as e:
+                #print(f'beat inference encounter exception {e}')
+                beat_error += 1
+
+
+            try:
+                combined_act = np.concatenate((np.maximum(pred[0] - pred[1], np.zeros(pred[0].shape))[:, np.newaxis], pred[1][:, np.newaxis]), axis=-1)   #(T, 2)
+                #print(combined_act.shape)
+                dbn_downbeat_pred = downbeat_tracker(combined_act)
+                dbn_downbeat_pred = dbn_downbeat_pred[dbn_downbeat_pred[:, 1]==1][:, 0]
+
+                downbeat_score_DBN = madmom.evaluation.beats.BeatEvaluation(dbn_downbeat_pred, downbeat)
+                downbeat_DBN_meter.update(f'{dataset_key}-fmeasure', downbeat_score_DBN.fmeasure)
+                downbeat_DBN_meter.update(f'{dataset_key}-cmlt', downbeat_score_DBN.cmlt)
+                downbeat_DBN_meter.update(f'{dataset_key}-amlt', downbeat_score_DBN.amlt)
+            except Exception as e:
+                #print(f'downbeat inference encounter exception {e}')
+                downbeat_error += 1
+        print(f'beat error: {beat_error}; downbeat error: {downbeat_error}')
+
+    print('DBN beat detection')
+    for key in beat_DBN_meter.avg.keys():
+        print('\t', key, beat_DBN_meter.avg[key])
+
+    print('DBN downbeat detection')
+    for key in downbeat_DBN_meter.avg.keys():
+        print('\t', key, downbeat_DBN_meter.avg[key])
+
+
+def demo_inference_dbn():
+    """
+    calculate accuracy and save the predicted (down-)beat timesteps into txt files
+    """
+    beat_DBN_meter = AverageMeter()
+    downbeat_DBN_meter = AverageMeter()
+
+    beat_tracker = madmom.features.beats.DBNBeatTrackingProcessor(min_bpm=55.0, max_bpm=215.0, fps=FPS, 
+                                                                    transition_lambda=100, 
+                                                                    observation_lambda=6, 
+                                                                    num_tempi=None, 
+                                                                    threshold=0.2)
+
+    downbeat_tracker = madmom.features.downbeats.DBNDownBeatTrackingProcessor(beats_per_bar=[3, 4], min_bpm=55.0, max_bpm=215.0, fps=FPS, 
+                                                                    transition_lambda=100, 
+                                                                    observation_lambda=6, 
+                                                                    num_tempi=None, 
+                                                                    threshold=0.2)
+    for dataset in DATA_TO_LOAD:
+        save_dir = os.path.join(DEMO_SAVE_ROOT, dataset)
+        print(f'Inferencing on {dataset} dataset ...')
+        for song in tqdm(os.listdir(save_dir)):
+            song_dir = os.path.join(save_dir, song)
+            beat_pred = np.loadtxt(os.path.join(song_dir, 'beat_activation.txt'))
+            downbeat_pred = np.loadtxt(os.path.join(song_dir, 'downbeat_activation.txt'))
+            beat_gt = np.loadtxt(os.path.join(song_dir, 'gt_beat.txt'))
+            
+            dbn_beat_pred = beat_tracker(beat_pred)
+            np.savetxt(os.path.join(song_dir, 'dbn_beat_pred.txt'), dbn_beat_pred[:, np.newaxis])
+            beat_score_DBN = madmom.evaluation.beats.BeatEvaluation(dbn_beat_pred, beat_gt)
+            
+            accuracy = [f'fmeasure\t{beat_score_DBN.fmeasure}\n', \
+                        f'cmlt\t{beat_score_DBN.cmlt}\n', \
+                        f'amlt\t{beat_score_DBN.amlt}\n']
+            with open(os.path.join(song_dir, 'accuracy.txt'), 'w') as f:
+                f.writelines(accuracy)
+
+            beat_DBN_meter.update(f'{dataset}-fmeasure', beat_score_DBN.fmeasure)
+            beat_DBN_meter.update(f'{dataset}-cmlt', beat_score_DBN.cmlt)
+            beat_DBN_meter.update(f'{dataset}-amlt', beat_score_DBN.amlt)
+
+
+            combined_act = np.concatenate((np.maximum(beat_pred - downbeat_pred, np.zeros(beat_pred.shape))[:, np.newaxis], downbeat_pred[:, np.newaxis]), axis=-1)   #(T, 2)
+            #print(combined_act.shape)
+            dbn_downbeat_pred = downbeat_tracker(combined_act)
+            dbn_downbeat_pred = dbn_downbeat_pred[dbn_downbeat_pred[:, 1]==1][:, 0]
+            np.savetxt(os.path.join(song_dir, 'dbn_downbeat_pred.txt'), dbn_downbeat_pred[:, np.newaxis])
+
+            #downbeat_score_DBN = madmom.evaluation.beats.BeatEvaluation(dbn_downbeat_pred, downbeat)
+            #downbeat_DBN_meter.update(f'{dataset}-fmeasure', downbeat_score_DBN.fmeasure)
+            #downbeat_DBN_meter.update(f'{dataset}-cmlt', downbeat_score_DBN.cmlt)
+            #downbeat_DBN_meter.update(f'{dataset}-amlt', downbeat_score_DBN.amlt)
+
+    print('DBN beat detection')
+    for key in beat_DBN_meter.avg.keys():
+        print('\t', key, beat_DBN_meter.avg[key])
+
+    print('DBN downbeat detection')
+    for key in downbeat_DBN_meter.avg.keys():
+        print('\t', key, downbeat_DBN_meter.avg[key])
+
+
+
+def infer_gtzan_activation():
+    """
+    predict (down-)beat activations for the test-only GTZAN dataset
+    """
+    dataset = audioDataset(data_to_load=['gtzan'],
+                            test_only_data = ['gtzan'],
+                            data_path = DATASET_PATH, 
+                            annotation_path = ANNOTATION_PATH,
+                            fps = FPS,
+                            sample_size = None,
+                            num_folds = NUM_FOLDS)
+
+    inference_pred = {}
+    beat_gt = {}
+    downbeat_gt = {}
+
+    FOLD = 7
+    train_set, val_set, test_set = dataset.get_fold(fold=FOLD)
+    #loader = DataLoader(val_set, batch_size=1, shuffle=False)
+    loader = DataLoader(test_set, batch_size=1, shuffle=False)
+
+    model = Demixed_DilatedTransformerModel(attn_len=ATTN_LEN,
+                                                instr=INSTR,
+                                                ntoken=NTOKEN, 
+                                                dmodel=DMODEL, 
+                                                nhead=NHEAD, 
+                                                d_hid=DHID, 
+                                                nlayers=NLAYER, 
+                                                norm_first=NORM_FIRST
+                                                )
+    #model.load_state_dict(torch.load(os.path.join(MODEL_PATH, f'Fold_{FOLD}', 'model', 'trf_param_012.pt'), map_location=torch.device('cpu')))
+    model.load_state_dict(torch.load(PARAM_PATH[FOLD], map_location=torch.device('cpu'))['state_dict'])
+    model.to(DEVICE)
+    model.eval()
+
+    with torch.no_grad():
+        for idx, (dataset_key, data, beat, downbeat, tempo, root) in tqdm(enumerate(loader), total=len(loader)):
+            #data
+            data = data.float().to(DEVICE)
+            pred, _ = model(data)
+            beat_pred = torch.sigmoid(pred[0, :, 0]).detach().cpu().numpy()
+            downbeat_pred = torch.sigmoid(pred[0, :, 1]).detach().cpu().numpy()
+
+            beat = torch.nonzero(beat[0]>.5)[:, 0].detach().numpy() / (FPS)
+            downbeat = torch.nonzero(downbeat[0]>.5)[:, 0].detach().numpy() / (FPS)
+
+            dataset_key = dataset_key[0]
+            if not dataset_key in inference_pred[FOLD]:
+                inference_pred[FOLD][dataset_key] = []
+                beat_gt[dataset_key] = []
+                downbeat_gt[dataset_key] = []
+            inference_pred[FOLD][dataset_key].append(np.stack((beat_pred, downbeat_pred), axis=0))
+            beat_gt[dataset_key].append(beat)
+            downbeat_gt[dataset_key].append(downbeat)
+
+
+    #uncomment to save new activation inference
+    #print('saving prediction ...')
+    #with open(os.path.join(DEMO_SAVE_ROOT, 'inference_gtzan_pred.pkl'), 'wb') as f:
+    #    pickle.dump( inference_pred, f)
+    #print('saving gt ...')
+    #with open(os.path.join(DEMO_SAVE_ROOT, 'beat_gtzan_gt.pkl'), 'wb') as f:
+    #    pickle.dump(beat_gt, f)
+    #with open(os.path.join(DEMO_SAVE_ROOT, 'down_gtzan_gt.pkl'), 'wb') as f:
+    #    pickle.dump(downbeat_gt, f)
+
+
+
+def inference_gtzan_dbn():
+    """
+    locate (down-)beat timesteps from activations for the test-only GTZAN dataset
+    """
+    beat_tracker = madmom.features.beats.DBNBeatTrackingProcessor(min_bpm=55.0, max_bpm=215.0, fps=FPS, 
+                                                                    transition_lambda=100, 
+                                                                    observation_lambda=6, 
+                                                                    num_tempi=None, 
+                                                                    threshold=0.2)
+
+    downbeat_tracker = madmom.features.downbeats.DBNDownBeatTrackingProcessor(beats_per_bar=[3, 4], min_bpm=55.0, max_bpm=215.0, fps=FPS, 
+                                                                    transition_lambda=100, 
+                                                                    observation_lambda=6, 
+                                                                    num_tempi=None, 
+                                                                    threshold=0.2)
+
+    print('loading activations ...')
+    with open(os.path.join(DEMO_SAVE_ROOT, 'inference_gtzan_pred.pkl'), 'rb') as f:
+        activations = pickle.load(f)
+    with open(os.path.join(DEMO_SAVE_ROOT, 'beat_gtzan_gt.pkl'), 'rb') as f:
+        beat_gt = pickle.load(f)
+    with open(os.path.join(DEMO_SAVE_ROOT, 'down_gtzan_gt.pkl'), 'rb') as f:
+        downbeat_gt = pickle.load(f)
+    
+    dataset_key ='gtzan'
+    print(f'inferencing on {dataset_key} ...')
+    FOLD = 7
+    beat_DBN_meter = AverageMeter()
+    downbeat_DBN_meter = AverageMeter()
+    beat_error = 0
+    downbeat_error = 0
+    for i in tqdm(range(len(activations[FOLD][dataset_key]))):
+        pred = activations[FOLD][dataset_key][i]
+        #print(pred.shape)
+        beat = beat_gt[dataset_key][i]
+        downbeat = downbeat_gt[dataset_key][i]
+
+        try:
+            dbn_beat_pred = beat_tracker(pred[0])
+            beat_score_DBN = madmom.evaluation.beats.BeatEvaluation(dbn_beat_pred, beat)
+            beat_DBN_meter.update(f'{dataset_key}-fmeasure', beat_score_DBN.fmeasure)
+            beat_DBN_meter.update(f'{dataset_key}-cmlt', beat_score_DBN.cmlt)
+            beat_DBN_meter.update(f'{dataset_key}-amlt', beat_score_DBN.amlt)
+        except Exception as e:
+            #print(f'beat inference encounter exception {e}')
+            beat_error += 1
+
+
+        try:
+            combined_act = np.concatenate((np.maximum(pred[0] - pred[1], np.zeros(pred[0].shape))[:, np.newaxis], pred[1][:, np.newaxis]), axis=-1)   #(T, 2)
+            #print(combined_act.shape)
+            dbn_downbeat_pred = downbeat_tracker(combined_act)
+            dbn_downbeat_pred = dbn_downbeat_pred[dbn_downbeat_pred[:, 1]==1][:, 0]
+
+            downbeat_score_DBN = madmom.evaluation.beats.BeatEvaluation(dbn_downbeat_pred, downbeat)
+            downbeat_DBN_meter.update(f'{dataset_key}-fmeasure', downbeat_score_DBN.fmeasure)
+            downbeat_DBN_meter.update(f'{dataset_key}-cmlt', downbeat_score_DBN.cmlt)
+            downbeat_DBN_meter.update(f'{dataset_key}-amlt', downbeat_score_DBN.amlt)
+        except Exception as e:
+            #print(f'downbeat inference encounter exception {e}')
+            downbeat_error += 1
+    print(f'beat error: {beat_error}; downbeat error: {downbeat_error}')
+
+    print('DBN beat detection')
+    for key in beat_DBN_meter.avg.keys():
+        print('\t', key, beat_DBN_meter.avg[key])
+
+    print('DBN downbeat detection')
+    for key in downbeat_DBN_meter.avg.keys():
+        print('\t', key, downbeat_DBN_meter.avg[key])
+    
+if __name__ == '__main__':
+    #infer_activation()
+    inference_dbn()
+    #infer_gtzan_activation
+    inference_gtzan_dbn()
+
+    
+
+            

Beat-Transformer/code/optimizer.py

@@ -0,0 +1,100 @@
+import math
+import torch
+import itertools as it
+from torch.optim import Optimizer
+from collections import defaultdict
+
+class Lookahead(Optimizer):
+    '''
+    PyTorch implementation of the lookahead wrapper.
+    Lookahead Optimizer: https://arxiv.org/abs/1907.08610
+    '''
+    def __init__(self, optimizer,alpha=0.5, k=6,pullback_momentum="none"):
+        '''
+        :param optimizer:inner optimizer
+        :param k (int): number of lookahead steps
+        :param alpha(float): linear interpolation factor. 1.0 recovers the inner optimizer.
+        :param pullback_momentum (str): change to inner optimizer momentum on interpolation update
+        '''
+        if not 0.0 <= alpha <= 1.0:
+            raise ValueError(f'Invalid slow update rate: {alpha}')
+        if not 1 <= k:
+            raise ValueError(f'Invalid lookahead steps: {k}')
+        self.optimizer = optimizer
+        self.param_groups = self.optimizer.param_groups
+        self.alpha = alpha
+        self.k = k
+        self.step_counter = 0
+        assert pullback_momentum in ["reset", "pullback", "none"]
+        self.pullback_momentum = pullback_momentum
+        self.state = defaultdict(dict)
+
+        # Cache the current optimizer parameters
+        for group in self.optimizer.param_groups:
+            for p in group['params']:
+                param_state = self.state[p]
+                param_state['cached_params'] = torch.zeros_like(p.data)
+                param_state['cached_params'].copy_(p.data)
+
+    def __getstate__(self):
+        return {
+            'state': self.state,
+            'optimizer': self.optimizer,
+            'alpha': self.alpha,
+            'step_counter': self.step_counter,
+            'k':self.k,
+            'pullback_momentum': self.pullback_momentum
+        }
+
+    def zero_grad(self):
+        self.optimizer.zero_grad()
+
+    def state_dict(self):
+        return self.optimizer.state_dict()
+
+    def load_state_dict(self, state_dict):
+        self.optimizer.load_state_dict(state_dict)
+
+    def _backup_and_load_cache(self):
+        """Useful for performing evaluation on the slow weights (which typically generalize better)
+        """
+        for group in self.optimizer.param_groups:
+            for p in group['params']:
+                param_state = self.state[p]
+                param_state['backup_params'] = torch.zeros_like(p.data)
+                param_state['backup_params'].copy_(p.data)
+                p.data.copy_(param_state['cached_params'])
+
+    def _clear_and_load_backup(self):
+        for group in self.optimizer.param_groups:
+            for p in group['params']:
+                param_state = self.state[p]
+                p.data.copy_(param_state['backup_params'])
+                del param_state['backup_params']
+
+    def step(self, closure=None):
+        """Performs a single Lookahead optimization step.
+        Arguments:
+            closure (callable, optional): A closure that reevaluates the model
+                and returns the loss.
+        """
+        loss = self.optimizer.step(closure)
+        self.step_counter += 1
+
+        if self.step_counter >= self.k:
+            self.step_counter = 0
+            # Lookahead and cache the current optimizer parameters
+            for group in self.optimizer.param_groups:
+                for p in group['params']:
+                    param_state = self.state[p]
+                    p.data.mul_(self.alpha).add_(1.0 - self.alpha, param_state['cached_params'])  # crucial line
+                    param_state['cached_params'].copy_(p.data)
+                    if self.pullback_momentum == "pullback":
+                        internal_momentum = self.optimizer.state[p]["momentum_buffer"]
+                        self.optimizer.state[p]["momentum_buffer"] = internal_momentum.mul_(self.alpha).add_(
+                            1.0 - self.alpha, param_state["cached_mom"])
+                        param_state["cached_mom"] = self.optimizer.state[p]["momentum_buffer"]
+                    elif self.pullback_momentum == "reset":
+                        self.optimizer.state[p]["momentum_buffer"] = torch.zeros_like(p.data)
+
+        return loss

Beat-Transformer/code/spectrogram_dataset.py

@@ -0,0 +1,427 @@
+import os
+import time
+import madmom
+import torch
+import librosa
+import numpy as np
+from torch.utils.data import Dataset
+from scipy.ndimage import maximum_filter1d
+from tqdm import tqdm
+from matplotlib import pyplot as plt
+import librosa.display
+from scipy.interpolate import interp1d
+from scipy.signal import argrelmax
+
+
+
+class dataset_processing(Dataset):
+    def __init__(self, full_data, 
+                    full_annotation, 
+                    audio_files,
+                    mode='train', 
+                    fold=0, 
+                    fps=44100/1024,
+                    sample_size = 512,
+                    num_folds=8,
+                    mask_value=-1,
+                    test_only = []  
+                    ):
+        self.fold = fold
+        self.num_folds = num_folds
+        self.fps = fps
+        self.mode = mode
+        self.sample_size = sample_size
+        self.MASK_VALUE = mask_value
+
+        self.data = []
+        self.beats = []
+        self.downbeats = []
+        self.tempi = []
+        self.root = []
+
+        if self.mode == 'train':
+            self.dataset_name = []
+            self.train_clip(full_data, full_annotation, test_only=test_only)
+        
+        elif self.mode == 'validation' or self.mode == 'test':
+            self.dataset_name = []
+            self.audio_files = []
+            self.val_and_test_clip(full_data, full_annotation, audio_files, test_only=test_only)
+
+        full_data = None
+        full_annotation = None
+            
+    def train_clip(self, full_data, full_annotation, num_tempo_bins=300, test_only=[]):
+        for fold_idx in tqdm(range(self.num_folds)):
+            if (fold_idx != self.fold) and (fold_idx != (self.fold+1)%self.num_folds):
+                for key in full_data:
+                    if key == test_only:
+                        continue
+                    #print(f'processing {key} under fold {fold_idx}')
+                    for song_idx in range(len(full_data[key][fold_idx])):
+                        song = full_data[key][fold_idx][song_idx]   #(t, 5, mel)
+                        annotation = full_annotation[key][fold_idx][song_idx]
+                        try:
+                            #print(annotation, annotation.shape)
+                            if len(annotation.shape) == 2:
+                                beat = madmom.utils.quantize_events(annotation[:, 0], fps=self.fps, length=len(song))
+                            else:
+                                beat = madmom.utils.quantize_events(annotation[:], fps=self.fps, length=len(song))
+                            beat = np.maximum(beat, maximum_filter1d(beat, size=3) * 0.5)
+                            beat = np.maximum(beat, maximum_filter1d(beat, size=3) * 0.5)
+                        except:
+                            beat = np.ones(len(song), dtype='float32') * self.MASK_VALUE
+                            print(f'beat load error at {key} dataset, skip it')
+                        
+                        try:
+                            downbeat = annotation[annotation[:, 1] == 1][:, 0]
+                            downbeat = madmom.utils.quantize_events(downbeat, fps=self.fps, length=len(song))
+                            downbeat = np.maximum(downbeat, maximum_filter1d(downbeat, size=3) * 0.5)
+                            downbeat = np.maximum(downbeat, maximum_filter1d(downbeat, size=3) * 0.5)
+                        except:
+                            downbeat = np.ones(len(song), dtype='float32') * self.MASK_VALUE
+                            if not ((key == 'smc') or (key == 'musicnet')):
+                                print(f'downbeat load error at {key} dataset, skip it')
+
+                        try:
+                            #tempo = self.infer_tempo(annotation[:, 0])
+                            #tempo = np.array([int(np.round(tempo))])
+                            tempo = np.zeros(num_tempo_bins, dtype='float32')
+                            if len(annotation.shape) == 2:
+                                tempo[int(np.round(self.infer_tempo(annotation[:, 0])))] = 1
+                            else:
+                                tempo[int(np.round(self.infer_tempo(annotation[:])))] = 1
+                            tempo = np.maximum(tempo, maximum_filter1d(tempo, size=3) * 0.5)
+                            tempo = np.maximum(tempo, maximum_filter1d(tempo, size=3) * 0.5)
+                            tempo = tempo/sum(tempo)
+                            #tempo += np.maximum(tempo, maximum_filter1d(tempo, size=3) * 0.25)
+                        except:
+                            #tempo = np.array([self.MASK_VALUE]) 
+                            tempo = np.ones(num_tempo_bins, dtype='float32') * self.MASK_VALUE
+          
+                        if self.sample_size is None:
+                                self.dataset_name.append(key)
+                                self.data.append(song)
+                                self.beats.append(beat)
+                                self.downbeats.append(downbeat)
+                                self.tempi.append(tempo)
+                        else:
+                            if len(song) <= self.sample_size:
+                                self.dataset_name.append(key)
+                                self.data.append(song)
+                                self.beats.append(beat)
+                                self.downbeats.append(downbeat)
+                                self.tempi.append(tempo)
+                            else:
+                                for i in range(0, len(song)-self.sample_size+1, self.sample_size):
+                                    self.dataset_name.append(key)
+                                    self.data.append(song[i: i+self.sample_size])
+                                    self.beats.append(beat[i: i+self.sample_size])
+                                    self.downbeats.append(downbeat[i: i+self.sample_size])
+                                    self.tempi.append(tempo)
+                                if i + self.sample_size < len(song):
+                                    self.dataset_name.append(key)
+                                    self.data.append(song[len(song)-self.sample_size:])
+                                    self.beats.append(beat[len(song)-self.sample_size:])
+                                    self.downbeats.append(downbeat[len(song)-self.sample_size:])
+                                    self.tempi.append(tempo)
+
+
+        #print(len(self.data), len(self.beats), len(self.downbeats))
+
+    def val_and_test_clip(self, full_data, full_annotation, audio_files, num_tempo_bins=300, test_only=[]):
+        if self.mode == 'validation':
+            fold_idx = (self.fold+1)%self.num_folds
+        elif self.mode == 'test':
+            fold_idx = self.fold
+        for key in tqdm(full_data, total=len(full_data)):
+            #print(f'processing {key}')
+            if ((self.mode == 'validation') and (key in test_only)):
+                continue
+            for song_idx in range(len(full_data[key][fold_idx])):
+                song = full_data[key][fold_idx][song_idx]
+                annotation = full_annotation[key][fold_idx][song_idx]
+                audio_file = audio_files[key][fold_idx][song_idx]
+                try:
+                    if len(annotation.shape) == 2:
+                        beat = madmom.utils.quantize_events(annotation[:, 0], fps=self.fps, length=len(song))
+                    else: 
+                        beat = madmom.utils.quantize_events(annotation[:], fps=self.fps, length=len(song))
+                    beat = np.maximum(beat, maximum_filter1d(beat, size=3) * 0.5)
+                    beat = np.maximum(beat, maximum_filter1d(beat, size=3) * 0.5)
+                except:
+                    beat = np.ones(len(song), dtype='float32') * self.MASK_VALUE
+                    print(f'beat load error at {key} dataset, skip it')
+
+                try:
+                    downbeat = annotation[annotation[:, 1] == 1][:, 0]
+                    downbeat = madmom.utils.quantize_events(downbeat, fps=self.fps, length=len(song))
+                    downbeat = np.maximum(downbeat, maximum_filter1d(downbeat, size=3) * 0.5)
+                    downbeat = np.maximum(downbeat, maximum_filter1d(downbeat, size=3) * 0.5)
+                except:
+                    downbeat = np.ones(len(song), dtype='float32') * self.MASK_VALUE
+                    if not ((key == 'smc') or (key == 'musicnet')):
+                        print(f'downbeat load error at {key} dataset, skip it')
+
+                try:
+                    #tempo = self.infer_tempo(annotation[:, 0])
+                    #tempo = np.array([int(np.round(tempo))])
+                    tempo = np.zeros(num_tempo_bins, dtype='float32')
+                    if len(annotation.shape) == 2:
+                        tempo[int(np.round(self.infer_tempo(annotation[:, 0])))] = 1
+                    else:
+                        tempo[int(np.round(self.infer_tempo(annotation[:])))] = 1
+                    tempo = np.maximum(tempo, maximum_filter1d(tempo, size=3) * 0.5)
+                    tempo = np.maximum(tempo, maximum_filter1d(tempo, size=3) * 0.5)
+                    tempo = tempo/sum(tempo)
+                except:
+                    #tempo = np.array([self.MASK_VALUE]) 
+                    tempo = np.ones(num_tempo_bins, dtype='float32') * self.MASK_VALUE
+                
+                if self.sample_size is None:
+                        self.dataset_name.append(key)
+                        self.root.append(audio_file)
+                        self.data.append(song)
+                        self.beats.append(beat)
+                        self.downbeats.append(downbeat)
+                        self.tempi.append(tempo)
+                else:
+                    eval_sample_size = int(44100/1024 * 420)
+                    if len(song) <= eval_sample_size:
+                        self.dataset_name.append(key)
+                        self.root.append(audio_file)
+                        self.data.append(song)
+                        self.beats.append(beat)
+                        self.downbeats.append(downbeat)
+                        self.tempi.append(tempo)
+                    else:
+                        for i in range(0, len(song)-eval_sample_size+1, eval_sample_size):
+                            self.dataset_name.append(key)
+                            self.root.append(audio_file)
+                            self.data.append(song[i: i+eval_sample_size])
+                            self.beats.append(beat[i: i+eval_sample_size])
+                            self.downbeats.append(downbeat[i: i+eval_sample_size])
+                            self.tempi.append(tempo)
+                        if i + eval_sample_size < len(song):
+                            self.dataset_name.append(key)
+                            self.root.append(audio_file)
+                            self.data.append(song[len(song)-eval_sample_size:])
+                            self.beats.append(beat[len(song)-eval_sample_size:])
+                            self.downbeats.append(downbeat[len(song)-eval_sample_size:])
+                            self.tempi.append(tempo)
+
+    def infer_tempo(self, beats, hist_smooth=4, no_tempo=-1):
+        ibis = np.diff(beats) * self.fps
+        bins = np.bincount(np.round(ibis).astype(int))
+        # if no beats are present, there is no tempo
+        if not bins.any():
+            return no_tempo
+        # smooth histogram bins
+        if hist_smooth > 0:
+            bins = madmom.audio.signal.smooth(bins, hist_smooth)
+        #print(bins)
+        intervals = np.arange(len(bins))       
+        # create interpolation function
+        interpolation_fn = interp1d(intervals, bins, 'quadratic')
+        # generate new intervals with 1000x the resolution
+        intervals = np.arange(intervals[0], intervals[-1], 0.001)
+        tempi = 60.0 * self.fps / intervals
+        # apply quadratic interpolation
+        bins = interpolation_fn(intervals)
+        peaks = argrelmax(bins, mode='wrap')[0]
+        if len(peaks) == 0:
+            # no peaks, no tempo
+            return no_tempo
+        else:
+            # report only the strongest tempo
+            sorted_peaks = peaks[np.argsort(bins[peaks])[::-1]]
+            return tempi[sorted_peaks][0]
+                
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, index):
+        """x = np.sum(self.data[index], axis=1).transpose(1, 0) #(dmodel, T)
+        x = librosa.power_to_db(x, ref=np.max)
+        x = x.T[np.newaxis, :, :]
+        x = np.repeat(x, 5, axis=0)
+        return self.dataset_name[index], x, self.beats[index], self.downbeats[index], self.tempi[index]"""
+        
+        x = np.transpose(self.data[index],( 1, 2, 0))   #5, dmodel, T
+        #x = x + .25 * np.sum(x, axis=0, keepdims=True)
+        #x = [librosa.power_to_db(x[i], ref=np.max) for i in range(x.shape[0])]
+
+        np.random.seed()
+        if self.mode == 'train':
+            p = np.random.rand()
+            if p < .5:  #50% time use 5 subspectrograms
+                pass
+            else:
+                idx_sum = np.random.choice(len(x), size=2, replace=False)
+                x = [x[i] for i in range(len(x)) if i not in idx_sum] + [x[idx_sum[0]] + x[idx_sum[1]]]
+                q = np.random.rand()
+                if q < .6:  #30% time use 4 subspectrograms
+                    pass
+                else:
+                    idx_sum = np.random.choice(len(x), size=2, replace=False)
+                    x = [x[i] for i in range(len(x)) if i not in idx_sum] + [x[idx_sum[0]] + x[idx_sum[1]]]
+                    r = np.random.rand()
+                    if r < .5:  #10% time use 3 subspectrograms
+                        pass
+                    else:  #10% time use 2 subspectrograms
+                        idx_sum = np.random.choice(len(x), size=2, replace=False)
+                        x = [x[i] for i in range(len(x)) if i not in idx_sum] + [x[idx_sum[0]] + x[idx_sum[1]]]
+            
+        x = [librosa.power_to_db(x[i], ref=np.max) for i in range(len(x))]
+        x = np.transpose(np.array(x), (0, 2, 1))    #T, instr, dmodel
+
+        if self.mode == 'test':
+            return self.dataset_name[index], x, self.beats[index], self.downbeats[index], self.tempi[index], self.root[index]
+        else:
+            return self.dataset_name[index], x, self.beats[index], self.downbeats[index], self.tempi[index]
+        
+
+
+
+
+class audioDataset(object):
+    def __init__(self, data_to_load=['ballroom', 'carnetic', 'gtzan', 'hainsworth', 'smc', 'harmonix'],
+                        test_only_data = ['hainsworth'],
+                        data_path="/data1/zhaojw/dataset/linear_spectrogram_data.npz", 
+                        annotation_path="/data1/zhaojw/dataset/beat_annotation.npz",
+                        fps=44100/1024,
+                        SEED = 0,
+                        num_folds=8,
+                        mask_value = -1,
+                        sample_size = 512
+                ):
+
+        self.fps = fps
+        self.sample_size = sample_size
+        self.mask_value = mask_value
+        self.num_folds = num_folds
+        self.test_only_data = test_only_data
+
+        # load_linear_spectr = np.load(data_path, allow_pickle=True)
+        load_annotation = np.load(annotation_path, allow_pickle=True)
+
+        self.full_data = {}
+        self.full_annotation = {}
+        self.audio_files = {}
+        for key in load_annotation:
+            if key in data_to_load:
+                time1 = time.time()
+                print(f'loading {key} dataset ...')
+                # data = load_linear_spectr[key]
+                annotation = load_annotation[key]
+                # assert(len(data) == len(annotation))
+
+                with open(f'./data/audio_lists/{key}.txt', 'r') as f:
+                    audio_root = f.readlines()
+                audio_root = [item.replace('\n', '') for item in audio_root]
+                assert(len(annotation) == len(audio_root))
+                print(f'finish loading {key} with shape {annotation.shape}, using {time.time()-time1}s.')
+                #fold split
+                self.full_data[key] = {}
+                self.full_annotation[key] = {}
+                self.audio_files[key] = {}
+                if key in self.test_only_data:
+                    FOLD_SIZE = len(annotation) // num_folds
+                    np.random.seed(SEED)
+                    np.random.shuffle(data)
+                    np.random.seed(SEED)
+                    np.random.shuffle(annotation)
+                    np.random.seed(SEED)
+                    np.random.shuffle(audio_root)
+                    for i in range(num_folds):
+                        self.full_data[key][i] = audio_root[:]
+                        self.full_annotation[key][i] = annotation[:]
+                        self.audio_files[key][i] = audio_root[:]
+                else:
+                    FOLD_SIZE = len(annotation) // num_folds
+                    np.random.seed(SEED)
+                    np.random.shuffle(data)
+                    np.random.seed(SEED)
+                    np.random.shuffle(annotation)
+                    np.random.seed(SEED)
+                    np.random.shuffle(audio_root)
+                    for i in range(num_folds-1):
+                        self.full_data[key][i] = data[i*FOLD_SIZE: (i+1)*FOLD_SIZE]
+                        self.full_annotation[key][i] = annotation[i*FOLD_SIZE: (i+1)*FOLD_SIZE]
+                        self.audio_files[key][i] = audio_root[i*FOLD_SIZE: (i+1)*FOLD_SIZE]
+                    self.full_data[key][num_folds-1] = data[(num_folds-1)*FOLD_SIZE: len(data)]
+                    self.full_annotation[key][num_folds-1] = annotation[(num_folds-1)*FOLD_SIZE: len(annotation)]
+                    self.audio_files[key][num_folds-1] = audio_root[(num_folds-1)*FOLD_SIZE: len(audio_root)]
+                data = None
+                annotation = None
+
+    def get_fold(self, fold=0):
+        print('processing train_set')
+        train_set = dataset_processing(full_data=self.full_data, 
+                                        full_annotation=self.full_annotation, 
+                                        audio_files=None,
+                                        mode='train', 
+                                        fps=self.fps,
+                                        fold=fold, 
+                                        sample_size = self.sample_size,
+                                        num_folds=self.num_folds,
+                                        mask_value=self.mask_value,
+                                        test_only=self.test_only_data
+                                        )
+
+        print('processing val_set')
+        val_set = dataset_processing(full_data=self.full_data, 
+                                        full_annotation=self.full_annotation, 
+                                        audio_files=self.audio_files,
+                                        mode='validation', 
+                                        fps=self.fps,
+                                        fold=fold, 
+                                        sample_size=self.sample_size,
+                                        num_folds=self.num_folds,
+                                        mask_value=self.mask_value,
+                                        test_only=self.test_only_data
+                                        )
+
+        print('processing test_set')
+        test_set = dataset_processing(full_data=self.full_data, 
+                                        full_annotation=self.full_annotation, 
+                                        audio_files=self.audio_files,
+                                        mode='test', 
+                                        fps=self.fps,
+                                        fold=fold, 
+                                        sample_size=self.sample_size,
+                                        num_folds=self.num_folds,
+                                        mask_value=self.mask_value,
+                                        test_only=self.test_only_data
+                                        )
+        return train_set, val_set, test_set
+
+
+    
+if __name__ == '__main__':
+    from torch.utils.data import DataLoader
+    #data_to_load=['ballroom', 'carnetic', 'gtzan', 'hainsworth', 'smc', 'harmonix']
+    dataset = audioDataset(data_to_load=['ballroom', 'carnetic', 'gtzan', 'hainsworth', 'smc'],
+                        test_only_data = ['gtzan'],
+                        # data_path = "./data/demix_spectrogram_data.npz", 
+                        annotation_path = "/work/fast_data_yinghao/Beat-Transformer/data/full_beat_annotation.npz",
+                        fps = 44100/1024,
+                        sample_size = None,
+                        num_folds = 8)
+    # Fold Splitting
+    train_set, val_set, test_set = dataset.get_fold(fold=0)
+    #train_loader = DataLoader(train_set, batch_size=1, shuffle=True)
+    #val_loader = DataLoader(val_set, batch_size=1, shuffle=False)
+    test_loader = DataLoader(test_set, batch_size=1, shuffle=False)
+    #for i, (key, data, beat, downbeat, tempo) in enumerate(val_data):
+    for i, (key, data, beat, downbeat, tempo, root) in enumerate(test_loader):
+        print('key:', key)
+        print('data:', data.shape)
+        print('beat:', beat.shape)
+        #print('beat:', torch.nonzero(beat))
+        print('downbeat:', downbeat.shape)
+        print('tempo:', tempo.shape)
+        print('audio_root:', root)
+        #print('downbeat:', torch.nonzero(downbeat))
+        break
+    

Beat-Transformer/code/train.py

@@ -0,0 +1,396 @@
+import os
+os.environ['CUDA_LAUNCH_BLOCKING'] = '1'
+import sys
+import time
+import madmom
+import torch
+from tqdm import tqdm
+from torch import nn
+from torch import optim
+from optimizer import Lookahead
+from torch.utils.tensorboard import SummaryWriter
+from torch.utils.data import DataLoader
+from utils import AverageMeter, epoch_time, infer_beat_with_DBN, infer_downbeat_with_DBN
+from spectrogram_dataset import audioDataset
+
+from DilatedTransformer import Demixed_DilatedTransformerModel
+
+import warnings
+warnings.filterwarnings('ignore')
+
+
+DEBUG_MODE = int(sys.argv[1])
+FOLD = int(sys.argv[2])
+GPU = int(sys.argv[3])
+PROJECT_NAME = 'Beat_Transformer'
+
+###############################################################################
+# Load config
+###############################################################################
+#data
+SAMPLE_SIZE = int(44100 / 1024 * 180)
+INSTR =5
+FPS = 44100 / 1024
+NUM_FOLDS = 8
+#model
+NORM_FIRST=True
+ATTN_LEN=5
+NTOKEN=2
+DMODEL=256
+NHEAD=8
+DHID=1024
+NLAYER=9
+DROPOUT=.1
+#training
+DEVICE=f'cuda:{GPU}'
+TRAIN_BATCH_SIZE = 1
+LEARNING_RATE = 1e-3
+DECAY = 0.99995
+N_EPOCH = 30
+CLIP=.5
+#directories
+DATASET_PATH = './data/demix_spectrogram_data.npz'
+ANNOTATION_PATH = './data/full_beat_annotation.npz'
+DATA_TO_LOAD = ['ballroom', 'ballroom', 'gtzan', 'hainsworth', 'smc', 'harmonix', 'carnetic']
+TEST_ONLY = ['gtzan']
+
+SAVE_PATH = f'./save/train_log/{str(GPU).zfill(2)}_{PROJECT_NAME}'
+
+if DEBUG_MODE:
+    N_EPOCH = 1
+    TRAIN_BATCH_SIZE = 1
+    DECAY = 0.9995
+    DATA_TO_LOAD = ['hainsworth']   #hainsworth, smc
+    SAVE_PATH = os.path.join(SAVE_PATH, 'debug')
+
+print(f'\nProject initialized: {PROJECT_NAME}\n', flush=True)
+
+
+print(f'\nFold {FOLD}')
+###############################################################################
+# Initialize fold
+###############################################################################
+project_path = os.path.join(SAVE_PATH, f'Fold_{FOLD}')
+
+MODEL_PATH = os.path.join(project_path, 'model') 
+LOG_PATH = os.path.join(project_path, 'log')
+
+if not os.path.exists(MODEL_PATH):
+    os.makedirs(MODEL_PATH)
+
+if not os.path.exists(LOG_PATH):
+    os.makedirs(LOG_PATH)
+
+loss_writer = SummaryWriter(os.path.join(LOG_PATH, 'loss'))
+#beat_writer = SummaryWriter(os.path.join(LOG_PATH, 'beat_acc'))
+beat_ll_writer = SummaryWriter(os.path.join(LOG_PATH, 'beat_likelihood'))
+downbeat_ll_writer = SummaryWriter(os.path.join(LOG_PATH, 'downbeat_likelihood'))
+beat_pr_writer = SummaryWriter(os.path.join(LOG_PATH, 'beat_precision'))
+downbeat_pr_writer = SummaryWriter(os.path.join(LOG_PATH, 'downbeat_precision'))
+beat_DBN_writer = SummaryWriter(os.path.join(LOG_PATH, 'beat_DBN_acc'))
+#downbeat_writer = SummaryWriter(os.path.join(LOG_PATH, 'downbeat_acc'))
+downbeat_DBN_writer = SummaryWriter(os.path.join(LOG_PATH, 'downbeat_DBN_acc'))
+
+
+###############################################################################
+# model parameter
+###############################################################################
+model = Demixed_DilatedTransformerModel(attn_len=ATTN_LEN,
+                                                instr=INSTR,
+                                                ntoken=NTOKEN, 
+                                                dmodel=DMODEL, 
+                                                nhead=NHEAD, 
+                                                d_hid=DHID, 
+                                                nlayers=NLAYER, 
+                                                norm_first=NORM_FIRST,
+                                                dropout=DROPOUT
+                                                )
+
+model.to(DEVICE)
+
+
+###############################################################################
+# load data
+###############################################################################
+dataset = audioDataset(data_to_load=DATA_TO_LOAD,
+                        test_only_data = TEST_ONLY,
+                        data_path = DATASET_PATH, 
+                        annotation_path = ANNOTATION_PATH,
+                        fps = FPS,
+                        sample_size = SAMPLE_SIZE,
+                        num_folds = NUM_FOLDS)
+# Fold Splitting
+train_set, val_set, test_set = dataset.get_fold(fold=FOLD)
+train_loader = DataLoader(train_set, batch_size=TRAIN_BATCH_SIZE, shuffle=True)
+val_loader = DataLoader(val_set, batch_size=1, shuffle=False)
+#test_loader = DataLoader(test_set, batch_size=1, shuffle=False)
+
+
+###############################################################################
+# Optimizer and Criterion
+###############################################################################
+optimizer = optim.RAdam(model.parameters(), lr=LEARNING_RATE)
+optimizer = Lookahead(optimizer=optimizer, k=5, alpha=0.5)
+#scheduler = MinExponentialLR(optimizer, gamma=DECAY, minimum=1e-5)
+scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, factor=.2, patience=2, threshold=1e-3, min_lr=1e-7)
+loss_func = nn.BCEWithLogitsLoss(reduction='none', pos_weight=torch.LongTensor([1, 1]).to(DEVICE))
+loss_tempo = nn.BCELoss(reduction='none')
+
+beat_tracker = madmom.features.beats.DBNBeatTrackingProcessor(min_bpm=55.0, max_bpm=215.0, fps=FPS, transition_lambda=10, threshold=0.05)
+downbeat_tracker = madmom.features.downbeats.DBNDownBeatTrackingProcessor(beats_per_bar=[3, 4], min_bpm=55.0, max_bpm=215.0, fps=FPS, transition_lambda=10)
+
+
+###############################################################################
+# Main
+###############################################################################
+def train(model, train_loader, optimizer, scheduler, loss_func, loss_tempo, clip, epoch, device):
+    print('training ...', flush=True)
+    num_batch = len(train_loader)
+    loss_meter_b = AverageMeter()
+    loss_meter_t = AverageMeter()
+    beat_meter = AverageMeter()
+    beat_DBN_meter = AverageMeter()
+    downbeat_meter = AverageMeter()
+    downbeat_DBN_meter = AverageMeter()
+    nan_count = []
+    for idx, (dataset_key, data, beat_gt, downbeat_gt, tempo_gt) in tqdm(enumerate(train_loader), total=num_batch):
+        #try:
+        #data
+        data = data.float().to(device)
+        #annotation
+        beat_gt = beat_gt.to(device)
+        downbeat_gt = downbeat_gt.to(device)
+        gt = torch.cat([beat_gt.unsqueeze(-1), downbeat_gt.unsqueeze(-1)], dim=-1).float().to(device) #(batch, T', 2)
+        tempo_gt = tempo_gt.to(device)
+        
+        optimizer.zero_grad()
+        pred, tempo = model(data)
+        #print(pred.shape, gt.shape)
+        valid_gt = gt.clone()
+        valid_gt[gt == -1] = 0
+        loss = loss_func(pred, valid_gt)
+        weight = (1 - torch.as_tensor(gt == -1, dtype=torch.int32)).to(device)
+        loss = (weight * loss).mean(dim=(0, 1)).sum()
+
+        valid_tempo_gt = tempo_gt.clone()
+        valid_tempo_gt[tempo_gt == -1] = 0
+        loss_t = loss_tempo(torch.softmax(tempo, dim=-1), valid_tempo_gt)
+        weight = (1 - torch.as_tensor(tempo_gt == -1, dtype=torch.int32)).to(device)
+        loss_t = (weight * loss_t).mean()
+        #except RuntimeError:
+        #    continue
+        
+        loss_meter_t.update('train/loss', loss_t.item())
+        loss_meter_b.update('train/loss', loss.item())
+        if ((dataset_key[0] == 'musicnet') and (-1 in tempo_gt)):
+            loss =  loss * 0 #do not trust musicnet beat annotation if tempo is none
+
+        #try:
+        loss = loss + loss_t
+        #except RuntimeError:
+        #    continue
+        if torch.isnan(loss):
+            nan_count.append(str(dataset_key)+'\n')
+            with open('./home/zhaojw/workspace/efficient_dilated_MultiSpec_Transformer/nancount.txt', 'w') as f:
+                f.writelines(nan_count)
+            continue
+
+        #downbeat_loss = loss_func(downbeat_pred, downbeat_gt)
+        loss.backward()
+
+        torch.nn.utils.clip_grad_norm_(model.parameters(), clip)
+        optimizer.step()
+        #scheduler.step()
+
+        #binary_acc = binary_accuracy(pred[:, :, :2], gt[:, :, :2])
+        #loss_meter.update('train/loss', loss.item())
+        #loss_meter.update('train/binary_acc', binary_acc.item())
+
+        #beat_acc = beat_accuracy(pred[:, :, 0], gt[:, :, 0], FPS/DS_RATIO)
+        #for key in beat_acc:
+        #    beat_meter.update('train/' + key, beat_acc[key])
+
+        
+        #downbeat_acc = beat_accuracy(pred[:, :, 1], gt[:, :, 1], FPS/DS_RATIO)
+        #if not dataset_key[0] == 'smc':
+        #    for key in downbeat_acc:
+        #        downbeat_meter.update('train/' + key, downbeat_acc[key])
+
+
+        if DEBUG_MODE:
+            print('------------training------------', flush=True)
+            print('Epoch: [{0}][{1}/{2}]'.format(epoch+1, idx, num_batch), flush=True)
+            print('train beat loss:', loss.item()-loss_t.item(), flush=True)
+            print('train tempo loss:', loss_t.item(), flush=True)
+            #print('train binary batch accuracy', binary_acc.item(), flush=True)
+            #print('beat accuracy:', list(beat_acc.values()), flush=True)
+            #print('downbeat accuracy:', list(downbeat_acc.values()), flush=True)
+
+        loss_writer.add_scalar('train/loss_beat', loss_meter_b.avg['train/loss'], epoch * num_batch + idx)
+        loss_writer.add_scalar('train/loss_tempo', loss_meter_t.avg['train/loss'], epoch * num_batch + idx)
+        loss_writer.add_scalar('train/lr', optimizer.param_groups[0]['lr'], epoch * num_batch + idx)
+
+        #for key in beat_meter.avg.keys():
+        #    if 'train' in key:    
+        #        beat_writer.add_scalar(key, beat_meter.avg[key], epoch * num_batch + idx)
+        #for key in beat_DBN_meter.avg.keys():
+        #    if 'train' in key:    
+        #        beat_DBN_writer.add_scalar(key, beat_DBN_meter.avg[key], epoch * num_batch + idx)
+        #for key in downbeat_meter.avg.keys():
+        #    if 'train' in key:    
+        #        downbeat_writer.add_scalar(key, downbeat_meter.avg[key], epoch * num_batch + idx)
+        #for key in downbeat_DBN_meter.avg.keys():
+        #    if 'train' in key:    
+        #        downbeat_DBN_writer.add_scalar(key, downbeat_DBN_meter.avg[key], epoch * num_batch + idx)
+    return loss_meter_b, loss_meter_t, beat_meter, beat_DBN_meter, downbeat_meter, downbeat_DBN_meter
+
+
+def evaluate(model, val_loader, loss_func, loss_tempo, epoch, device):
+    print('validating ...', flush=True)
+    num_batch = len(val_loader)
+    loss_meter_b = AverageMeter()
+    loss_meter_t = AverageMeter()
+    beat_meter = AverageMeter()
+    beat_DBN_meter = AverageMeter()
+    downbeat_meter = AverageMeter()
+    downbeat_DBN_meter = AverageMeter()
+    with torch.no_grad():
+        for idx, (dataset_key, data, beat_gt, downbeat_gt, tempo_gt) in tqdm(enumerate(val_loader), total=num_batch):
+            #try:
+            #data
+            data = data.float().to(device)
+            #annotation
+            beat_gt = beat_gt.to(device)
+            downbeat_gt = downbeat_gt.to(device)
+            gt = torch.cat([beat_gt.unsqueeze(-1), downbeat_gt.unsqueeze(-1)], dim=-1).float().to(device) #(batch, T', 2)
+            #tempo_gt = tempo_gt.reshape(-1).long().to(device)
+            tempo_gt = tempo_gt.float().to(device)
+
+            pred, tempo = model(data)
+            
+            valid_gt = gt.clone()
+            valid_gt[gt == -1] = 0
+            loss = loss_func(pred, valid_gt)
+            weight = (1 - torch.as_tensor(gt == -1, dtype=torch.int32)).to(device)
+            loss = (weight * loss).mean(dim=(0, 1)).sum()
+
+            valid_tempo_gt = tempo_gt.clone()
+            valid_tempo_gt[tempo_gt == -1] = 0
+            loss_t = loss_tempo(torch.softmax(tempo, dim=-1), valid_tempo_gt)
+            weight = (1 - torch.as_tensor(tempo_gt == -1, dtype=torch.int32)).to(device)
+            loss_t = (weight * loss_t).mean()
+            #except RuntimeError:
+            #    continue
+            
+            if not dataset_key[0] == 'gtzan':
+                loss_meter_b.update('val/loss', loss.item())
+            else:
+                loss_meter_b.update('val/loss_nontrain', loss.item())
+
+            if not dataset_key[0] == 'gtzan':
+                loss_meter_t.update('val/loss', loss_t.item())
+            else:
+                loss_meter_t.update('val/loss_nontrain', loss_t.item())
+            
+            #binary_acc = binary_accuracy(pred[:, :, :2], gt[:, :, :2])
+            #if not dataset_key[0][0] == 'gtzan':
+            #    loss_meter.update('val/loss', loss.item())
+            #    loss_meter.update('val/binary_acc', binary_acc.item())
+            #else:
+            #    loss_meter.update('val/loss_nontrain', loss.item())
+            #    loss_meter.update('val/binary_acc_nontrain', binary_acc.item())
+            
+
+            #try:
+            #beat_acc = beat_accuracy(pred[:, :, 0], gt[:, :, 0], FPS/DS_RATIO)
+            #for key in beat_acc:
+            #    beat_meter.update(f'val-{dataset_key[0][0]}/{key}', beat_acc[key])
+
+            beat_acc_DBN = infer_beat_with_DBN(pred[:, :, 0], beat_gt, beat_tracker, FPS)
+            for key in beat_acc_DBN:
+                beat_DBN_meter.update(f'val-{dataset_key[0]}/{key}', beat_acc_DBN[key])
+
+            
+            #downbeat_acc = beat_accuracy(pred[:, :, 1], gt[:, :, 1], FPS/DS_RATIO)
+            #if not dataset_key[0][0] == 'smc':
+            #    for key in downbeat_acc:
+            #        downbeat_meter.update(f'val-{dataset_key[0][0]}/{key}', downbeat_acc[key])
+
+            downbeat_DBN_acc = infer_downbeat_with_DBN(pred[:, :, 0], pred[:, :, 1], downbeat_gt, downbeat_tracker, FPS)
+            if not dataset_key[0] == 'smc':
+                for key in downbeat_DBN_acc:
+                    downbeat_DBN_meter.update(f'val-{dataset_key[0]}/{key}', downbeat_DBN_acc[key])
+
+
+            if DEBUG_MODE:
+                print('------------validation------------', flush=True)
+                print('Epoch: [{0}][{1}/{2}]'.format(epoch+1, idx, num_batch), flush=True)
+                print('val beat loss:', loss.item(), flush=True)
+                print('train tempo loss:', loss_t.item(), flush=True)
+                #print('val batch binary accuracy:', binary_acc.item(), flush=True)
+                #print('beat accuracy:', list(beat_acc.values()), flush=True)
+                print('beat accuracy with DBN:', list(beat_acc_DBN.values()), flush=True)
+                #print('downbeat accuracy:', list(downbeat_acc.values()), flush=True)
+                print('downbeat accuracy with DBN:', list(downbeat_DBN_acc.values()), flush=True)
+            #except Exception as e:
+            #    print(e)
+
+
+        if not dataset_key[0] == 'gtzan':
+            loss_writer.add_scalar('val/loss_beat', loss_meter_b.avg['val/loss'], epoch)
+            loss_writer.add_scalar('val/loss_tempo', loss_meter_t.avg['val/loss'], epoch)
+        else:
+            loss_writer.add_scalar('val/loss_beat_nontrain', loss_meter_b.avg['val/loss_nontrain'], epoch)
+            loss_writer.add_scalar('val/loss_tempo_nontrain', loss_meter_t.avg['val/loss_nontrain'], epoch)
+
+
+        #for key in beat_meter.avg.keys():
+        #    if 'val' in key:    
+        #        beat_writer.add_scalar(key, beat_meter.avg[key], epoch)
+        for key in beat_DBN_meter.avg.keys():
+            if 'val' in key:    
+                beat_DBN_writer.add_scalar(key, beat_DBN_meter.avg[key], epoch)
+        #for key in downbeat_meter.avg.keys():
+        #    if 'val' in key:    
+        #        downbeat_writer.add_scalar(key, downbeat_meter.avg[key], epoch)
+        for key in downbeat_DBN_meter.avg.keys():
+            if 'val' in key:    
+                downbeat_DBN_writer.add_scalar(key, downbeat_DBN_meter.avg[key], epoch)
+    return loss_meter_b, loss_meter_t, beat_meter, beat_DBN_meter, downbeat_meter, downbeat_DBN_meter
+
+
+for epoch in range(N_EPOCH):
+    print(f'Start Epoch: {epoch + 1:02}', flush=True)
+    start_time = time.time()
+
+    model.train()
+    _, _, _, _, _, _ = train(model, train_loader, optimizer, scheduler, loss_func, loss_tempo, CLIP, epoch, DEVICE)
+
+    model.eval()
+    #optimizer._backup_and_load_cache()
+    loss_meter_b, loss_meter_t, beat_meter, beat_DBN_meter, downbeat_meter, downbeat_DBN_meter = evaluate(model, val_loader, loss_func, loss_tempo, epoch, DEVICE)
+    #optimizer._clear_and_load_backup()
+
+    scheduler.step(loss_meter_b.avg['val/loss'] + loss_meter_t.avg['val/loss'])
+
+    #torch.save(model.state_dict(), os.path.join(MODEL_PATH, 'trf_param_'+str(epoch).zfill(3)+'.pt'))
+
+
+    torch.save({ 'epoch': epoch,
+    'state_dict': model.state_dict(),
+    'optimizer': optimizer.state_dict(),
+    'scheduler': scheduler.state_dict(),  
+    }, os.path.join(MODEL_PATH, 'trf_param_'+str(epoch).zfill(3)+'.pt'))
+
+    
+    end_time = time.time()
+    epoch_mins, epoch_secs = epoch_time(start_time, end_time)
+    print(f'Epoch: {epoch + 1:02} | Time: {epoch_mins}m {epoch_secs}s', flush=True)
+
+    print('val beat loss:', loss_meter_b.avg['val/loss'], flush=True)
+    print('val tempo loss:', loss_meter_t.avg['val/loss'], flush=True)
+    #print('beat accuracy:', [(key.split('/')[-1], beat_meter.avg[key]) for key in beat_meter.avg.keys() if 'val' in key], flush=True)
+    print('beat accuracy with DBN:', [(key.split('/')[-1], beat_DBN_meter.avg[key]) for key in beat_DBN_meter.avg.keys() if 'val' in key], flush=True)
+    #print('downbeat accuracy:', [(key.split('/')[-1], downbeat_meter.avg[key]) for key in downbeat_meter.avg.keys() if 'val' in key], flush=True)
+    print('downbeat accuracy with DBN:', [(key.split('/')[-1], downbeat_DBN_meter.avg[key]) for key in downbeat_DBN_meter.avg.keys() if 'val' in key], flush=True)
+    print('\n')

Beat-Transformer/code/train.sh

@@ -0,0 +1,9 @@
+#!/bin/sh
+python ./code/train.py 0 0 0;
+python ./code/train.py 0 1 0;
+python ./code/train.py 0 2 0;
+python ./code/train.py 0 3 0;
+python ./code/train.py 0 4 0;
+python ./code/train.py 0 5 0;
+python ./code/train.py 0 6 0;
+python ./code/train.py 0 7 0 

Beat-Transformer/code/utils.py

@@ -0,0 +1,301 @@
+import numpy as np
+import json, sys, os
+from torch import nn
+import torch
+from torch.distributions import kl_divergence, Normal
+from torch.optim.lr_scheduler import ExponentialLR
+import random
+import madmom
+
+class AverageMeter(object):
+    """Computes and stores the average and current value"""
+    def __init__(self):
+        self.reset()
+
+    def reset(self):
+        self.val = {}
+        self.avg = {}
+        self.sum = {}
+        self.count = {}
+
+    def update(self, key, val, n=1):
+        if not key in self.val:
+            self.val[key] = val
+            self.sum[key] = val * n
+            self.count[key] = n
+            self.avg[key] = self.sum[key] / self.count[key]
+        else:
+            self.val[key] = val
+            self.sum[key] += val * n
+            self.count[key] += n
+            self.avg[key] = self.sum[key] / self.count[key]
+
+def binary_accuracy(beat_pred, beat_gt):
+    #beat: (B, T)
+    weight = (1 - torch.as_tensor(beat_gt == -1, dtype=torch.int32))
+    beat_pred = torch.as_tensor((torch.sigmoid(beat_pred) >= 0.5), dtype=torch.int32)
+    beat_gt = torch.as_tensor((beat_gt > 0.6), dtype=torch.int32)
+    positives = torch.as_tensor((beat_pred == beat_gt), dtype=torch.int32)
+    positives = positives * weight
+    binary_accuracy = positives.sum() / (weight.sum() + 1e-4)
+    return binary_accuracy
+
+def beat_accuracy(beat_pred, beat_gt, fps):
+    #beat_pred: (B, L), estimation result
+    weight = (1 - torch.as_tensor(beat_gt == -1, dtype=torch.int32))
+    beat_pred = torch.sigmoid(beat_pred) * weight
+    beat_pred = torch.as_tensor((beat_pred - 0.5) > 0, dtype=torch.int32).detach().cpu().numpy()
+    #beat_pred = (beat_pred / fps)
+    beat_gt = torch.as_tensor((beat_gt - 0.5) > 0, dtype=torch.int32).detach().cpu().numpy()
+    #beat_gt = (beat_gt / fps)
+    #print(beat_gt)
+    batch_score = []
+    for idx in range(beat_pred.shape[0]):
+        #if (beat_gt[idx] == 0).all():
+        #    continue
+        if np.sum(beat_gt[idx]) < 2:
+            continue
+        beat_pred_batch = np.nonzero(beat_pred[idx])[0] / fps
+        beat_gt_batch = np.nonzero(beat_gt[idx])[0] / fps
+        #print(beat_gt_batch)
+        score = madmom.evaluation.beats.BeatEvaluation(beat_pred_batch, beat_gt_batch)
+        batch_score.append(score)
+    batch_score = madmom.evaluation.beats.BeatMeanEvaluation(batch_score)
+    return {"fmeasure": batch_score.fmeasure, \
+            #"cemgil": batch_score.cemgil, \
+            #"cmlc": batch_score.cmlc, \
+            "cmlt": batch_score.cmlt, \
+            #"amlc": batch_score.amlc, \
+            "amlt": batch_score.amlt}
+    
+
+def infer_beat_with_DBN(beat_pred, beat_gt, dbn_model, fps):
+    #beat_pred: (B, L), estimation result
+    weight = (1 - torch.as_tensor(beat_gt == -1, dtype=torch.int32))
+    beat_pred = (torch.sigmoid(beat_pred) * weight).detach().cpu().numpy()
+    #beat_pred = (beat_pred / fps)
+    beat_gt = torch.as_tensor((beat_gt - 0.5) > 0, dtype=torch.int32).detach().cpu().numpy()
+    batch_score = []
+    for idx in range(beat_pred.shape[0]):
+        #if (beat_gt[idx] == 0).all():
+        #    continue
+        if np.sum(beat_gt[idx]) < 2:
+            continue
+        try:
+            beat_pred_batch = dbn_model(beat_pred[idx])
+        except:
+            return {"fmeasure": 0, "cmlt": 0, "amlt": 0}
+        beat_gt_batch = np.nonzero(beat_gt[idx])[0] / fps
+        score = madmom.evaluation.beats.BeatEvaluation(beat_pred_batch, beat_gt_batch)
+        batch_score.append(score)
+    batch_score = madmom.evaluation.beats.BeatMeanEvaluation(batch_score)
+    return {"fmeasure": batch_score.fmeasure if not np.isnan(batch_score.fmeasure) else 0, \
+            #"cemgil": batch_score.cemgil, \
+            #"cmlc": batch_score.cmlc, \
+            "cmlt": batch_score.cmlt if not np.isnan(batch_score.cmlt) else 0, \
+            #"amlc": batch_score.amlc, \
+            "amlt": batch_score.amlt if not np.isnan(batch_score.amlt) else 0}
+
+
+def infer_downbeat_with_DBN(beat_pred, downbeat_pred, downbeat_gt, dbn_model, fps):
+    #beat_pred: (B, L), estimation result
+    beat_pred = torch.sigmoid(beat_pred).detach().cpu()
+    downbeat_pred = torch.sigmoid(downbeat_pred).detach().cpu()
+    combined_act = torch.cat((torch.maximum(beat_pred - downbeat_pred, torch.zeros(beat_pred.shape)).unsqueeze(-1), downbeat_pred.unsqueeze(-1)), dim=-1)
+    #beat_pred = (beat_pred / fps)
+    weight = (1 - torch.as_tensor(downbeat_gt == -1, dtype=torch.int32)).unsqueeze(-1).detach().cpu()
+    combined_act = (combined_act * weight).numpy()
+
+    beat_gt = torch.as_tensor((downbeat_gt - 0.5) > 0, dtype=torch.int32).detach().cpu().numpy()
+    batch_score = []
+    for idx in range(beat_pred.shape[0]):
+        #if (beat_gt[idx] == 0).all():
+        #    continue
+        if np.sum(beat_gt[idx]) < 2:
+            continue
+        try:
+            beat_pred_batch = dbn_model(combined_act[idx])
+            beat_pred_batch = beat_pred_batch[beat_pred_batch[:, 1]==1][:, 0]
+        except:
+            return {"fmeasure": 0, "cmlt": 0, "amlt": 0}
+        beat_gt_batch = np.nonzero(beat_gt[idx])[0] / fps
+        score = madmom.evaluation.beats.BeatEvaluation(beat_pred_batch, beat_gt_batch)
+        batch_score.append(score)
+    batch_score = madmom.evaluation.beats.BeatMeanEvaluation(batch_score)
+    return {"fmeasure": batch_score.fmeasure if not np.isnan(batch_score.fmeasure) else 0, \
+            #"cemgil": batch_score.cemgil, \
+            #"cmlc": batch_score.cmlc, \
+            "cmlt": batch_score.cmlt if not np.isnan(batch_score.cmlt) else 0, \
+            #"amlc": batch_score.amlc, \
+            "amlt": batch_score.amlt if not np.isnan(batch_score.amlt) else 0}
+
+
+
+def load_dataset_path(fn='model_config.json'):
+    with open(fn) as f:
+        paths = json.load(f)['dataset_path']
+
+    train_val_path = paths['hpc_data_path']
+    return train_val_path
+
+def load_params_dict(key, fn='model_config.json'):
+    with open(fn) as f:
+        dict = json.load(f)[key]
+    return dict
+
+
+def count_parameters(model):
+    return sum(p.numel() for p in model.parameters() if p.requires_grad)
+
+
+def init_weights(m):
+    for name, param in m.named_parameters():
+        if 'weight' in name:
+            nn.init.normal_(param.data, mean=0, std=0.01)
+        else:
+            nn.init.constant_(param.data, 0)
+
+def standard_normal(shape):
+    N = Normal(torch.zeros(shape), torch.ones(shape))
+    if torch.cuda.is_available():
+        N.loc = N.loc.cuda()
+        N.scale = N.scale.cuda()
+    return N
+
+
+def loss_function_vae(recon_pitch, pitch, dist, pitch_criterion, normal,
+                  weights=(1, .1)):
+    # bs = dist.mean.size(0)
+    #print(recon_pitch.shape, pitch.shape, recon_rhythm.shape, rhythm.shape)
+    pitch_loss = pitch_criterion(recon_pitch, pitch)
+    kl_div = kl_divergence(dist, normal).mean()
+    loss = weights[0] * pitch_loss + weights[1] * kl_div
+    return loss, pitch_loss, kl_div
+
+def loss_function_discr(recon_mask, mask_gt, dist, mask_criterion, normal,
+                  weights=(1, .1)):
+    # bs = dist.mean.size(0)
+    #print(recon_pitch.shape, pitch.shape, recon_rhythm.shape, rhythm.shape)
+    mask_loss = mask_criterion(recon_mask, mask_gt)
+    kl_div = kl_divergence(dist, normal).mean()
+    loss = weights[0] * mask_loss + weights[1] * kl_div
+    return loss, mask_loss, kl_div
+
+def get_complement(mask_gt):
+    #mask_gt: (BT, 128)
+    complement = torch.zeros(mask_gt.shape).long().cuda()
+    for i in range(mask_gt.shape[0]):
+        if random.random() < 0.5:
+            low = max(mask_gt[i].max(0)[-1].item() - 5, 0)
+            high = min(mask_gt[i].max(0)[-1].item() + 6, 127)
+        else:
+            low = max(mask_gt[i].max(0)[-1].item() - 6, 0)
+            high = min(mask_gt[i].max(0)[-1].item() + 5, 127)
+        #print(low, high)
+        complement[i, low: high+1] = 1.
+    return complement - mask_gt
+
+
+# Useful function for how long epochs take
+def epoch_time(start_time, end_time):
+    elapsed_time = end_time - start_time
+    elapsed_mins = int(elapsed_time / 60)
+    elapsed_secs = int(elapsed_time - (elapsed_mins * 60))
+    return elapsed_mins, elapsed_secs
+
+
+class MinExponentialLR(ExponentialLR):
+    def __init__(self, optimizer, gamma, minimum, last_epoch=-1):
+        self.min = minimum
+        super(MinExponentialLR, self).__init__(optimizer, gamma, last_epoch=-1)
+
+    def get_lr(self):
+        return [
+            max(base_lr * self.gamma ** self.last_epoch, self.min)
+            for base_lr in self.base_lrs
+        ]
+
+
+def scheduled_sampling(i, high=0.7, low=0.05):
+    x = 10 * (i - 0.5)
+    z = 1 / (1 + np.exp(x))
+    y = (high - low) * z + low
+    return y
+
+
+
+def piano_roll_to_target(pr):
+    #  pr: (32, 128, 3), dtype=bool
+
+    # Assume that "not (first_layer or second layer) = third_layer"
+    pr[:, :, 1] = np.logical_not(np.logical_or(pr[:, :, 0], pr[:, :, 2]))
+    # To int dtype can make addition work
+    pr = pr.astype(int)
+    # Initialize a matrix to store the duration of a note on the (32, 128) grid
+    pr_matrix = np.zeros((32, 128))
+
+    for i in range(31, -1, -1):
+        # At each iteration
+        # 1. Assure that the second layer accumulates the note duration
+        # 2. collect the onset notes in time step i, and mark it on the matrix.
+
+        # collect
+        onset_idx = np.where(pr[i, :, 0] == 1)[0]
+        pr_matrix[i, onset_idx] = pr[i, onset_idx, 1] + 1
+        if i == 0:
+            break
+        # Accumulate
+        # pr[i - 1, :, 1] += pr[i, :, 1]
+        # pr[i - 1, onset_idx, 1] = 0  # the onset note should be set 0.
+        pr[i, onset_idx, 1] = 0  # the onset note should be set 0.
+        pr[i - 1, :, 1] += pr[i, :, 1]
+
+    return pr_matrix
+
+
+def target_to_3dtarget(pr_mat, max_note_count=11, max_pitch=107, min_pitch=22,
+                       pitch_pad_ind=88, dur_pad_ind=2,
+                       pitch_sos_ind=86, pitch_eos_ind=87):
+    """
+    :param pr_mat: (32, 128) matrix. pr_mat[t, p] indicates a note of pitch p,
+    started at time step t, has a duration of pr_mat[t, p] time steps.
+    :param max_note_count: the maximum number of notes in a time step,
+    including <sos> and <eos> tokens.
+    :param max_pitch: the highest pitch in the dataset.
+    :param min_pitch: the lowest pitch in the dataset.
+    :param pitch_pad_ind: see return value.
+    :param dur_pad_ind: see return value.
+    :param pitch_sos_ind: sos token.
+    :param pitch_eos_ind: eos token.
+    :return: pr_mat3d is a (32, max_note_count, 6) matrix. In the last dim,
+    the 0th column is for pitch, 1: 6 is for duration in binary repr. Output is
+    padded with <sos> and <eos> tokens in the pitch column, but with pad token
+    for dur columns.
+    """
+    pitch_range = max_pitch - min_pitch + 1  # including pad
+    pr_mat3d = np.ones((32, max_note_count, 6), dtype=int) * dur_pad_ind
+    pr_mat3d[:, :, 0] = pitch_pad_ind
+    pr_mat3d[:, 0, 0] = pitch_sos_ind
+    cur_idx = np.ones(32, dtype=int)
+    for t, p in zip(*np.where(pr_mat != 0)):
+        pr_mat3d[t, cur_idx[t], 0] = p - min_pitch
+        binary = np.binary_repr(int(pr_mat[t, p]) - 1, width=5)
+        pr_mat3d[t, cur_idx[t], 1: 6] = \
+            np.fromstring(' '.join(list(binary)), dtype=int, sep=' ')
+        cur_idx[t] += 1
+    pr_mat3d[np.arange(0, 32), cur_idx, 0] = pitch_eos_ind
+    return pr_mat3d
+
+
+def get_low_high_dur_count(pr_mat):
+    # pr_mat (32, 128)
+    # return the maximum duration
+    # return the pitch range
+    # return the number of notes at each column
+
+    pitch_range = np.where(pr_mat != 0)[1]
+    low_pitch = pitch_range.min()
+    high_pitch = pitch_range.max()
+    pitch_dur = pr_mat.max()
+    num_notes = np.count_nonzero(pr_mat, axis=-1)
+    return low_pitch, high_pitch, pitch_dur, num_notes

Beat-Transformer/code/visiualize_attention.py

@@ -0,0 +1,150 @@
+import os
+os.environ['CUDA_LAUNCH_BLOCKING'] = '1'
+import madmom
+import torch
+import numpy as np
+from tqdm import tqdm
+from torch.utils.data import DataLoader
+from DilatedTransformer import Demixed_DilatedTransformerModel
+from spectrogram_dataset import audioDataset
+import scipy
+#import seaborn as sns
+import matplotlib.pyplot as plt
+
+from utils import AverageMeter
+
+import warnings
+warnings.filterwarnings('ignore')
+
+
+#data
+SAMPLE_SIZE = None
+FPS = 44100/1024
+NUM_FOLDS = 8
+FOLD = 0
+#model
+DEVICE='cuda:0'
+NORM_FIRST=True
+ATTN_LEN=5
+INSTR=5
+NTOKEN=2
+DMODEL=256 
+NHEAD=8
+DHID=1024
+NLAYER=9
+#directories
+DATASET_PATH = './data/demix_spectrogram_data.npz'
+ANNOTATION_PATH = 'data/full_beat_annotation.npz'
+MODEL_PATH = "./checkpoints/fold_6_trf_param.pt"
+DATA_TO_LOAD = ['gtzan']   #'carnetic', 'harmonix'   # ballroom,  'gtzan', 'hainsworth', 'smc'
+TEST_ONLY = ['gtzan']
+DEMO_SAVE_ROOT = './save/visualization'
+if not os.path.exists(DEMO_SAVE_ROOT):
+    os.mkdir(DEMO_SAVE_ROOT)
+
+
+model = Demixed_DilatedTransformerModel(attn_len=ATTN_LEN,
+                                                    instr=INSTR,
+                                                    ntoken=NTOKEN, 
+                                                    dmodel=DMODEL, 
+                                                    nhead=NHEAD, 
+                                                    d_hid=DHID, 
+                                                    nlayers=NLAYER, 
+                                                    norm_first=NORM_FIRST
+                                                    )
+
+model.load_state_dict(torch.load(MODEL_PATH, map_location=torch.device('cpu'))['state_dict'])
+model.to(DEVICE)
+model.eval()
+
+
+dataset = audioDataset(data_to_load=DATA_TO_LOAD,
+                            test_only_data = TEST_ONLY,
+                            data_path = DATASET_PATH, 
+                            annotation_path = ANNOTATION_PATH,
+                            fps = FPS,
+                            sample_size = None,
+                            num_folds = NUM_FOLDS)
+
+train_set, val_set, test_set = dataset.get_fold(fold=0)
+loader = DataLoader(test_set, batch_size=1, shuffle=False)
+
+beat_tracker = madmom.features.beats.DBNBeatTrackingProcessor(min_bpm=55.0, max_bpm=215.0, fps=FPS, transition_lambda=10, threshold=0.05)
+downbeat_tracker = madmom.features.downbeats.DBNDownBeatTrackingProcessor(beats_per_bar=[3, 4], min_bpm=55.0, max_bpm=215.0, fps=FPS, transition_lambda=10)
+
+#thresh_beat_meter = AverageMeter()
+#pick_beat_meter = AverageMeter()
+beat_DBN_meter = AverageMeter()
+#thresh_downbeat_meter = AverageMeter()
+#pick_downbeat_meter = AverageMeter()
+downbeat_DBN_meter = AverageMeter()
+
+with torch.no_grad():
+    for idx, (dataset_key, data, beat, downbeat, tempo, root) in tqdm(enumerate(loader), total=len(loader)):
+        #if idx == 0:
+        #    continue
+        data = data.float().to(DEVICE)  #(1, 5, T', 128)
+
+        dataset = dataset_key[0]
+        print(root)
+
+        #inference
+        pred, pred_t, attn = model.inference(data)
+
+        beat_pred = torch.sigmoid(pred[0, :, 0]).detach().cpu().numpy()
+        #np.savetxt(os.path.join(save_dir, 'beat_activation.txt'), beat_pred[:, np.newaxis])
+        downbeat_pred = torch.sigmoid(pred[0, :, 1]).detach().cpu().numpy()
+        #np.savetxt(os.path.join(save_dir, 'downbeat_activation.txt'), downbeat_pred[:, np.newaxis])
+
+        #gt beat
+        beat_gt = torch.nonzero(beat[0]>.5)[:, 0].detach().numpy() / (FPS)
+        dnb_beat_pred = beat_tracker(beat_pred)
+
+        downbeat_gt = torch.nonzero(downbeat[0]>.5)[:, 0].detach().numpy() / (FPS)
+        combined_act = np.concatenate((np.maximum(beat_pred - downbeat_pred, np.zeros(beat_pred.shape))[:, np.newaxis], downbeat_pred[:, np.newaxis]), axis=-1)   #(T, 2)
+        dbn_downbeat_pred = downbeat_tracker(combined_act)
+        dbn_downbeat_pred = dbn_downbeat_pred[dbn_downbeat_pred[:, 1]==1][:, 0]
+
+        beat_score_DBN = madmom.evaluation.beats.BeatEvaluation(dnb_beat_pred, beat_gt)
+
+        downbeat_score_DBN = madmom.evaluation.beats.BeatEvaluation(dbn_downbeat_pred, downbeat_gt)
+
+
+        fig = plt.figure(figsize=(20, 60))
+        for i in range(1, 10):
+            layer_attn = attn[i].transpose(-2, -1).squeeze(0).cpu().detach().numpy()
+            #layer_attn = np.mean(layer_attn, axis=0)
+            layer_attn = layer_attn[2]
+            #print(layer_attn.shape)
+
+            fig.add_subplot(9, 4, 4*i-3)
+            plt.imshow(layer_attn[0, :, :], cmap='viridis')
+            plt.vlines(torch.nonzero(beat[0, :]>.5)[:, 0].detach().numpy(), 0, layer_attn.shape[-1], label='Beats', color='r', linestyle=':', linewidth=.01)
+            plt.hlines(torch.nonzero(beat[0, :]>.5)[:, 0].detach().numpy(), 0, layer_attn.shape[-1], label='Beats', color='g', linestyle=':', linewidth=.01)
+
+            fig.add_subplot(9, 4, 4*i-2)
+            plt.imshow(layer_attn[1, :, :], cmap='viridis')
+            plt.vlines(torch.nonzero(beat[0, :]>.5)[:, 0].detach().numpy(), 0, layer_attn.shape[-1], label='Beats', color='r', linestyle=':', linewidth=.01)
+            plt.hlines(torch.nonzero(beat[0, :]>.5)[:, 0].detach().numpy(), 0, layer_attn.shape[-1], label='Beats', color='g', linestyle=':', linewidth=.01)
+
+            fig.add_subplot(9, 4, 4*i-1)
+            plt.imshow(layer_attn[2, :, :], cmap='viridis')
+            plt.vlines(torch.nonzero(beat[0, :]>.5)[:, 0].detach().numpy(), 0, layer_attn.shape[-1], label='Beats', color='r', linestyle=':', linewidth=.01)
+            plt.hlines(torch.nonzero(beat[0, :]>.5)[:, 0].detach().numpy(), 0, layer_attn.shape[-1], label='Beats', color='g', linestyle=':', linewidth=.01)
+
+            fig.add_subplot(9, 4, 4*i)
+            plt.imshow(layer_attn[3, :, :], cmap='viridis')
+            plt.vlines(torch.nonzero(beat[0, :]>.5)[:, 0].detach().numpy(), 0, layer_attn.shape[-1], label='Beats', color='r', linestyle=':', linewidth=.01)
+            plt.hlines(torch.nonzero(beat[0, :]>.5)[:, 0].detach().numpy(), 0, layer_attn.shape[-1], label='Beats', color='g', linestyle=':', linewidth=.01)
+        
+        plt.show()
+        #fig = ax.get_figure()
+        print('saving...')
+        plt.savefig(f"{DEMO_SAVE_ROOT}/{root[0].split('/')[-1].replace('.wav', '')}_attention_paterns.pdf", format='pdf', dpi=1200)
+        #ax = sns.heatmap(attn[1])
+        #print(attn)
+
+
+        print('beat accuracy:', beat_score_DBN.fmeasure, beat_score_DBN.cmlt, beat_score_DBN.amlt)
+        print('dowbbeat accuracy:', downbeat_score_DBN.fmeasure, downbeat_score_DBN.cmlt, downbeat_score_DBN.amlt)
+        break

Beat-Transformer/data/SMC/SMC_MIREX_Readme.txt

@@ -0,0 +1,58 @@
+SMC_MIREX Readme
+
+Hi,
+
+In the archive there are 4 folders:
+
+SMC_MIREX_Annotations 
+SMC_MIREX_Annotations_05_08_2014 
+SMC_MIREX_Audio  
+SMC_MIREX_Tags 
+
+They contain the following:
+
+SMC_MIREX_Annotations
+---------------------
+
+Ground truth beat annotations in seconds
+The filenames are a bit confusing, their structure is not so important, but to explain:
+
+SMC_001_2_1_1_a.txt means 
+
+file: SMC_001
+
+other metrical interpretation: 2_1_1 (beats tapped in a 2:1 ratio, starting on beat 1 could also be acceptable) - NOTE this is not tested nor should it be used!
+
+a: gives the name of the annotator (again this information is not useful)
+
+SMC_MIREX_Annotations_05_08_2014
+--------------------------------
+
+The content of this directory is the same as above, except for the annotations for excerpts 056, 137, 153, 203 and 257 which have been updated to remove the final beat annotations which were out of range. Thanks to Andy Lambert for pointing this out. 
+
+
+SMC_MIREX_Audio
+---------------
+
+The audio files (mono .wav at 44.1khz)
+There are 217 in total, but they are numbered running up to 289.
+Note, files 271 - 289 are "easy" compared to the rest which are hard.
+
+SMC_MIREX_Tags
+--------------
+
+These are text files with tags that correspond to why the annotation was difficult, along with a code, e.g. f1 where 'f' is the name of the annotator and '1' is a confidence level (again this information is not very relevant for you).
+These tags are probably not so useful, but might be good for post-hoc analysis of results.
+
+Acknowledgment
+--------------
+If you use the dataset in your work, please cite the following paper:
+
+Holzapfel, A.; Davies, M.E.P.; Zapata, J.R.; Oliveira, J.L.; Gouyon, F.; , "Selective Sampling for Beat Tracking Evaluation," Audio, Speech, and Language Processing, IEEE Transactions on , vol.20, no.9, pp.2539-2548, Nov. 2012
+doi: 10.1109/TASL.2012.2205244
+URL: http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=6220849&isnumber=6268383
+
+
+Any questions, send me a mail: mdavies@inesctec.pt
+
+

Beat-Transformer/data/SMC/SMC_MIREX_Tags/SMC_048.tag

@@ -0,0 +1,3 @@
+quiet accompaniment
+slow tempo
+o1

Beat-Transformer/data/SMC/SMC_MIREX_Tags/SMC_133.tag

@@ -0,0 +1,8 @@
+quiet accompaniment
+slow tempo
+expressive timing
+(poor sound quality)
+lack of transient sounds
+excerpt is the introduction of the song
+(ternary meter)
+m2

Beat-Transformer/data/SMC/SMC_MIREX_Tags/SMC_158.tag

@@ -0,0 +1,5 @@
+slow tempo
+changing time signature
+expressive timing
+(missing bass)
+a3

Beat-Transformer/data/SMC/SMC_MIREX_Tags/SMC_208.tag

@@ -0,0 +1,5 @@
+expressive timing
+lack of transient sounds
+ternary meter
+(missing bass)
+a2

Beat-Transformer/data/SMC/SMC_MIREX_Tags/SMC_217.tag

@@ -0,0 +1,5 @@
+slow tempo
+expressive timing
+lack of transient sounds
+(missing bass)
+a1

Beat-Transformer/data/SMC/SMC_MIREX_Tags/SMC_261.tag

@@ -0,0 +1,5 @@
+gradual tempo change
+expressive timing
+(missing bass)
+(strong syncopation)
+a2

Beat-Transformer/data/SMC/SMC_MIREX_Tags/SMC_279.tag

@@ -0,0 +1,2 @@
+none
+m1

Beat-Transformer/data/demix_spectrogram_data.txt

@@ -0,0 +1,3 @@
+Download our processed data at https://drive.google.com/file/d/1LamSAEY5QsnY57cF6qH_0niesGGKkHtI/view?usp=sharing
+Each piece is demixed into 5 stems and saved as spectrogram of shape (time, stem=5, mel_bin=128). 
+This file includes full processed spectrogram data from Ballroom, Hainsworth, Carnetic, Harmonix, SMC, and GTZAN.

Beat-Transformer/sft.py

@@ -0,0 +1,170 @@
+import os
+import numpy as np
+from pydub import AudioSegment
+from scipy.ndimage import maximum_filter1d
+import json
+import hashlib
+import tqdm
+import os
+
+from scipy.interpolate import interp1d
+from scipy.signal import argrelmax
+
+
+
+def infer_tempo(beats, fps, hist_smooth=4, no_tempo=-1):
+    import madmom
+    ibis = np.diff(beats) * fps
+    bins = np.bincount(np.round(ibis).astype(int))
+    if not bins.any():
+        return no_tempo
+    if hist_smooth > 0:
+        bins = madmom.audio.signal.smooth(bins, hist_smooth)
+    intervals = np.arange(len(bins))       
+    interpolation_fn = interp1d(intervals, bins, 'quadratic')
+    intervals = np.arange(intervals[0], intervals[-1], 0.001)
+    tempi = 60.0 * fps / intervals
+    print(tempi)
+    bins = interpolation_fn(intervals)
+    peaks = argrelmax(bins, mode='wrap')[0]
+    if len(peaks) == 0:
+        return no_tempo
+    else:
+        sorted_peaks = peaks[np.argsort(bins[peaks])[::-1]]
+        return tempi[sorted_peaks][0]
+
+
+def quantise(beats):
+   return [int(round(b * 25)) / 25 for b in beats]
+
+
+def get_sample(excerpt_path, beats, existed_uuid_list, split="train", key="gtzan", type="beat"):
+    # print(f'processing {excerpt_path} ...')
+    # print(f'beats: {beats}')
+
+    data_sample = {
+        "instruction": "Identify and list the timestamps of all beats in this audio track. Use the format of `0.0s,0.54s,1.0ss, ...`",
+        "input": f"<|SOA|>{excerpt_path[len(PATH)+1:]}<|EOA|>",
+        "output": ",".join([f"{b}s" for b in beats]),
+        "uuid": "",
+        "audioid": excerpt_path[len(PATH)+1:], # exclude the '/' at the beginning, to enable os.join.path
+        "split": [split],
+        "task_type": {"major": ["global_MIR"], "minor": ["beat_tracking"]},
+        "domain": "music",
+        "source": key,
+        "other": {}
+    }
+    if type == "downbeat":
+        data_sample["instruction"] = "Identify and list the timestamps of all downbeats in this audio track. Use the format of `0.0s,1.54s,3.0s, ...`"
+        data_sample["task_type"]["minor"] = ["downbeat_tracking"]
+        
+    # change uuid
+    uuid_string = f"{data_sample['instruction']}#{data_sample['input']}#{data_sample['output']}"
+    unique_id = hashlib.md5(uuid_string.encode()).hexdigest()[:16] #只取前16位
+    if unique_id in existed_uuid_list:
+        sha1_hash = hashlib.sha1(uuid_string.encode()).hexdigest()[:16] # 为了相加的时候位数对应上 # 将 MD5 和 SHA1 结果相加,并计算新的 MD5 作为最终的 UUID
+        unique_id = hashlib.md5((unique_id + sha1_hash).encode()).hexdigest()[:16]
+    existed_uuid_list.add(unique_id)
+    data_sample["uuid"] = f"{unique_id}"
+    return data_sample
+
+
+EXCERPT_LENGTH = 30 * 1000  # 30 seconds in milliseconds
+MIN_LENGTH = 5 * 1000  # 5 seconds in milliseconds
+
+PATH = '/work/fast_data_yinghao/Beat-Transformer/data'
+load_annotation = np.load(f'{PATH}/full_beat_annotation.npz', allow_pickle=True)
+
+for key in ["ballroom"]:  #"rwc", "ballroom", "gtzan", "hainsworth", "carnetic", "smc"
+    # ballroom, GTZAN 30s, beat & downbeat
+    # hainsworth, (RWC,) carnetic: split audio, beat & downbeat
+    # smc: split audio, beat
+    annotation = load_annotation[key]
+
+    with open(f'{PATH}/audio_lists/{key}.txt', 'r') as f:
+        audio_root = f.readlines()
+    audio_root = [item.replace('\n', '') for item in audio_root]
+    audio_root = [f'{PATH}/{item[37:]}' for item in audio_root]
+    assert(len(annotation) == len(audio_root))
+
+    existed_uuid_list = set()
+    data_samples = []
+    for idx, ann in tqdm.tqdm(enumerate(annotation)):
+        # print(f'processing {audio_root[idx]} ...')
+        audio_path = audio_root[idx]
+        if len(ann.shape) == 1:
+            beats = quantise(ann)
+            downbeats = None
+        elif key != "rwc":
+            beats = quantise(ann[:,0])
+            downbeats = quantise(ann[ann[:, 1] == 1, 0])
+        else:
+            NotImplementedError
+            # beat = madmom.utils.quantize_events(annotation[:, 0], fps=self.fps, length=len(song))
+            # beat = np.maximum(beat, maximum_filter1d(beat, size=3) * 0.5)
+            # beat = np.maximum(beat, maximum_filter1d(beat, size=3) * 0.5)             
+            # downbeat = annotation[annotation[:, 1] == 1][:, 0]
+            # downbeat = madmom.utils.quantize_events(downbeat, fps=self.fps, length=len(song))
+            # downbeat = np.maximum(downbeat, maximum_filter1d(downbeat, size=3) * 0.5)
+            # downbeat = np.maximum(downbeat, maximum_filter1d(downbeat, size=3) * 0.5)
+                            
+        # print(f'tempo: {tempo}')
+
+        if key =="ballroom":
+            # tempo = infer_tempo(beats, fps=100)
+            sample = get_sample(audio_path, beats, existed_uuid_list, key=key)
+            data_samples.append(sample)
+            sample = get_sample(audio_path, downbeats, existed_uuid_list, key=key, type="downbeat")
+            data_samples.append(sample)          
+        elif key == "gtzan":
+            if "jazz.00054" in audio_path:
+                continue
+            sample = get_sample(audio_path, beats, existed_uuid_list, split="test", key=key)
+            data_samples.append(sample)
+            if downbeats:
+                sample = get_sample(audio_path, downbeats, existed_uuid_list, split="test", key=key, type="downbeat")
+                data_samples.append(sample)                    
+        else:
+            audio = AudioSegment.from_file(audio_path)
+            for i in range(0, len(audio), EXCERPT_LENGTH):
+                end = i + EXCERPT_LENGTH
+                if end < len(audio):
+                    excerpt = audio[i:end]
+                else:
+                    excerpt = audio[i:]
+                    # Discard short audio clips
+                    if len(excerpt) < MIN_LENGTH:
+                        break
+                    end = len(audio)
+                    
+                # # Save the excerpt to the same directory with a new name
+                excerpt_path = f"{audio_path[:-4]}_{i//EXCERPT_LENGTH}.wav"
+                if not os.path.exists(excerpt_path):
+                    excerpt.export(excerpt_path, format="wav")
+
+                excerpt_beats = [b%30 for b in beats if i * 30 <= b <= (i + 1) * 30]
+                if downbeats:
+                    excerpt_downbeats = [db%30 for db in downbeats if i * 30 <= db <= (i + 1) * 30]
+                else:
+                    excerpt_downbeats = None
+                
+                # tempo = infer_tempo(excerpt_beats, fps=100)
+                sample = get_sample(excerpt_path, excerpt_beats, existed_uuid_list, key=key)
+                data_samples.append(sample)
+                if downbeats:
+                    sample = get_sample(excerpt_path, excerpt_downbeats, existed_uuid_list, key=key, type="downbeat")    
+                    data_samples.append(sample)      
+            # Remove the original audio file
+            # os.remove(audio_path)          
+        
+        # break
+        
+
+    split = "test" if key == "gtzan" else "train"
+    output_file_path = f'{PATH}/../{key}_{split}.jsonl'  # Replace with the desired output path
+    with open(output_file_path, 'w') as outfile:
+        # for sample in data_samples:
+        json.dump(data_samples, outfile)
+
+        # outfile.write('\n')
+    outfile.close()

MSD/1/0/1004941.clip.wav

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

MSD/1/0/1026549.clip.wav

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

MSD/1/0/1036772.clip.wav

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