Add files using upload-large-folder tool

extras/check_drum_channel_slakh.py

@@ -0,0 +1,24 @@
+from utils.mirdata_dev.datasets import slakh16k
+
+
+def check_drum_channel_slakh(data_home: str):
+    ds = slakh16k.Dataset(data_home, version='default')
+    for track_id in ds.track_ids:
+        is_drum = ds.track(track_id).is_drum
+        midi = MidiFile(ds.track(track_id).midi_path)
+        cnt = 0
+        for msg in midi:
+            if 'note' in msg.type:
+                if is_drum and (msg.channel != 9):
+                    print('found drum track with channel != 9 in track_id: ',
+                          track_id)
+                if not is_drum and (msg.channel == 9):
+                    print(
+                        'found non-drum track with channel == 9 in track_id: ',
+                        track_id)
+                if is_drum and (msg.channel == 9):
+                    cnt += 1
+        if cnt > 0:
+            print(f'found {cnt} notes in drum track with ch 9 in track_id: ',
+                  track_id)
+    return

extras/dataset_mutable_var_sanity_check.py

@@ -0,0 +1,81 @@
+for n in range(1000):
+    sampled_data = ds.__getitem__(n)
+
+    a = deepcopy(sampled_data['note_event_segments'])
+    b = deepcopy(sampled_data['note_event_segments'])
+
+    for (note_events, tie_note_events, start_time) in list(zip(*b.values())):
+        note_events = pitch_shift_note_events(note_events, 2)
+        tie_note_events = pitch_shift_note_events(tie_note_events, 2)
+
+    # compare
+    for i, (note_events, tie_note_events, start_time) in enumerate(list(zip(*b.values()))):
+        for j, ne in enumerate(note_events):
+            if ne.is_drum is False:
+                if ne.pitch != a['note_events'][i][j].pitch + 2:
+                    print(i, j)
+                assert ne.pitch == a['note_events'][i][j].pitch + 2
+
+        for k, tne in enumerate(tie_note_events):
+            assert tne.pitch == a['tie_note_events'][i][k].pitch + 2
+
+    print('test {} passed'.format(n))
+
+
+def assert_note_events_almost_equal(actual_note_events,
+                                    predicted_note_events,
+                                    ignore_time=False,
+                                    ignore_activity=True,
+                                    delta=5.1e-3):
+    """
+    Asserts that the given lists of Note instances are equal up to a small
+    floating-point tolerance, similar to `assertAlmostEqual` of `unittest`.
+    Tolerance is 5e-3 by default, which is 5 ms for 100 ticks-per-second.
+
+    If `ignore_time` is True, then the time field is ignored. (useful for 
+    comparing tie note events, default is False)
+
+    If `ignore_activity` is True, then the activity field is ignored (default
+    is True).
+    """
+    assert len(actual_note_events) == len(predicted_note_events)
+    for j, (actual_note_event,
+            predicted_note_event) in enumerate(zip(actual_note_events, predicted_note_events)):
+        if ignore_time is False:
+            assert abs(actual_note_event.time - predicted_note_event.time) <= delta
+        assert actual_note_event.is_drum == predicted_note_event.is_drum
+        if actual_note_event.is_drum is False and predicted_note_event.is_drum is False:
+            assert actual_note_event.program == predicted_note_event.program
+        assert actual_note_event.pitch == predicted_note_event.pitch
+        assert actual_note_event.velocity == predicted_note_event.velocity
+        if ignore_activity is False:
+            assert actual_note_event.activity == predicted_note_event.activity
+
+
+cache_old = deepcopy(dict(ds.cache))
+for n in range(500):
+    sampled_data = ds.__getitem__(n)
+    cache_new = ds.cache
+    cnt = 0
+    for k, v in cache_new.items():
+        if k in cache_old:
+            cnt += 1
+            assert (cache_new[k]['programs'] == cache_old[k]['programs']).all()
+            assert (cache_new[k]['is_drum'] == cache_old[k]['is_drum']).all()
+            assert (cache_new[k]['has_stems'] == cache_old[k]['has_stems'])
+            assert (cache_new[k]['has_unannotated'] == cache_old[k]['has_unannotated'])
+            assert (cache_new[k]['audio_array'] == cache_old[k]['audio_array']).all()
+
+            for nes_new, nes_old in zip(cache_new[k]['note_event_segments']['note_events'],
+                                        cache_old[k]['note_event_segments']['note_events']):
+                assert_note_events_almost_equal(nes_new, nes_old)
+
+            for tnes_new, tnes_old in zip(cache_new[k]['note_event_segments']['tie_note_events'],
+                                          cache_old[k]['note_event_segments']['tie_note_events']):
+                assert_note_events_almost_equal(tnes_new, tnes_old, ignore_time=True)
+
+            for s_new, s_old in zip(cache_new[k]['note_event_segments']['start_times'],
+                                    cache_old[k]['note_event_segments']['start_times']):
+                assert s_new == s_old
+    cache_old = deepcopy(dict(ds.cache))
+    print(n, cnt)

extras/demo_intra_augmentation.py

@@ -0,0 +1,52 @@
+# Copyright 2024 The YourMT3 Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Please see the details in the LICENSE file.
+import numpy as np
+import torch
+import json
+import soundfile as sf
+from utils.datasets_train import get_cache_data_loader
+
+
+def get_filelist(track_id: int) -> dict:
+    filelist = '../../data/yourmt3_indexes/slakh_train_file_list.json'
+    with open(filelist, 'r') as f:
+        fl = json.load(f)
+    new_filelist = dict()
+    for key, value in fl.items():
+        if int(key) == track_id:
+            new_filelist[0] = value
+    return new_filelist
+
+
+def get_ds(track_id: int, random_amp_range: list = [1., 1.], stem_aug_prob: float = 0.8):
+    filelist = get_filelist(track_id)
+    dl = get_cache_data_loader(filelist,
+                               'train',
+                               1,
+                               1,
+                               random_amp_range=random_amp_range,
+                               stem_aug_prob=stem_aug_prob,
+                               shuffle=False)
+    ds = dl.dataset
+    return ds
+
+
+def gen_audio(track_id: int, n_segments: int = 30, random_amp_range: list = [1., 1.], stem_aug_prob: float = 0.8):
+    ds = get_ds(track_id, random_amp_range, stem_aug_prob)
+    audio = []
+    for i in range(n_segments):
+        audio.append(ds.__getitem__(0)[0])
+        # audio.append(ds.__getitem__(i)[0])
+
+    audio = torch.concat(audio, dim=2).numpy()[0, 0, :]
+    sf.write('audio.wav', audio, 16000, subtype='PCM_16')
+
+
+gen_audio(1, 20)

extras/examples/singing_note_events.npy

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

extras/examples/singing_notes.npy

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

extras/label_smoothing.py

@@ -0,0 +1,67 @@
+import torch
+import numpy as np
+import matplotlib.pyplot as plt
+
+a = torch.signal.windows.gaussian(11, sym=True, std=3)
+plt.plot(a)
+
+
+def gaussian_smoothing(y_hot, mu=5, sigma=0.865):
+    """
+    y_hot: one-hot encoded array
+    """
+    #sigma = np.sqrt(np.abs(np.log(0.05) / ((4 - mu)**2))) / 2
+
+    # Generate index array
+    i = np.arange(len(y_hot))
+
+    # Gaussian function
+    y_smooth = np.exp(-(i - mu)**2 / (2 * sigma**2))
+
+    # Normalize the resulting array
+    y_smooth /= y_smooth.sum()
+    return y_smooth, sigma
+
+
+# y_ls = (1 - α) * y_hot + α / K, where K is the number of classes, alpha is the smoothing parameter
+
+y_hot = torch.zeros(11)
+y_hot[5] = 1
+plt.plot(y_hot, 'b.-')
+
+alpha = 0.3
+y_ls = (1 - alpha) * y_hot + alpha / 10
+plt.plot(y_ls, 'r.-')
+
+y_gs, std = gaussian_smoothing(y_hot, A=0.5)
+plt.plot(y_gs, 'g.-')
+
+y_gst_a, std = gaussian_smoothing(y_hot, A=0.5, mu=5.5)
+plt.plot(y_gst_a, 'y.-')
+
+y_gst_b, std = gaussian_smoothing(y_hot, A=0.5, mu=5.8)
+plt.plot(y_gst_b, 'c.-')
+
+plt.legend([
+    'y_hot', 'label smoothing' + '\n' + '(alpha=0.3)',
+    'gaussian smoothing' + '\n' + 'for interval of interest' + '\n' + 'mu=5',
+    'gaussian smoothing' + '\n' + 'mu=5.5', 'gaussian smoothing' + '\n' + 'mu=5.8'
+])
+
+plt.grid()
+plt.xticks(np.arange(11), np.arange(0, 110, 10))
+plt.xlabel('''Time (ms)
+original (quantized) one hot label:
+[0,0,0,0,0,1,0,0,0,0,0]
+\n
+label smooting is defined as:
+ y_ls = (1 - α) * y_hot + α / K,
+where K is the number of classes, α is the smoothing parameter
+\n
+gaussian smoothing for the interval (± 10ms) of interest:
+y_gs = A * exp(-(i - mu)**2 / (2 * sigma**2))
+with sigma = 0.865 an mu = 5
+\n 
+gaussian smoothing with unqunatized target timing:
+mu = 5.5 for 55ms target timing
+''')

extras/npy_speed_benchmark.py

@@ -0,0 +1,187 @@
+import os
+from tasks.utils.event_codec import Event, EventRange
+from tasks.utils import event_codec
+
+ec = event_codec.Codec(
+            max_shift_steps=1000,  # this means 0,1,...,1000
+            steps_per_second=100,
+            event_ranges=[
+                EventRange('pitch', min_value=0, max_value=127),
+                EventRange('velocity', min_value=0, max_value=1),
+                EventRange('tie', min_value=0, max_value=0),
+                EventRange('program', min_value=0, max_value=127),
+                EventRange('drum', min_value=0, max_value=127),
+            ],
+        )
+
+events = [
+    Event(type='shift', value=0),  # actually not needed
+    Event(type='shift', value=1),  # 10 ms shift
+    Event(type='shift', value=1000),  # 10 s shift
+    Event(type='pitch', value=0),  # lowest pitch 8.18 Hz
+    Event(type='pitch', value=60),  # C4 or 261.63 Hz
+    Event(type='pitch', value=127),  # highest pitch G9 or 12543.85 Hz
+    Event(type='velocity', value=0),  # lowest velocity)
+    Event(type='velocity', value=1),  # lowest velocity)
+    Event(type='tie', value=0),  # tie
+    Event(type='program', value=0),  # program
+    Event(type='program', value=127),  # program
+    Event(type='drum', value=0),  # drum
+    Event(type='drum', value=127),  # drum
+]
+
+events = events * 100
+tokens = [ec.encode_event(e) for e in events]
+tokens = np.array(tokens, dtype=np.int16)
+
+import csv
+# Save events to a CSV file
+with open('events.csv', 'w', newline='') as file:
+    writer = csv.writer(file)
+    for event in events:
+        writer.writerow([event.type, event.value])
+
+# Load events from a CSV file
+with open('events.csv', 'r') as file:
+    reader = csv.reader(file)
+    events2 = [Event(row[0], int(row[1])) for row in reader]
+
+
+import json
+# Save events to a JSON file
+with open('events.json', 'w') as file:
+    json.dump([event.__dict__ for event in events], file)
+
+# Load events from a JSON file
+with open('events.json', 'r') as file:
+    events = [Event(**event_dict) for event_dict in json.load(file)]
+
+
+
+
+"""----------------------------"""
+# Write the tokens to a npy file
+import numpy as np
+np.save('tokens.npy', tokens)
+
+def t_npy():
+    t = np.load('tokens.npy', allow_pickle=True) # allow pickle doesn't affect speed
+
+os.makedirs('temp', exist_ok=True)
+for i in range(2400):
+    np.save(f'temp/tokens{i}.npy', tokens)
+
+def t_npy2400():
+    for i in range(2400):
+        t = np.load(f'temp/tokens{i}.npy')
+def t_npy2400_take200():
+    for i in range(200):
+        t = np.load(f'temp/tokens{i}.npy')
+
+import shutil
+shutil.rmtree('temp', ignore_errors=True)
+
+# Write the 2400 tokens to a single npy file
+data = dict()
+for i in range(2400):
+    data[f'arr{i}'] = tokens.copy()
+np.save(f'tokens_2400x.npy', data)
+def t_npy2400single():
+    t = np.load('tokens_2400x.npy', allow_pickle=True).item()
+
+def t_mmap2400single():
+    t = np.load('tokens_2400x.npy', mmap_mode='r')
+
+# Write the tokens to a npz file
+np.savez('tokens.npz', arr0=tokens)
+def t_npz():
+    npz_file = np.load('tokens.npz')
+    tt = npz_file['arr0']
+
+data = dict()
+for i in range(2400):
+    data[f'arr{i}'] = tokens
+np.savez('tokens.npz', **data )
+def t_npz2400():
+    npz_file = np.load('tokens.npz')
+    for i in range(2400):
+        tt = npz_file[f'arr{i}']
+
+def t_npz2400_take200():
+    npz_file = np.load('tokens.npz')
+    # npz_file.files
+    for i in range(200):
+        tt = npz_file[f'arr{i}']
+
+
+# Write the tokens to a txt file
+with open('tokens.txt', 'w') as file:
+    file.write(' '.join(map(str, tokens)))
+
+def t_txt():
+    # Read the tokens from the file
+    with open('tokens.txt', 'r') as file:
+        t = list(map(int, file.read().split()))
+    t = np.array(t)
+
+
+# Write the tokens to a CSV file
+with open('tokens.csv', 'w', newline='') as file:
+    writer = csv.writer(file)
+    writer.writerow(tokens)
+
+def t_csv():
+    # Read the tokens from the CSV file
+    with open('tokens.csv', 'r') as file:
+        reader = csv.reader(file)
+        t = list(map(int, next(reader)))
+        t = np.array(t)
+
+
+# Write the tokens to a JSON file
+with open('tokens.json', 'w') as file:
+    json.dump(tokens, file)
+
+def t_json():
+    # Read the tokens from the JSON file
+    with open('tokens.json', 'r') as file:
+        t = json.load(file)
+        t = np.array(t)
+
+with open('tokens_2400x.json', 'w') as file:
+    json.dump(data, file)
+
+def t_json2400single():
+    # Read the tokens from the JSON file
+    with open('tokens_2400x.json', 'r') as file:
+        t = json.load(file)      
+
+def t_mmap():
+    t = np.load('tokens.npy', mmap_mode='r')
+
+# Write the tokens to bytes file
+
+
+
+
+np.savetxt('tokens.ntxt', tokens)
+def t_ntxt():
+    t = np.loadtxt('tokens.ntxt').astype(np.int32)
+
+%timeit t_npz() # 139 us
+%timeit t_mmap() # 3.12 ms 
+%timeit t_npy() # 87.8 us
+%timeit t_txt() # 109 152 us
+%timeit t_csv() # 145 190 us
+%timeit t_json() # 72.8 119 us
+%timeit t_ntxt() # 878 us
+
+%timeit t_npy2400() # 212 ms; 2400 files in a folder
+%timeit t_npz2400() # 296 ms; uncompreesed 1000 arrays in a single file
+
+%timeit t_npy2400_take200() # 17.4 ms; 25 Mb
+%timeit t_npz2400_take200() # 28.8 ms; 3.72 ms for 10 arrays; 25 Mb
+%timeit t_npy2400single() # 4 ms; frozen dictionary containing 2400 arrays; 6.4 Mb; int16
+%timeit t_mmap2400single() # dictionary is not supported 
+%timeit t_json2400single() # 175 ms; 17 Mb
+# 2400 files from 100ms hop for 4 minutes   

extras/perceivertf_inspect.py

@@ -0,0 +1,640 @@
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+
+def l2_normalize(matrix):
+    """
+    L2 Normalize the matrix along its rows.
+
+    Parameters:
+        matrix (numpy.ndarray): The input matrix.
+
+    Returns:
+        numpy.ndarray: The L2 normalized matrix.
+    """
+    l2_norms = np.linalg.norm(matrix, axis=1, keepdims=True)
+    normalized_matrix = matrix / l2_norms
+    return normalized_matrix
+
+
+def z_normalize(matrix):
+    """
+    Z-normalize the matrix along its rows (mean=0 and std=1).
+    Z-normalization is also known as "standardization", and derives from z-score.
+    Z = (X - mean) / std
+    Z-nomarlized, each row has mean=0 and std=1. 
+
+    Parameters:
+        matrix (numpy.ndarray): The input matrix.
+
+    Returns:
+        numpy.ndarray: The Z normalized matrix.
+    """
+    mean = np.mean(matrix, axis=1, keepdims=True)
+    std = np.std(matrix, axis=1, keepdims=True)
+    normalized_matrix = (matrix - mean) / std
+    return normalized_matrix
+
+
+def l2_normalize_tensors(tensor_tuple):
+    """
+    Applies L2 normalization on the last two dimensions for each tensor in a tuple.
+
+    Parameters:
+        tensor_tuple (tuple of torch.Tensor): A tuple containing N tensors, each of shape (1, k, 30, 30).
+
+    Returns:
+        tuple of torch.Tensor: A tuple containing N L2-normalized tensors.
+    """
+    normalized_tensors = []
+    for tensor in tensor_tuple:
+        # Ensure the tensor is a floating-point type
+        tensor = tensor.float()
+
+        # Calculate L2 norm on the last two dimensions, keeping the dimensions using keepdim=True
+        l2_norm = torch.linalg.norm(tensor, dim=(-2, -1), keepdim=True)
+
+        # Apply L2 normalization
+        normalized_tensor = tensor / (
+            l2_norm + 1e-7)  # Small value to avoid division by zero
+
+        normalized_tensors.append(normalized_tensor)
+
+    return tuple(normalized_tensors)
+
+
+def z_normalize_tensors(tensor_tuple):
+    """
+    Applies Z-normalization on the last two dimensions for each tensor in a tuple.
+
+    Parameters:
+        tensor_tuple (tuple of torch.Tensor): A tuple containing N tensors, each of shape (1, k, 30, 30).
+
+    Returns:
+        tuple of torch.Tensor: A tuple containing N Z-normalized tensors.
+    """
+    normalized_tensors = []
+    for tensor in tensor_tuple:
+        # Ensure the tensor is a floating-point type
+        tensor = tensor.float()
+
+        # Calculate mean and std on the last two dimensions
+        mean = tensor.mean(dim=(-2, -1), keepdim=True)
+        std = tensor.std(dim=(-2, -1), keepdim=True)
+
+        # Apply Z-normalization
+        normalized_tensor = (tensor - mean) / (
+            std + 1e-7)  # Small value to avoid division by zero
+
+        normalized_tensors.append(normalized_tensor)
+
+    return tuple(normalized_tensors)
+
+
+def apply_temperature_to_attention_tensors(tensor_tuple, temperature=1.0):
+    """
+    Applies temperature scaling to the attention weights in each tensor in a tuple.
+    
+    Parameters:
+        tensor_tuple (tuple of torch.Tensor): A tuple containing N tensors, 
+                                             each of shape (1, k, 30, 30).
+        temperature (float): Temperature parameter to control the sharpness 
+                             of the attention weights. Default is 1.0.
+                             
+    Returns:
+        tuple of torch.Tensor: A tuple containing N tensors with scaled attention weights.
+    """
+    scaled_attention_tensors = []
+
+    for tensor in tensor_tuple:
+        # Ensure the tensor is a floating-point type
+        tensor = tensor.float()
+
+        # Flatten the last two dimensions
+        flattened_tensor = tensor.reshape(1, tensor.shape[1],
+                                          -1)  # Modified line here
+
+        # Apply temperature scaling and softmax along the last dimension
+        scaled_attention = flattened_tensor / temperature
+        scaled_attention = F.softmax(scaled_attention, dim=-1)
+
+        # Reshape to original shape
+        scaled_attention = scaled_attention.view_as(tensor)
+
+        scaled_attention_tensors.append(scaled_attention)
+
+    return tuple(scaled_attention_tensors)
+
+
+def shorten_att(tensor_tuple, length=30):
+    shortend_tensors = []
+    for tensor in tensor_tuple:
+        shortend_tensors.append(tensor[:, :, :length, :length])
+    return tuple(shortend_tensors)
+
+
+def keep_top_k(matrix, k=6):
+    """
+    Keep only the top k values in each row, set the rest to 0.
+
+    Parameters:
+        matrix (numpy.ndarray): The input matrix.
+        k (int): The number of top values to keep in each row.
+
+    Returns:
+        numpy.ndarray: The transformed matrix.
+    """
+    topk_indices_per_row = np.argpartition(matrix, -k, axis=1)[:, -k:]
+    result_matrix = np.zeros_like(matrix)
+
+    for i in range(matrix.shape[0]):
+        result_matrix[i, topk_indices_per_row[i]] = matrix[
+            i, topk_indices_per_row[i]]
+    return result_matrix
+
+
+def test_case_forward_enc_perceiver_tf_dec_t5():
+    import torch
+    from model.ymt3 import YourMT3
+    from config.config import audio_cfg, model_cfg, shared_cfg
+    model_cfg["encoder_type"] = "perceiver-tf"
+    model_cfg["encoder"]["perceiver-tf"]["attention_to_channel"] = True
+    model_cfg["encoder"]["perceiver-tf"]["num_latents"] = 24
+    model_cfg["decoder_type"] = "t5"
+    model_cfg["pre_decoder_type"] = "default"
+
+    audio_cfg["codec"] = "spec"
+    audio_cfg["hop_length"] = 300
+    model = YourMT3(audio_cfg=audio_cfg, model_cfg=model_cfg)
+    model.eval()
+
+    # x = torch.randn(2, 1, 32767)
+    # labels = torch.randint(0, 400, (2, 1024), requires_grad=False)
+
+    # # forward
+    # output = model.forward(x, labels)
+
+    # # inference
+    # result = model.inference(x, None)
+
+    # display latents
+    checkpoint = torch.load(
+        "../logs/ymt3/ptf_all_cross_rebal5_spec300_xk2_amp0811_edr_005_attend_c_full_plus_b52/checkpoints/model.ckpt",
+        map_location="cpu")
+    state_dict = checkpoint['state_dict']
+    new_state_dict = {
+        k: v
+        for k, v in state_dict.items() if 'pitchshift' not in k
+    }
+    model.load_state_dict(new_state_dict, strict=False)
+
+    latents = model.encoder.latent_array.latents.detach().numpy()
+    import matplotlib.pyplot as plt
+    import numpy as np
+    from sklearn.metrics.pairwise import cosine_similarity
+    cos = cosine_similarity(latents)
+
+    from utils.data_modules import AMTDataModule
+    from einops import rearrange
+    dm = AMTDataModule(data_preset_multi={"presets": ["slakh"]})
+    dm.setup("test")
+    dl = dm.test_dataloader()
+    ds = list(dl.values())[0].dataset
+    audio, notes, tokens, _ = ds.__getitem__(7)
+    x = audio[[16], ::]
+    label = tokens[[16], :]
+    # spectrogram
+    x_spec = model.spectrogram(x)
+    plt.imshow(x_spec[0].detach().numpy().T, aspect='auto', origin='lower')
+    plt.title("spectrogram")
+    plt.xlabel('time step')
+    plt.ylabel('frequency bin')
+    plt.show()
+    x_conv = model.pre_encoder(x_spec)
+    # Create a larger figure
+    plt.figure(
+        figsize=(15,
+                 10))  # Adjust these numbers as needed for width and height
+    plt.subplot(2, 4, 1)
+    plt.imshow(x_spec[0].detach().numpy().T, aspect='auto', origin='lower')
+    plt.title("spectrogram")
+    plt.xlabel('time step')
+    plt.ylabel('frequency bin')
+    plt.subplot(2, 4, 2)
+    plt.imshow(x_conv[0][:, :, 0].detach().numpy().T,
+               aspect='auto',
+               origin='lower')
+    plt.title("conv(spec), ch=0")
+    plt.xlabel('time step')
+    plt.ylabel('F')
+    plt.subplot(2, 4, 3)
+    plt.imshow(x_conv[0][:, :, 42].detach().numpy().T,
+               aspect='auto',
+               origin='lower')
+    plt.title("ch=42")
+    plt.xlabel('time step')
+    plt.ylabel('F')
+    plt.subplot(2, 4, 4)
+    plt.imshow(x_conv[0][:, :, 80].detach().numpy().T,
+               aspect='auto',
+               origin='lower')
+    plt.title("ch=80")
+    plt.xlabel('time step')
+    plt.ylabel('F')
+    plt.subplot(2, 4, 5)
+    plt.imshow(x_conv[0][:, :, 11].detach().numpy().T,
+               aspect='auto',
+               origin='lower')
+    plt.title("ch=11")
+    plt.xlabel('time step')
+    plt.ylabel('F')
+    plt.subplot(2, 4, 6)
+    plt.imshow(x_conv[0][:, :, 20].detach().numpy().T,
+               aspect='auto',
+               origin='lower')
+    plt.title("ch=20")
+    plt.xlabel('time step')
+    plt.ylabel('F')
+    plt.subplot(2, 4, 7)
+    plt.imshow(x_conv[0][:, :, 77].detach().numpy().T,
+               aspect='auto',
+               origin='lower')
+    plt.title("ch=77")
+    plt.xlabel('time step')
+    plt.ylabel('F')
+    plt.subplot(2, 4, 8)
+    plt.imshow(x_conv[0][:, :, 90].detach().numpy().T,
+               aspect='auto',
+               origin='lower')
+    plt.title("ch=90")
+    plt.xlabel('time step')
+    plt.ylabel('F')
+    plt.tight_layout()
+    plt.show()
+
+    # encoding
+    output = model.encoder(inputs_embeds=x_conv,
+                           output_hidden_states=True,
+                           output_attentions=True)
+    enc_hs_all, att, catt = output["hidden_states"], output[
+        "attentions"], output["cross_attentions"]
+    enc_hs_last = enc_hs_all[2]
+
+    # enc_hs: time-varying encoder hidden state
+    plt.subplot(2, 3, 1)
+    plt.imshow(enc_hs_all[0][0][:, :, 21].detach().numpy().T)
+    plt.title('ENC_HS B0, d21')
+    plt.colorbar(orientation='horizontal')
+    plt.ylabel('latent k')
+    plt.xlabel('t')
+    plt.subplot(2, 3, 4)
+    plt.imshow(enc_hs_all[0][0][:, :, 127].detach().numpy().T)
+    plt.colorbar(orientation='horizontal')
+    plt.title('B0, d127')
+    plt.ylabel('latent k')
+    plt.xlabel('t')
+    plt.subplot(2, 3, 2)
+    plt.imshow(enc_hs_all[1][0][:, :, 21].detach().numpy().T)
+    plt.colorbar(orientation='horizontal')
+    plt.title('B1, d21')
+    plt.ylabel('latent k')
+    plt.xlabel('t')
+    plt.subplot(2, 3, 5)
+    plt.imshow(enc_hs_all[1][0][:, :, 127].detach().numpy().T)
+    plt.colorbar(orientation='horizontal')
+    plt.title('B1, d127')
+    plt.ylabel('latent k')
+    plt.xlabel('t')
+    plt.subplot(2, 3, 3)
+    plt.imshow(enc_hs_all[2][0][:, :, 21].detach().numpy().T)
+    plt.colorbar(orientation='horizontal')
+    plt.title('B2, d21')
+    plt.ylabel('latent k')
+    plt.xlabel('t')
+    plt.subplot(2, 3, 6)
+    plt.imshow(enc_hs_all[2][0][:, :, 127].detach().numpy().T)
+    plt.colorbar(orientation='horizontal')
+    plt.title('B2, d127')
+    plt.ylabel('latent k')
+    plt.xlabel('t')
+    plt.tight_layout()
+    plt.show()
+
+    enc_hs_proj = model.pre_decoder(enc_hs_last)
+    plt.imshow(enc_hs_proj[0].detach().numpy())
+    plt.title(
+        'ENC_HS_PROJ: linear projection of encoder output, which is used for enc-dec cross attention'
+    )
+    plt.colorbar(orientation='horizontal')
+    plt.ylabel('latent k')
+    plt.xlabel('d')
+    plt.show()
+
+    plt.subplot(221)
+    plt.imshow(enc_hs_all[2][0][0, :, :].detach().numpy(), aspect='auto')
+    plt.title('enc_hs, t=0')
+    plt.ylabel('latent k')
+    plt.xlabel('d')
+    plt.subplot(222)
+    plt.imshow(enc_hs_all[2][0][10, :, :].detach().numpy(), aspect='auto')
+    plt.title('enc_hs, t=10')
+    plt.ylabel('latent k')
+    plt.xlabel('d')
+    plt.subplot(223)
+    plt.imshow(enc_hs_all[2][0][20, :, :].detach().numpy(), aspect='auto')
+    plt.title('enc_hs, t=20')
+    plt.ylabel('latent k')
+    plt.xlabel('d')
+    plt.subplot(224)
+    plt.imshow(enc_hs_all[2][0][30, :, :].detach().numpy(), aspect='auto')
+    plt.title('enc_hs, t=30')
+    plt.ylabel('latent k')
+    plt.xlabel('d')
+    plt.tight_layout()
+    plt.show()
+
+    # enc_hs correlation: which dim has most unique info?
+    plt.subplot(1, 3, 1)
+    a = rearrange(enc_hs_last, '1 t k d -> t (k d)').detach().numpy()
+    plt.imshow(cosine_similarity(a))
+    plt.title("enc hs, t x t cos_sim")
+    plt.subplot(1, 3, 2)
+    b = rearrange(enc_hs_last, '1 t k d -> k (t d)').detach().numpy()
+    plt.imshow(cosine_similarity(b))
+    plt.title("enc hs, k x k cos_sim")
+    plt.subplot(1, 3, 3)
+    c = rearrange(enc_hs_last, '1 t k d -> d (k t)').detach().numpy()
+    plt.imshow(cosine_similarity(c))
+    plt.title("cross att, d x d cos_sim")
+    plt.tight_layout()
+    plt.show()
+
+    # enc latent
+    plt.imshow(model.encoder.latent_array.latents.detach().numpy())
+    plt.title('latent array')
+    plt.xlabel('d')
+    plt.ylabel('latent k')
+    plt.show()
+
+    # enc Spectral Cross Attention: (T x head x K x D). How latent K attends to conv channel C?
+    plt.subplot(311)
+    plt.imshow(
+        torch.sum(torch.sum(catt[0][0], axis=0), axis=0).detach().numpy())
+    plt.title('block=0')
+    plt.ylabel('latent k')
+    plt.xlabel('conv channel')
+    plt.subplot(312)
+    plt.imshow(
+        torch.sum(torch.sum(catt[1][0], axis=0), axis=0).detach().numpy())
+    plt.title('block=1')
+    plt.ylabel('latent k')
+    plt.xlabel('conv channel')
+    plt.subplot(313)
+    plt.imshow(
+        torch.sum(torch.sum(catt[2][0], axis=0), axis=0).detach().numpy())
+    plt.title('block=2')
+    plt.ylabel('latent k')
+    plt.xlabel('conv channel')
+    plt.tight_layout()
+    plt.show()
+    # enc Latent Self-attention: How latent K attends to K?
+    plt.subplot(231)
+    plt.imshow(torch.sum(torch.sum(att[0][0], axis=1),
+                         axis=0).detach().numpy(),
+               origin='upper')
+    plt.title('B0L0')
+    plt.xlabel('latent k')
+    plt.ylabel('latent k')
+    plt.subplot(234)
+    plt.imshow(torch.sum(torch.sum(att[0][1], axis=1),
+                         axis=0).detach().numpy(),
+               origin='upper')
+    plt.title('B0L1')
+    plt.xlabel('latent k')
+    plt.ylabel('latent k')
+    plt.subplot(232)
+    plt.imshow(torch.sum(torch.sum(att[1][0], axis=1),
+                         axis=0).detach().numpy(),
+               origin='upper')
+    plt.title('B1L0')
+    plt.xlabel('latent k')
+    plt.ylabel('latent k')
+    plt.subplot(235)
+    plt.imshow(torch.sum(torch.sum(att[1][1], axis=1),
+                         axis=0).detach().numpy(),
+               origin='upper')
+    plt.title('B1L1')
+    plt.xlabel('latent k')
+    plt.ylabel('latent k')
+    plt.subplot(233)
+    plt.imshow(torch.sum(torch.sum(att[2][0], axis=1),
+                         axis=0).detach().numpy(),
+               origin='upper')
+    plt.title('B2L0')
+    plt.xlabel('latent k')
+    plt.ylabel('latent k')
+    plt.subplot(236)
+    plt.imshow(torch.sum(torch.sum(att[2][1], axis=1),
+                         axis=0).detach().numpy(),
+               origin='upper')
+    plt.title('B2L1')
+    plt.xlabel('latent k')
+    plt.ylabel('latent k')
+    plt.tight_layout()
+    plt.show()
+    # Time varying, different head for latent self-attention
+    plt.subplot(231)
+    plt.imshow(att[0][0][30, 3, :, :].detach().numpy())
+    plt.title('B0L0, t=30, Head=3')
+    plt.colorbar(orientation='horizontal')
+    plt.xlabel('k')
+    plt.ylabel('k')
+    plt.subplot(234)
+    plt.imshow(att[0][1][30, 3, :, :].detach().numpy())
+    plt.title('B0L1, t=30, Head=3')
+    plt.colorbar(orientation='horizontal')
+    plt.xlabel('k')
+    plt.ylabel('k')
+    plt.subplot(232)
+    plt.imshow(att[1][0][30, 3, :, :].detach().numpy())
+    plt.title('B1L0, t=30, Head=3')
+    plt.colorbar(orientation='horizontal')
+    plt.xlabel('k')
+    plt.ylabel('k')
+    plt.subplot(235)
+    plt.imshow(att[1][1][30, 3, :, :].detach().numpy())
+    plt.title('B1L1, t=30, Head=3')
+    plt.colorbar(orientation='horizontal')
+    plt.xlabel('k')
+    plt.ylabel('k')
+    plt.subplot(233)
+    plt.imshow(att[2][0][30, 3, :, :].detach().numpy())
+    plt.title('B2L0, t=30, Head=3')
+    plt.colorbar(orientation='horizontal')
+    plt.xlabel('k')
+    plt.ylabel('k')
+    plt.subplot(236)
+    plt.imshow(att[2][1][30, 3, :, :].detach().numpy())
+    plt.title('B2L1, t=30, Head=3')
+    plt.colorbar(orientation='horizontal')
+    plt.xlabel('k')
+    plt.ylabel('k')
+    plt.tight_layout()
+    plt.show()
+    plt.subplot(231)
+    plt.imshow(att[0][0][30, 5, :, :].detach().numpy())
+    plt.title('B0L0, t=30, Head=5')
+    plt.colorbar(orientation='horizontal')
+    plt.xlabel('k')
+    plt.ylabel('k')
+    plt.subplot(234)
+    plt.imshow(att[0][1][30, 5, :, :].detach().numpy())
+    plt.title('B0L1, t=30, Head=5')
+    plt.colorbar(orientation='horizontal')
+    plt.xlabel('k')
+    plt.ylabel('k')
+    plt.subplot(232)
+    plt.imshow(att[1][0][30, 5, :, :].detach().numpy())
+    plt.title('B1L0, t=30, Head=5')
+    plt.colorbar(orientation='horizontal')
+    plt.xlabel('k')
+    plt.ylabel('k')
+    plt.subplot(235)
+    plt.imshow(att[1][1][30, 5, :, :].detach().numpy())
+    plt.title('B1L1, t=30, Head=5')
+    plt.colorbar(orientation='horizontal')
+    plt.xlabel('k')
+    plt.ylabel('k')
+    plt.subplot(233)
+    plt.imshow(att[2][0][30, 5, :, :].detach().numpy())
+    plt.title('B2L0, t=30, Head=5')
+    plt.colorbar(orientation='horizontal')
+    plt.xlabel('k')
+    plt.ylabel('k')
+    plt.subplot(236)
+    plt.imshow(att[2][1][30, 5, :, :].detach().numpy())
+    plt.title('B2L1, t=30, Head=5')
+    plt.colorbar(orientation='horizontal')
+    plt.xlabel('k')
+    plt.ylabel('k')
+    plt.tight_layout()
+    plt.show()
+
+    # Temporal Self-attention: (K x H x T x T) How time t attends to time t?
+    plt.subplot(231)
+    plt.imshow(torch.sum(torch.sum(att[0][2], axis=1),
+                         axis=0).detach().numpy(),
+               origin='upper')
+    plt.title('B0L2')
+    plt.xlabel('t')
+    plt.ylabel('t')
+    plt.subplot(234)
+    plt.imshow(torch.sum(torch.sum(att[0][3], axis=1),
+                         axis=0).detach().numpy(),
+               origin='upper')
+    plt.title('B0L3')
+    plt.xlabel('t')
+    plt.ylabel('t')
+    plt.subplot(232)
+    plt.imshow(torch.sum(torch.sum(att[1][2], axis=1),
+                         axis=0).detach().numpy(),
+               origin='upper')
+    plt.title('B1L2')
+    plt.xlabel('t')
+    plt.ylabel('t')
+    plt.subplot(235)
+    plt.imshow(torch.sum(torch.sum(att[1][3], axis=1),
+                         axis=0).detach().numpy(),
+               origin='upper')
+    plt.title('B1L3')
+    plt.xlabel('t')
+    plt.ylabel('t')
+    plt.subplot(233)
+    plt.imshow(torch.sum(torch.sum(att[2][2], axis=1),
+                         axis=0).detach().numpy(),
+               origin='upper')
+    plt.title('B2L2')
+    plt.xlabel('t')
+    plt.ylabel('t')
+    plt.subplot(236)
+    plt.imshow(torch.sum(torch.sum(att[2][3], axis=1),
+                         axis=0).detach().numpy(),
+               origin='upper')
+    plt.title('B2L3')
+    plt.xlabel('t')
+    plt.ylabel('t')
+    plt.tight_layout()
+    plt.show()
+
+    # decoding
+    dec_input_ids = model.shift_right_fn(label)
+    dec_inputs_embeds = model.embed_tokens(dec_input_ids)
+    dec_output = model.decoder(inputs_embeds=dec_inputs_embeds,
+                               encoder_hidden_states=enc_hs_proj,
+                               output_attentions=True,
+                               output_hidden_states=True,
+                               return_dict=True)
+    dec_att, dec_catt = dec_output.attentions, dec_output.cross_attentions
+    dec_hs_all = dec_output.hidden_states
+
+    # dec att
+    plt.subplot(1, 2, 1)
+    plt.imshow(torch.sum(dec_att[0][0], axis=0).detach().numpy())
+    plt.title('decoder attention, layer0')
+    plt.xlabel('decoder time step')
+    plt.ylabel('decoder time step')
+    plt.subplot(1, 2, 2)
+    plt.imshow(torch.sum(dec_att[7][0], axis=0).detach().numpy())
+    plt.title('decoder attention, layer8')
+    plt.xlabel('decoder time step')
+    plt.show()
+    # dec catt
+    plt.imshow(np.rot90((torch.sum(dec_catt[7][0],
+                                   axis=0))[:1000, :].detach().numpy()),
+               origin='upper',
+               aspect='auto')
+    plt.colorbar()
+    plt.title('decoder cross att, layer8')
+    plt.xlabel('decoder time step')
+    plt.ylabel('encoder frame')
+    plt.show()
+    # dec catt by head with xxx
+    dec_att_z = z_normalize_tensors(shorten_att(dec_att))
+    plt.imshow(dec_att_z[0][0, 0, :, :].detach().numpy())
+    from bertviz import head_view
+    token = []
+    for i in label[0, :30]:
+        token.append(str(i))
+    head_view(dec_att_z, tokens)
+
+    # dec_hs
+    plt.subplot(1, 2, 1)
+    plt.imshow(dec_hs_all[0][0].detach().numpy(), origin='upper')
+    plt.colorbar(orientation='horizontal')
+    plt.title('decoder hidden state, layer1')
+    plt.xlabel('hidden dim')
+    plt.ylabel('time step')
+    plt.subplot(1, 2, 2)
+    plt.imshow(dec_hs_all[7][0].detach().numpy(), origin='upper')
+    plt.colorbar(orientation='horizontal')
+    plt.title('decoder hidden state, layer8')
+    plt.xlabel('hidden dim')
+    plt.show()
+
+    # lm head
+    logits = model.lm_head(dec_hs_all[0])
+    plt.imshow(logits[0][0:200, :].detach().numpy(), origin='upper')
+    plt.title('lm head softmax')
+    plt.xlabel('vocab dim')
+    plt.ylabel('time step')
+    plt.xlim([1000, 1350])
+    plt.show()
+    softmax = torch.nn.Softmax(dim=2)
+    logits_sm = softmax(logits)
+    plt.imshow(logits_sm[0][0:200, :].detach().numpy(), origin='upper')
+    plt.title('lm head softmax')
+    plt.xlabel('vocab dim')
+    plt.ylabel('time step')
+    plt.xlim([1000, 1350])
+    plt.show()

extras/perceivertf_multi_inspect.py

@@ -0,0 +1,778 @@
+import numpy as np
+import torch
+import torch.nn.functional as F
+import torchaudio
+from matplotlib.animation import FuncAnimation
+
+def l2_normalize(matrix):
+    """
+    L2 Normalize the matrix along its rows.
+
+    Parameters:
+        matrix (numpy.ndarray): The input matrix.
+
+    Returns:
+        numpy.ndarray: The L2 normalized matrix.
+    """
+    l2_norms = np.linalg.norm(matrix, axis=1, keepdims=True)
+    normalized_matrix = matrix / l2_norms
+    return normalized_matrix
+
+
+def z_normalize(matrix):
+    """
+    Z-normalize the matrix along its rows (mean=0 and std=1).
+    Z-normalization is also known as "standardization", and derives from z-score.
+    Z = (X - mean) / std
+    Z-nomarlized, each row has mean=0 and std=1. 
+
+    Parameters:
+        matrix (numpy.ndarray): The input matrix.
+
+    Returns:
+        numpy.ndarray: The Z normalized matrix.
+    """
+    mean = np.mean(matrix, axis=1, keepdims=True)
+    std = np.std(matrix, axis=1, keepdims=True)
+    normalized_matrix = (matrix - mean) / std
+    return normalized_matrix
+
+
+def l2_normalize_tensors(tensor_tuple):
+    """
+    Applies L2 normalization on the last two dimensions for each tensor in a tuple.
+
+    Parameters:
+        tensor_tuple (tuple of torch.Tensor): A tuple containing N tensors, each of shape (1, k, 30, 30).
+
+    Returns:
+        tuple of torch.Tensor: A tuple containing N L2-normalized tensors.
+    """
+    normalized_tensors = []
+    for tensor in tensor_tuple:
+        # Ensure the tensor is a floating-point type
+        tensor = tensor.float()
+
+        # Calculate L2 norm on the last two dimensions, keeping the dimensions using keepdim=True
+        l2_norm = torch.linalg.norm(tensor, dim=(-2, -1), keepdim=True)
+
+        # Apply L2 normalization
+        normalized_tensor = tensor / (
+            l2_norm + 1e-7)  # Small value to avoid division by zero
+
+        normalized_tensors.append(normalized_tensor)
+
+    return tuple(normalized_tensors)
+
+
+def z_normalize_tensors(tensor_tuple):
+    """
+    Applies Z-normalization on the last two dimensions for each tensor in a tuple.
+
+    Parameters:
+        tensor_tuple (tuple of torch.Tensor): A tuple containing N tensors, each of shape (1, k, 30, 30).
+
+    Returns:
+        tuple of torch.Tensor: A tuple containing N Z-normalized tensors.
+    """
+    normalized_tensors = []
+    for tensor in tensor_tuple:
+        # Ensure the tensor is a floating-point type
+        tensor = tensor.float()
+
+        # Calculate mean and std on the last two dimensions
+        mean = tensor.mean(dim=(-2, -1), keepdim=True)
+        std = tensor.std(dim=(-2, -1), keepdim=True)
+
+        # Apply Z-normalization
+        normalized_tensor = (tensor - mean) / (
+            std + 1e-7)  # Small value to avoid division by zero
+
+        normalized_tensors.append(normalized_tensor)
+
+    return tuple(normalized_tensors)
+
+
+def apply_temperature_to_attention_tensors(tensor_tuple, temperature=1.0):
+    """
+    Applies temperature scaling to the attention weights in each tensor in a tuple.
+    
+    Parameters:
+        tensor_tuple (tuple of torch.Tensor): A tuple containing N tensors, 
+                                             each of shape (1, k, 30, 30).
+        temperature (float): Temperature parameter to control the sharpness 
+                             of the attention weights. Default is 1.0.
+                             
+    Returns:
+        tuple of torch.Tensor: A tuple containing N tensors with scaled attention weights.
+    """
+    scaled_attention_tensors = []
+
+    for tensor in tensor_tuple:
+        # Ensure the tensor is a floating-point type
+        tensor = tensor.float()
+
+        # Flatten the last two dimensions
+        flattened_tensor = tensor.reshape(1, tensor.shape[1],
+                                          -1)  # Modified line here
+
+        # Apply temperature scaling and softmax along the last dimension
+        scaled_attention = flattened_tensor / temperature
+        scaled_attention = F.softmax(scaled_attention, dim=-1)
+
+        # Reshape to original shape
+        scaled_attention = scaled_attention.view_as(tensor)
+
+        scaled_attention_tensors.append(scaled_attention)
+
+    return tuple(scaled_attention_tensors)
+
+
+def shorten_att(tensor_tuple, length=30):
+    shortend_tensors = []
+    for tensor in tensor_tuple:
+        shortend_tensors.append(tensor[:, :, :length, :length])
+    return tuple(shortend_tensors)
+
+
+def keep_top_k(matrix, k=6):
+    """
+    Keep only the top k values in each row, set the rest to 0.
+
+    Parameters:
+        matrix (numpy.ndarray): The input matrix.
+        k (int): The number of top values to keep in each row.
+
+    Returns:
+        numpy.ndarray: The transformed matrix.
+    """
+    topk_indices_per_row = np.argpartition(matrix, -k, axis=1)[:, -k:]
+    result_matrix = np.zeros_like(matrix)
+
+    for i in range(matrix.shape[0]):
+        result_matrix[i, topk_indices_per_row[i]] = matrix[
+            i, topk_indices_per_row[i]]
+    return result_matrix
+
+
+def test_case_forward_enc_perceiver_tf_dec_multi_t5():
+    import torch
+    from model.ymt3 import YourMT3
+    from config.config import audio_cfg, model_cfg, shared_cfg
+    model_cfg["encoder_type"] = "perceiver-tf"
+
+    model_cfg["encoder"]["perceiver-tf"]["attention_to_channel"] = True
+    model_cfg["encoder"]["perceiver-tf"]["num_latents"] = 26
+
+    model_cfg["decoder_type"] = "multi-t5"
+
+    audio_cfg["codec"] = "spec"
+    audio_cfg["hop_length"] = 300
+    model = YourMT3(audio_cfg=audio_cfg, model_cfg=model_cfg)
+    model.eval()
+
+    # x = torch.randn(2, 1, 32767)
+    # labels = torch.randint(0, 400, (2, 1024), requires_grad=False)
+
+    # # forward
+    # output = model.forward(x, labels)
+
+    # # inference
+    # result = model.inference(x, None)
+
+    # display latents
+    checkpoint = torch.load(
+        "../logs/ymt3/ptf_mc13_256_all_cross_v6_xk5_amp0811_edr005_attend_c_full_plus_2psn_nl26_sb_b26r_800k/checkpoints/model.ckpt",
+        map_location="cpu")
+    state_dict = checkpoint['state_dict']
+    new_state_dict = {
+        k: v
+        for k, v in state_dict.items() if 'pitchshift' not in k
+    }
+    model.load_state_dict(new_state_dict, strict=False)
+
+    latents = model.encoder.latent_array.latents.detach().numpy()
+    import matplotlib.pyplot as plt
+    import numpy as np
+    from sklearn.metrics.pairwise import cosine_similarity
+    cos = cosine_similarity(latents)
+
+    from utils.data_modules import AMTDataModule
+    from einops import rearrange
+    # dm = AMTDataModule(data_preset_multi={"presets": ["slakh"]})
+    #dm.setup("test")
+    # dl = dm.test_dataloader()
+    # ds = list(dl.values())[0].dataset
+    # audio, notes, tokens, _ = ds.__getitem__(7)
+    # x = audio[[16], ::]
+    # label = tokens[[16], :]
+
+    # from utils.task_manager import TaskManager
+    # tm = TaskManager(task_name='mc13_256')
+    # dm = AMTDataModule(data_preset_multi={"presets": ["slakh"]},
+    #                    task_manager=tm,
+    #                    train_stem_iaug_prob=None,
+    #                    train_stem_xaug_policy=None)
+    # dm.setup('fit')
+    # dl = dm.train_dataloader()
+    # ds = dl.flattened[0].dataset
+    # audio,tokens, _, _ = ds.__getitem__(67)
+    # x = audio[[5], ::]
+    # label = tokens[[5], :]
+    # save audio
+    # torchaudio.save("singing.wav", x[0, :, :], 16000)
+    
+    x, _ = torchaudio.load('piano.wav')#'test.wav')
+    x = x.unsqueeze(0)
+
+    # spectrogram
+    x_spec = model.spectrogram(x)
+    x_conv = model.pre_encoder(x_spec)
+    # Create a larger figure
+    plt.figure(
+        figsize=(15,
+                 10))  # Adjust these numbers as needed for width and height
+    plt.subplot(2, 4, 1)
+    plt.imshow(x_spec[0].detach().numpy().T, aspect='auto', origin='lower')
+    plt.title("spectrogram")
+    plt.xlabel('time step')
+    plt.ylabel('frequency bin')
+    plt.subplot(2, 4, 2)
+    plt.imshow(x_conv[0][:, :, 0].detach().numpy().T,
+               aspect='auto',
+               origin='lower')
+    plt.title("conv(spec), ch=0")
+    plt.xlabel('time step')
+    plt.ylabel('F')
+    plt.subplot(2, 4, 3)
+    plt.imshow(x_conv[0][:, :, 42].detach().numpy().T,
+               aspect='auto',
+               origin='lower')
+    plt.title("ch=42")
+    plt.xlabel('time step')
+    plt.ylabel('F')
+    plt.subplot(2, 4, 4)
+    plt.imshow(x_conv[0][:, :, 80].detach().numpy().T,
+               aspect='auto',
+               origin='lower')
+    plt.title("ch=80")
+    plt.xlabel('time step')
+    plt.ylabel('F')
+    plt.subplot(2, 4, 5)
+    plt.imshow(x_conv[0][:, :, 11].detach().numpy().T,
+               aspect='auto',
+               origin='lower')
+    plt.title("ch=11")
+    plt.xlabel('time step')
+    plt.ylabel('F')
+    plt.subplot(2, 4, 6)
+    plt.imshow(x_conv[0][:, :, 20].detach().numpy().T,
+               aspect='auto',
+               origin='lower')
+    plt.title("ch=20")
+    plt.xlabel('time step')
+    plt.ylabel('F')
+    plt.subplot(2, 4, 7)
+    plt.imshow(x_conv[0][:, :, 77].detach().numpy().T,
+               aspect='auto',
+               origin='lower')
+    plt.title("ch=77")
+    plt.xlabel('time step')
+    plt.ylabel('F')
+    plt.subplot(2, 4, 8)
+    plt.imshow(x_conv[0][:, :, 90].detach().numpy().T,
+               aspect='auto',
+               origin='lower')
+    plt.title("ch=90")
+    plt.xlabel('time step')
+    plt.ylabel('F')
+    plt.tight_layout()
+    plt.show()
+
+    # encoding
+    output = model.encoder(inputs_embeds=x_conv,
+                           output_hidden_states=True,
+                           output_attentions=True)
+    enc_hs_all, att, catt = output["hidden_states"], output[
+        "attentions"], output["cross_attentions"]
+    enc_hs_last = enc_hs_all[2]
+
+    # enc_hs: time-varying encoder hidden state
+    plt.subplot(2, 3, 1)
+    plt.imshow(enc_hs_all[0][0][:, :, 21].detach().numpy().T)
+    plt.title('ENC_HS B0, d21')
+    plt.colorbar(orientation='horizontal')
+    plt.ylabel('latent k')
+    plt.xlabel('t')
+    plt.subplot(2, 3, 4)
+    plt.imshow(enc_hs_all[0][0][:, :, 127].detach().numpy().T)
+    plt.colorbar(orientation='horizontal')
+    plt.title('B0, d127')
+    plt.ylabel('latent k')
+    plt.xlabel('t')
+    plt.subplot(2, 3, 2)
+    plt.imshow(enc_hs_all[1][0][:, :, 21].detach().numpy().T)
+    plt.colorbar(orientation='horizontal')
+    plt.title('B1, d21')
+    plt.ylabel('latent k')
+    plt.xlabel('t')
+    plt.subplot(2, 3, 5)
+    plt.imshow(enc_hs_all[1][0][:, :, 127].detach().numpy().T)
+    plt.colorbar(orientation='horizontal')
+    plt.title('B1, d127')
+    plt.ylabel('latent k')
+    plt.xlabel('t')
+    plt.subplot(2, 3, 3)
+    plt.imshow(enc_hs_all[2][0][:, :, 21].detach().numpy().T)
+    plt.colorbar(orientation='horizontal')
+    plt.title('B2, d21')
+    plt.ylabel('latent k')
+    plt.xlabel('t')
+    plt.subplot(2, 3, 6)
+    plt.imshow(enc_hs_all[2][0][:, :, 127].detach().numpy().T)
+    plt.colorbar(orientation='horizontal')
+    plt.title('B2, d127')
+    plt.ylabel('latent k')
+    plt.xlabel('t')
+    plt.tight_layout()
+    plt.show()
+
+    # enc_hs: time-varying encoder hidden state by k (block, 1, t, k, d)
+    # --> (t, d) for each k in last block
+    data = enc_hs_all[2][0].detach().numpy()  # (T, K, D)
+    fig, axs = plt.subplots(
+        5, 5, figsize=(10, 9))  # 25 subplots arranged in 5 rows and 5 columns
+    axs = axs.flatten(
+    )  # Flatten the 2D array of axes to 1D for easy iteration
+
+    for k in range(25):  # Iterating through K indices from 0 to 24
+        axs[k].imshow(data[:, k, :].T,
+                      cmap='viridis')  # Transposing the matrix to swap T and D
+        axs[k].set_title(f'k={k}')
+        axs[k].set_xlabel('Time step')
+        axs[k].set_ylabel('Dim')
+
+    # Adjusting layout for better visibility
+    plt.tight_layout()
+    plt.show()
+
+    #!! Projected encoder hidden state for 13 channels, that is conditioning for decoder
+    enc_hs_proj = model.pre_decoder(enc_hs_last)
+    fig, axs = plt.subplots(1, 13, figsize=(26, 8))  # 13 subplots in a row
+    data = enc_hs_proj[0].detach().numpy()
+    for ch in range(13):
+        axs[ch].imshow(np.rot90(data[ch]), cmap='viridis')  # Rotate 90 degrees
+        axs[ch].set_title(f'ch: {ch}')
+        axs[ch].set_xlabel('Time step')
+        axs[ch].set_ylabel('Dim')
+    plt.suptitle(
+        'linear projection of encoder outputs by channel, which is conditioning for enc-dec cross attention',
+        y=0.1,
+        fontsize=12)
+    plt.tight_layout(rect=[0, 0.1, 1, 1])
+    plt.show()
+
+    plt.subplot(221)
+    plt.imshow(enc_hs_all[2][0][0, :, :].detach().numpy(), aspect='auto')
+    plt.title('enc_hs, t=0')
+    plt.ylabel('latent k')
+    plt.xlabel('d')
+    plt.subplot(222)
+    plt.imshow(enc_hs_all[2][0][10, :, :].detach().numpy(), aspect='auto')
+    plt.title('enc_hs, t=10')
+    plt.ylabel('latent k')
+    plt.xlabel('d')
+    plt.subplot(223)
+    plt.imshow(enc_hs_all[2][0][20, :, :].detach().numpy(), aspect='auto')
+    plt.title('enc_hs, t=20')
+    plt.ylabel('latent k')
+    plt.xlabel('d')
+    plt.subplot(224)
+    plt.imshow(enc_hs_all[2][0][30, :, :].detach().numpy(), aspect='auto')
+    plt.title('enc_hs, t=30')
+    plt.ylabel('latent k')
+    plt.xlabel('d')
+    plt.tight_layout()
+    plt.show()
+
+    # enc_hs correlation: which dim has most unique info?
+    plt.subplot(1, 3, 1)
+    a = rearrange(enc_hs_last, '1 t k d -> t (k d)').detach().numpy()
+    plt.imshow(cosine_similarity(a))
+    plt.title("enc hs, t x t cos_sim")
+    plt.subplot(1, 3, 2)
+    b = rearrange(enc_hs_last, '1 t k d -> k (t d)').detach().numpy()
+    plt.imshow(cosine_similarity(b))
+    plt.title("enc hs, k x k cos_sim")
+    plt.subplot(1, 3, 3)
+    c = rearrange(enc_hs_last, '1 t k d -> d (k t)').detach().numpy()
+    plt.imshow(cosine_similarity(c))
+    plt.title("cross att, d x d cos_sim")
+    plt.tight_layout()
+    plt.show()
+
+    #!! enc latent
+    plt.imshow(model.encoder.latent_array.latents.detach().numpy())
+    plt.title('latent array')
+    plt.xlabel('d')
+    plt.ylabel('latent k')
+    plt.show()
+
+    #!! enc Spectral Cross Attention: (T x head x K x D). How latent K attends to conv channel C?
+    plt.subplot(311)
+    plt.imshow(
+        torch.sum(torch.sum(catt[0][0], axis=0), axis=0).detach().numpy())
+    plt.title('block=0')
+    plt.ylabel('latent k')
+    plt.xlabel('conv channel')
+    plt.subplot(312)
+    plt.imshow(
+        torch.sum(torch.sum(catt[1][0], axis=0), axis=0).detach().numpy())
+    plt.title('block=1')
+    plt.ylabel('latent k')
+    plt.xlabel('conv channel')
+    plt.subplot(313)
+    plt.imshow(
+        torch.sum(torch.sum(catt[2][0], axis=0), axis=0).detach().numpy())
+    plt.title('block=2')
+    plt.ylabel('latent k')
+    plt.xlabel('conv channel')
+    # f'spectral cross attention. T-C-F Model',
+    # y=0,
+    # fontsize=12)
+    plt.tight_layout()
+    plt.show()
+
+    #!! Animation of SCA for varying time, head in last block
+    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 6))  # Adjusted figsize for better layout
+
+    # Function to update the plots for each frame in the animation
+    def update(t):
+        # Clear previous images
+        ax1.clear()
+        ax2.clear()
+
+        # Update subplot for h=3
+        ax1.imshow(catt[2][0][t, 3, :, :].detach().numpy())
+        ax1.set_title(f'block=2, t={t}, head=3')
+        ax1.set_ylabel('latent k'); ax1.set_xlabel('conv channel')
+
+        # Update subplot for h=5
+        ax2.imshow(catt[2][0][t, 5, :, :].detach().numpy())
+        ax2.set_title(f'block=2, t={t}, head=5')
+        ax2.set_ylabel('latent k'); ax2.set_xlabel('conv channel')
+
+        # Adjust layout
+        fig.tight_layout()
+
+    # Create the animation
+    anim = FuncAnimation(fig, update, frames=range(0, 110), interval=200)
+    anim.save('animation.gif', writer='pillow', fps=5)
+
+
+
+    fig, axs = plt.subplots(3, 1, figsize=(12, 18), gridspec_kw={'height_ratios': [1, 1, 0.5]})  # Adjusted for different subplot sizes
+
+    # Subplots for catt visualization (h=3 and h=5)
+    ax_catt3, ax_catt5, ax_att_row = axs
+
+    # Creating 8 subplots for att visualization within the third row
+    for i in range(8):
+        ax_att_row = fig.add_subplot(3, 8, 17 + i)  # Adding subplots in the third row
+
+    # Update function for the combined animation
+    def combined_update_smaller_att(t):
+        # Update subplot for catt with h=3
+        ax_catt3.clear()
+        ax_catt3.imshow(catt[2][0][t, 3, :, :].detach().numpy())
+        ax_catt3.set_title(f'block=2, t={t}, head=3')
+        ax_catt3.set_ylabel('latent k'); ax_catt3.set_xlabel('conv channel')
+
+        # Update subplot for catt with h=5
+        ax_catt5.clear()
+        ax_catt5.imshow(catt[2][0][t, 5, :, :].detach().numpy())
+        ax_catt5.set_title(f'block=2, t={t}, head=5')
+        ax_catt5.set_ylabel('latent k'); ax_catt5.set_xlabel('conv channel')
+
+        # Update subplots for att (8 heads in one row)
+        for i in range(8):
+            ax = fig.add_subplot(3, 8, 17 + i)
+            ax.clear()
+            ax.imshow(att[0][1][t, i, :, :].detach().numpy(), cmap='viridis')
+            ax.set_title(f't={t}, head={i}')
+            ax.set_xlabel('k')
+            ax.set_ylabel('k')
+            ax.axis('square')  # Make each subplot square-shaped
+
+        # Adjust layout
+        fig.tight_layout()
+    combined_anim_smaller_att = FuncAnimation(fig, combined_update_smaller_att, frames=range(0, 110), interval=200)
+    combined_anim_smaller_att.save('combined_animation_smaller_att.gif', writer='pillow', fps=5)
+
+
+
+
+
+    # enc Latent Self-attention: How latent K attends to K?
+    plt.subplot(231)
+    plt.imshow(torch.sum(torch.sum(att[0][0], axis=1),
+                         axis=0).detach().numpy(),
+               origin='upper')
+    plt.title('B0L0')
+    plt.xlabel('latent k')
+    plt.ylabel('latent k')
+    plt.subplot(234)
+    plt.imshow(torch.sum(torch.sum(att[0][1], axis=1),
+                         axis=0).detach().numpy(),
+               origin='upper')
+    plt.title('B0L1')
+    plt.xlabel('latent k')
+    plt.ylabel('latent k')
+    plt.subplot(232)
+    plt.imshow(torch.sum(torch.sum(att[1][0], axis=1),
+                         axis=0).detach().numpy(),
+               origin='upper')
+    plt.title('B1L0')
+    plt.xlabel('latent k')
+    plt.ylabel('latent k')
+    plt.subplot(235)
+    plt.imshow(torch.sum(torch.sum(att[1][1], axis=1),
+                         axis=0).detach().numpy(),
+               origin='upper')
+    plt.title('B1L1')
+    plt.xlabel('latent k')
+    plt.ylabel('latent k')
+    plt.subplot(233)
+    plt.imshow(torch.sum(torch.sum(att[2][0], axis=1),
+                         axis=0).detach().numpy(),
+               origin='upper')
+    plt.title('B2L0')
+    plt.xlabel('latent k')
+    plt.ylabel('latent k')
+    plt.subplot(236)
+    plt.imshow(torch.sum(torch.sum(att[2][1], axis=1),
+                         axis=0).detach().numpy(),
+               origin='upper')
+    plt.title('B2L1')
+    plt.xlabel('latent k')
+    plt.ylabel('latent k')
+    plt.tight_layout()
+    plt.show()
+    # Time varying, different head for latent self-attention
+    #!!! Display latent self-attention for each head
+    bl = 0  # first latent transformer block, last layer att
+    data = att[bl][1].detach().numpy()
+    time_steps = [30, 50, 100]
+    fig, axs = plt.subplots(
+        len(time_steps), 8,
+        figsize=(16, 6))  # Subplots for each time step and head
+    for i, t in enumerate(time_steps):
+        for head in range(8):
+            axs[i, head].imshow(data[t, head, :, :], cmap='viridis')
+            axs[i, head].set_title(f't={t}, head={head}')
+            axs[i, head].set_xlabel('k')
+            axs[i, head].set_ylabel('k')
+    plt.suptitle(
+        f'latent transformer block={bl}, last layer self-attention over time',
+        y=0,
+        fontsize=12)
+    plt.tight_layout()
+    plt.show()
+
+    bl = 1  # second latent transformer block, last layer att
+    data = att[bl][1].detach().numpy()
+    time_steps = [30, 50, 100]
+    fig, axs = plt.subplots(
+        len(time_steps), 8,
+        figsize=(16, 6))  # Subplots for each time step and head
+    for i, t in enumerate(time_steps):
+        for head in range(8):
+            axs[i, head].imshow(data[t, head, :, :], cmap='viridis')
+            axs[i, head].set_title(f't={t}, head={head}')
+            axs[i, head].set_xlabel('k')
+            axs[i, head].set_ylabel('k')
+    plt.suptitle(
+        f'latent transformer block={bl}, last layer self-attention over time',
+        y=0,
+        fontsize=12)
+    plt.tight_layout()
+    plt.show()
+
+    bl = 2  # last latent transformer block, last layer att
+    data = att[bl][1].detach().numpy()
+    time_steps = [30, 50, 100]
+    fig, axs = plt.subplots(
+        len(time_steps), 8,
+        figsize=(16, 6))  # Subplots for each time step and head
+    for i, t in enumerate(time_steps):
+        for head in range(8):
+            axs[i, head].imshow(data[t, head, :, :], cmap='viridis')
+            axs[i, head].set_title(f't={t}, head={head}')
+            axs[i, head].set_xlabel('k')
+            axs[i, head].set_ylabel('k')
+    plt.suptitle(
+        f'latent transformer block={bl}, last layer self-attention over time',
+        y=0,
+        fontsize=12)
+    plt.tight_layout()
+    plt.show()
+
+    # Temporal Self-attention: (K x H x T x T) How time t attends to time t?
+    plt.subplot(231)
+    plt.imshow(torch.sum(torch.sum(att[0][2], axis=1),
+                         axis=0).detach().numpy(),
+               origin='upper')
+    plt.title('B0L2')
+    plt.xlabel('t')
+    plt.ylabel('t')
+    plt.subplot(234)
+    plt.imshow(torch.sum(torch.sum(att[0][3], axis=1),
+                         axis=0).detach().numpy(),
+               origin='upper')
+    plt.title('B0L3')
+    plt.xlabel('t')
+    plt.ylabel('t')
+    plt.subplot(232)
+    plt.imshow(torch.sum(torch.sum(att[1][2], axis=1),
+                         axis=0).detach().numpy(),
+               origin='upper')
+    plt.title('B1L2')
+    plt.xlabel('t')
+    plt.ylabel('t')
+    plt.subplot(235)
+    plt.imshow(torch.sum(torch.sum(att[1][3], axis=1),
+                         axis=0).detach().numpy(),
+               origin='upper')
+    plt.title('B1L3')
+    plt.xlabel('t')
+    plt.ylabel('t')
+    plt.subplot(233)
+    plt.imshow(torch.sum(torch.sum(att[2][2], axis=1),
+                         axis=0).detach().numpy(),
+               origin='upper')
+    plt.title('B2L2')
+    plt.xlabel('t')
+    plt.ylabel('t')
+    plt.subplot(236)
+    plt.imshow(torch.sum(torch.sum(att[2][3], axis=1),
+                         axis=0).detach().numpy(),
+               origin='upper')
+    plt.title('B2L3')
+    plt.xlabel('t')
+    plt.ylabel('t')
+    plt.tight_layout()
+    plt.show()
+
+    # decoding
+    dec_input_ids = model.shift_right_fn(label)
+    dec_inputs_embeds = model.embed_tokens(dec_input_ids)
+    dec_output = model.decoder(inputs_embeds=dec_inputs_embeds,
+                               encoder_hidden_states=enc_hs_proj,
+                               output_attentions=True,
+                               output_hidden_states=True,
+                               return_dict=True)
+    dec_att, dec_catt = dec_output.attentions, dec_output.cross_attentions
+    dec_hs_all = dec_output.hidden_states
+    dec_last_hs = dec_output.last_hidden_state
+
+    # lm head
+    logits = model.lm_head(dec_last_hs)
+
+    # pred ids
+    pred_ids = torch.argmax(logits, dim=3)
+
+    # dec att
+    plt.subplot(1, 2, 1)
+    plt.imshow(torch.sum(dec_att[5][0], axis=0).detach().numpy())
+    plt.title('decoder attention, layer0')
+    plt.xlabel('decoder time step')
+    plt.ylabel('decoder time step')
+    plt.subplot(1, 2, 2)
+    plt.imshow(torch.sum(dec_att[7][0], axis=0).detach().numpy())
+    plt.title('decoder attention, final layer')
+    plt.xlabel('decoder step')
+    plt.show()
+    
+    
+    # dec catt
+    def remove_values_after_eos(catt_np, pred_ids, max_k):
+        # catt_np: (k, head, t, t)
+        # pred_ids: (1, k, t))
+        max_length = pred_ids.shape[-1]
+        seq_lengths = np.zeros((max_k), dtype=np.int32)
+        for k in range(max_k):
+            for t in range(max_length):
+                if pred_ids[0, k, t] == 1:
+                    break
+            catt_np[k, :, t+1:, :] = 0
+            # catt_np[k, :, :, t+1:] = 0
+            seq_lengths[k] = t+1  
+        return catt_np, seq_lengths
+
+    # data = dec_catt[1].detach().numpy() # last layer's cross attention
+    l = 4
+    data = dec_catt[l].detach().numpy() 
+    data, seq_lengths = remove_values_after_eos(data, pred_ids, max_k=13)
+    seq_lengths[:]= 256
+
+    fig, axs = plt.subplots(13, 6, figsize=(21, 39))  # 13 rows (for k=0:12) and 7 columns (for head=0:6)
+    for k in range(13):
+        s = seq_lengths[k]
+        for head in range(6):
+            axs[k, head].imshow(data[k, head, :s, :].T, aspect='auto', cmap='viridis')
+            axs[k, head].set_title(f'Layer {l}, k={k}, head={head}')
+            axs[k, head].set_xlabel('Decoder step')
+            axs[k, head].set_ylabel('Encoder frame')
+    plt.tight_layout()
+    plt.show()
+
+
+    # # dec catt by head with xxx
+    # dec_att_z = z_normalize_tensors(shorten_att(dec_att))
+    # plt.imshow(dec_att_z[0][0, 0, :, :].detach().numpy())
+    # from bertviz import head_view
+    # token = []
+    # for i in label[0, :30]:
+    #     token.append(str(i))
+    # head_view(dec_att_z, tokens)
+
+    # dec_hs
+    plt.subplot(1, 2, 1)
+    k=2
+    plt.imshow(dec_last_hs[0][k].detach().numpy(), origin='upper')
+    plt.colorbar(orientation='horizontal')
+    plt.title('decoder last hidden state, k=0')
+    plt.xlabel('hidden dim')
+    plt.ylabel('time step')
+    plt.subplot(1, 2, 2)
+    k=12
+    plt.imshow(dec_last_hs[0][k].detach().numpy(), origin='upper')
+    plt.colorbar(orientation='horizontal')
+    plt.title('decoder last hidden state, k=12')
+    plt.xlabel('hidden dim')
+    plt.show()
+
+    # lm head
+    logits = model.lm_head(dec_last_hs)
+    k=6
+    plt.imshow(logits[0][k][0:200, :].detach().numpy().T, origin='upper')
+    plt.title('lm head output')
+    plt.xlabel('vocab dim')
+    plt.ylabel('time step')
+    plt.show()
+    softmax = torch.nn.Softmax(dim=3)
+    logits_sm = softmax(logits) # B, K, T, V
+    k=6
+    plt.imshow(logits_sm[0][k][:255, :].detach().numpy().T, origin='upper')
+    plt.title('lm head softmax')
+    plt.xlabel('vocab dim')
+    plt.ylabel('time step')
+    # plt.xlim([1000, 1350])
+    plt.show()
+
+    k = 10
+    print(torch.argmax(logits, dim=3)[0,k,:])
+
+
+
+

extras/pitch_shift_benchmark.py

@@ -0,0 +1,167 @@
+""" Test the speed of the augmentation """
+import torch
+import torchaudio
+
+# Device
+device = torch.device("cuda")
+# device = torch.device("cpu")
+
+# Music
+# x, _ = torchaudio.load("music.wav")
+# slice_length = 32767
+# n_slices = 80
+# slices = [x[0, i * slice_length:(i + 1) * slice_length] for i in range(n_slices)]
+# x = torch.stack(slices)  # (80, 32767)
+# Sine wave
+t = torch.arange(0, 2.0479, 1 / 16000)  # 2.05 seconds at 16kHz
+x = torch.sin(2 * torch.pi * 440 * t) * 0.5
+x = x.reshape(1, 1, 32767).tile(80, 1, 1)
+x = x.to(device)
+
+############################################################################################
+# torch-audiomentation: https://github.com/asteroid-team/torch-audiomentation
+#
+# process time <CPU>: 1.18 s ± 5.35 ms
+# process time <GPU>: 58 ms
+# GPU memory usage: 3.8 GB per 1 semitone
+############################################################################################
+import torch
+from torch_audiomentations import Compose, PitchShift, Gain, PolarityInversion
+
+apply_augmentation = Compose(transforms=[
+    # Gain(
+    #     min_gain_in_db=-15.0,
+    #     max_gain_in_db=5.0,
+    #     p=0.5,
+    # ),
+    # PolarityInversion(p=0.5)
+    PitchShift(
+        min_transpose_semitones=0,
+        max_transpose_semitones=2.2,
+        mode="per_batch",  #"per_example",
+        p=1.0,
+        p_mode="per_batch",
+        sample_rate=16000,
+        target_rate=16000)
+])
+x_am = apply_augmentation(x, sample_rate=16000)
+
+############################################################################################
+# torchaudio:
+#
+# process time <CPU>: 4.01 s ± 19.6 ms per loop
+# process time <GPU>: 25.1 ms ± 161 µs per loop
+# memory usage <GPU>: 1.2 (growth to 5.49) GB per 1 semitone
+############################################################################################
+from torchaudio import transforms
+
+ta_transform = transforms.PitchShift(16000, n_steps=2).to(device)
+x_ta = ta_transform(x)
+
+############################################################################################
+# YourMT3 pitch_shift_layer:
+#
+# process time <CPU>: 389ms ± 22ms, (stretch=143 ms, resampler=245 ms)
+# process time <GPU>: 7.18 ms ± 17.3 µs (stretch=6.47 ms, resampler=0.71 ms)
+# memory usage: 16 MB per 1 semitone (average)
+############################################################################################
+from model.pitchshift_layer import PitchShiftLayer
+
+ps_ymt3 = PitchShiftLayer(pshift_range=[2, 2], fs=16000, min_gcd=16, n_fft=2048).to(device)
+x_ymt3 = ps_ymt3(x, 2)
+
+############################################################################################
+# Plot 1: Comparison of Process Time and GPU Memory Usage for 3 Pitch Shifting Methods
+############################################################################################
+import matplotlib.pyplot as plt
+
+# Model names
+models = ['torch-audiomentation', 'torchaudio', 'YourMT3:PitchShiftLayer']
+
+# Process time (CPU) in seconds
+cpu_time = [1.18, 4.01, 0.389]
+
+# Process time (GPU) in milliseconds
+gpu_time = [58, 25.1, 7.18]
+
+# GPU memory usage in GB
+gpu_memory = [3.8, 5.49, 0.016]
+
+# Creating subplots
+fig, axs = plt.subplots(1, 3, figsize=(15, 5))
+
+# Creating bar charts
+bar1 = axs[0].bar(models, cpu_time, color=['#FFB6C1', '#ADD8E6', '#98FB98'])
+bar2 = axs[1].bar(models, gpu_time, color=['#FFB6C1', '#ADD8E6', '#98FB98'])
+bar3 = axs[2].bar(models, gpu_memory, color=['#FFB6C1', '#ADD8E6', '#98FB98'])
+
+# Adding labels and titles
+axs[0].set_ylabel('Time (s)')
+axs[0].set_title('Process Time (CPU) bsz=80')
+axs[1].set_ylabel('Time (ms)')
+axs[1].set_title('Process Time (GPU) bsz=80')
+axs[2].set_ylabel('Memory (GB)')
+axs[2].set_title('GPU Memory Usage per semitone')
+
+# Adding grid for better readability of the plots
+for ax in axs:
+    ax.grid(axis='y')
+    ax.set_yscale('log')
+    ax.set_xticklabels(models, rotation=45, ha="right")
+
+# Adding text labels above the bars
+for i, rect in enumerate(bar1):
+    axs[0].text(
+        rect.get_x() + rect.get_width() / 2,
+        rect.get_height(),
+        f'{cpu_time[i]:.2f} s',
+        ha='center',
+        va='bottom')
+for i, rect in enumerate(bar2):
+    axs[1].text(
+        rect.get_x() + rect.get_width() / 2,
+        rect.get_height(),
+        f'{gpu_time[i]:.2f} ms',
+        ha='center',
+        va='bottom')
+for i, rect in enumerate(bar3):
+    axs[2].text(
+        rect.get_x() + rect.get_width() / 2,
+        rect.get_height(),
+        f'{gpu_memory[i]:.3f} GB',
+        ha='center',
+        va='bottom')
+plt.tight_layout()
+plt.show()
+
+############################################################################################
+# Plot 2: Stretch and Resampler Processing Time Contribution
+############################################################################################
+# Data
+processing_type = ['Stretch (Phase Vocoder)', 'Resampler (Conv1D)']
+cpu_times = [143, 245]  # [Stretch, Resampler] times for CPU in milliseconds
+gpu_times = [6.47, 0.71]  # [Stretch, Resampler] times for GPU in milliseconds
+
+# Creating subplots
+fig, axs = plt.subplots(1, 2, figsize=(12, 6))
+
+# Plotting bar charts
+axs[0].bar(processing_type, cpu_times, color=['#ADD8E6', '#98FB98'])
+axs[1].bar(processing_type, gpu_times, color=['#ADD8E6', '#98FB98'])
+
+# Adding labels and titles
+axs[0].set_ylabel('Time (ms)')
+axs[0].set_title('Contribution of CPU Processing Time: YMT3-PS (BSZ=80)')
+axs[1].set_title('Contribution of GPU Processing Time: YMT3-PS (BSZ=80)')
+
+# Adding grid for better readability of the plots
+for ax in axs:
+    ax.grid(axis='y')
+    ax.set_yscale('log')  # Log scale to better visualize the smaller values
+
+# Adding values on top of the bars
+for ax, times in zip(axs, [cpu_times, gpu_times]):
+    for idx, time in enumerate(times):
+        ax.text(idx, time, f"{time:.2f} ms", ha='center', va='bottom', fontsize=8)
+plt.tight_layout()
+plt.show()

extras/run_spleeter_mir1k.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+shopt -s globstar
+for file in "$1"/**/*.wav; do
+    echo $file
+    output_dir="tmp"
+    spleeter separate -b 256k -B tensorflow -p spleeter:2stems -o $output_dir $file -f {instrument}.{codec}
+    sox --ignore-length tmp/accompaniment.wav -r 16000 -c 1 -b 16 tmp/accompaniment_16k.wav
+    sox --ignore-length tmp/vocals.wav -r 16000 -c 1 -b 16 tmp/vocals_16k.wav
+    acc_file="${file//.wav/_accompaniment.wav}"
+    voc_file="${file//.wav/_vocals.wav}"
+    mv -f "tmp/accompaniment_16k.wav" $acc_file
+    mv -f "tmp/vocals_16k.wav" $voc_file
+    echo $acc_file
+    echo $voc_file
+    rm -rf tmp    
+done
+rm -rf pretrained_models

extras/run_spleeter_mirst500.sh

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