Dir mixup

.gitignore

@@ -0,0 +1,3 @@
+dcase24.py
+wandb/
+*.pyc

dataloader.py

@@ -0,0 +1,42 @@
+import torch
+import time
+from torch.utils.data import DataLoader
+from dataset.dcase24_dev import get_training_set
+from helpers.init import worker_init_fn
+from dataset.dcase24_dev_logmel import get_training_set_log
+
+# Function to obtain datasets
+def get_datasets():
+    dataset1 = get_training_set_log(5, roll=0)
+    dataset2 = get_training_set(5, roll=0)
+    return dataset1, dataset2
+
+def measure_dataloader_speed(dataloader, num_batches):
+    start_time = time.time()
+    for i, _ in enumerate(dataloader):
+        if i >= num_batches:
+            break
+    end_time = time.time()
+    elapsed_time = end_time - start_time
+    average_time_per_batch = elapsed_time / num_batches
+    return average_time_per_batch
+
+def main():
+    # Obtain datasets from user-provided script
+    dataset1, dataset2 = get_datasets()
+
+    # Define dataloaders
+    batch_size = 256
+    dataloader1 = DataLoader(dataset1, batch_size=batch_size, shuffle=True, num_workers=0, worker_init_fn=worker_init_fn)
+    dataloader2 = DataLoader(dataset2, batch_size=batch_size, shuffle=True, num_workers=0, worker_init_fn=worker_init_fn)
+
+    # Measure the speed of dataloaders
+    num_batches_to_test = 100
+    avg_time_dataloader1 = measure_dataloader_speed(dataloader1, num_batches_to_test)
+    avg_time_dataloader2 = measure_dataloader_speed(dataloader2, num_batches_to_test)
+
+    print(f"Average loading time per batch for .pt Dataloader: {avg_time_dataloader1:.4f} seconds")
+    print(f"Average loading time per batch for .wav to Logmel Dataloader: {avg_time_dataloader2:.4f} seconds")
+
+if __name__ == "__main__":
+    main()

dataset/dcase24.py → dataset/dcase24_dev.py

@@ -4,10 +4,15 @@
 from torch.utils.data import Dataset as TorchDataset
 import torch
 import torchaudio
+import torch.nn.functional as F
 from torch.hub import download_url_to_file
 import numpy as np
+import librosa
+from scipy.signal import convolve
+import pathlib
 
-dataset_dir = None
+# dataset_dir = r"D:\Sean\DCASE\datasets\Extract_to_Folder\TAU-urban-acoustic-scenes-2022-mobile-development" # Alibaba
+dataset_dir = r"F:\DCASE\2024\Datasets\TAU-urban-acoustic-scenes-2022-mobile-development" # DSP
 assert dataset_dir is not None, "Specify 'TAU Urban Acoustic Scenes 2022 Mobile dataset' location in variable " \
                                 "'dataset_dir'. The dataset can be downloaded from this URL:" \
                                 " https://zenodo.org/record/6337421"
@@ -18,11 +23,69 @@
     "split_path": "split_setup",
     "split_url": "https://github.com/CPJKU/dcase2024_task1_baseline/releases/download/files/",
     "test_split_csv": "test.csv",
-    "eval_dir": os.path.join(dataset_dir, "..", "TAU-urban-acoustic-scenes-2024-mobile-evaluation"),
-    "eval_meta_csv": os.path.join(dataset_dir, "..", "TAU-urban-acoustic-scenes-2024-mobile-evaluation", "meta.csv")
+    "dirs_path": os.path.join("dataset", "dirs"),
+    "eval_dir": os.path.join(dataset_dir), 
+    "eval_meta_csv": os.path.join(dataset_dir, "split100.csv"), # to get the full prediction list with index intact
+    "logits_file": os.path.join("predictions","elymyq0s", "logits.pt") #specifies where the logit and predictions are stored. Still need to provide script with ckpt_id
+    # "eval_dir": os.path.join(dataset_dir, "TAU-urban-acoustic-scenes-2024-mobile-evaluation"), 
+    # "eval_meta_csv": os.path.join(dataset_dir,  "TAU-urban-acoustic-scenes-2024-mobile-evaluation", "meta.csv")
 }
 
+class DIRAugmentDataset(TorchDataset):
+    """
+   Augments Waveforms with a Device Impulse Response (DIR)
+    """
+
+    def __init__(self, ds, dirs, prob):
+        self.ds = ds
+        self.dirs = dirs
+        self.prob = prob
+
+    def __getitem__(self, index):
+        x, file, label, device, city, logits = self.ds[index]
+
+        fsplit = file.rsplit("-", 1)
+        device = fsplit[1][:-4]
+
+        if device == 'a' and torch.rand(1) < self.prob:
+            # choose a DIR at random
+            dir_idx = int(np.random.randint(0, len(self.dirs)))
+            dir = self.dirs[dir_idx]
+
+            x = convolve(x, dir, 'full')[:, :x.shape[1]]
+            x = torch.from_numpy(x)
+        return x, file, label, device, city, logits
+
+    def __len__(self):
+        return len(self.ds)
+class AddLogitsDataset(TorchDataset):
+    """A dataset that loads and adds teacher logits to audio samples.
+    """
+
+    def __init__(self, dataset, map_indices, logits_file, temperature=2):
+        """
+        @param dataset: dataset to load data from
+        @param map_indices: used to get correct indices in list of logits
+        @param logits_file: logits file to load the teacher logits from
+        @param temperature: used in Knowledge Distillation, change distribution of predictions
+        return: x, file name, label, device, city, logits
+        """
+        self.dataset = dataset
+        if not os.path.isfile(logits_file):
+            print("Verify existence of teacher predictions.")
+            raise SystemExit
+        logits = torch.load(logits_file).float()
+        self.logits = logits
+        # self.logits = F.log_softmax(logits / temperature, dim=-1)
+        self.map_indices = map_indices
 
+    def __getitem__(self, index):
+        x, file, label, device, city = self.dataset[index]
+        return x, file, label, device, city, self.logits[self.map_indices[index]]
+
+    def __len__(self):
+        return len(self.dataset)
+
 class BasicDCASE24Dataset(TorchDataset):
     """
     Basic DCASE'24 Dataset: loads data from files
@@ -85,15 +148,29 @@ def __init__(self, dataset: TorchDataset, shift_range: int, axis=1):
         self.axis = axis
 
     def __getitem__(self, index):
-        x, file, label, device, city = self.dataset[index]
+        x, file, label, device, city, logits = self.dataset[index]
         sf = int(np.random.random_integers(-self.shift_range, self.shift_range))
-        return x.roll(sf, self.axis), file, label, device, city
+        return x.roll(sf, self.axis), file, label, device, city, logits
 
     def __len__(self):
         return len(self.dataset)
+def load_dirs(dirs_path, resample_rate):
+    all_paths = [path for path in pathlib.Path(os.path.expanduser(dirs_path)).rglob('*.wav')]
+    all_paths = sorted(all_paths)
+    all_paths_name = [str(p).rsplit("/", 1)[-1] for p in all_paths]
+
+    print("Augment waveforms with the following device impulse responses:")
+    for i in range(len(all_paths_name)):
+        print(i, ": ", all_paths_name[i])
 
+    def process_func(dir_file):
+        sig, _ = librosa.load(dir_file, sr=resample_rate, mono=True)
+        sig = torch.from_numpy(sig[np.newaxis])
+        return sig
 
-def get_training_set(split=100, roll=False):
+    return [process_func(p) for p in all_paths]
+
+def get_training_set(split=100, roll=False, dir_prob=0,resample_rate=44100):
     assert str(split) in ("5", "10", "25", "50", "100"), "Parameters 'split' must be in [5, 10, 25, 50, 100]"
     os.makedirs(dataset_config['split_path'], exist_ok=True)
     subset_fname = f"split{split}.csv"
@@ -104,6 +181,8 @@ def get_training_set(split=100, roll=False):
         print(f"Downloading file: {subset_fname}")
         download_url_to_file(subset_csv_url, subset_split_file)
     ds = get_base_training_set(dataset_config['meta_csv'], subset_split_file)
+    if dir_prob > 0:
+        ds = DIRAugmentDataset(ds, load_dirs(dataset_config['dirs_path'], resample_rate), dir_prob)
     if roll:
         ds = RollDataset(ds, shift_range=roll)
     return ds
@@ -115,6 +194,7 @@ def get_base_training_set(meta_csv, train_files_csv):
     train_subset_indices = list(meta[meta['filename'].isin(train_files)].index)
     ds = SimpleSelectionDataset(BasicDCASE24Dataset(meta_csv),
                                 train_subset_indices)
+    # ds = AddLogitsDataset(ds, train_subset_indices, dataset_config['logits_file'])
     return ds
 
 
@@ -169,5 +249,4 @@ def get_eval_set():
 
 def get_base_eval_set(meta_csv, eval_dir):
     ds = BasicDCASE24EvalDataset(meta_csv, eval_dir)
-    return ds
-
+    return ds