LOG: DVS Dataset Version 1.0

.gitignore

@@ -0,0 +1 @@
+test/dog

README.md

@@ -6,11 +6,11 @@ tags:
 - biology
 - dog
 - audio
+task_categories:
+- audio-to-audio
 ---
 
-# Dataset
-
-You can download the DVS dataset from [here](https://huggingface.co/datasets/ArlingtonCL2/Dog-Vocal-Separation).
+# [Dataset] Dog Vocal Separation
 
 ## Overview
 
@@ -33,18 +33,34 @@ You can download the DVS dataset from [here](https://huggingface.co/datasets/Arl
 │   └── mixture
 │       └── ...
 └── test
+    ├── test_pairs.csv
     └── mixture
         └── ...
 ```
 
+The CSV files (`train_pairs.csv`, `val_pairs.csv`, and `test_pairs.csv`) contain pairs of (dog, mixture) in their rows. For instance, (`6357ca529eec8ca42a1fa588e0725904.wav`, `f046b186c4def7428cd627ae98d1762d.wav`) is a pair of (dog, mixture) written at `train_pairs.csv`.
+
+The dataset uploaded on HuggingFace is splitted into `subdir`s, since the number of files is only allowed up to 10,000 in a single directory. To make the the dataset hierarchy like the original one, you can use the given script;
+
+``` bash
+$ ./post_download.py train/dog
+```
+
 ## Description
 
 Pairs of the 10-second mixed sound and its ground truth dog vocal are given in a train set. Only sound mixtures are provided in a test set. Participants are expected to produce 10-second dog barks as their output.
 
-The total length of the train, validation, and test sets are about 348, 46, and 32 hours, respectively. In other words, 125,476 pairs for mixtures and ground truths are in the train set. 16,830 pairs and 11,550 pairs for validation and test set as well.
+The total length of the train, validation, and test sets are about 348, 46, and 8 hours, respectively. In other words, 125,476 pairs for mixtures and ground truths are in the train set. 16,830 pairs and 3,000 pairs for validation and test set as well.
 
 Pure dog barks come from a previous work [1] which are originally about 1-2 seconds long on average. These are padded to 10 seconds long. Background noises are strategically selected from AudioSet [2] to mix with the dog barks. Dog barks and noises are combined in different permutations, while ensuring that no single dog's vocal data exists in more than one of the sets above, to avoid information leak.
 
+## Challenge Notice
+
+1. All audios are sampled at 32,000 kHz. Make sure your submission is also sampled at 32,000 kHz.
+2. Named your submission audios with the `test_pairs.csv`. The csv file contains corresponding the dog filename from the mixture. For instance, if the original filename was `16a4168a678743ce0f23c70f89d9170b.wav` in the test set, your prediction should be `97677e409040b54a21fdec623557bb2b.wav`.
+3. Only `test_pairs.csv` have a `split` column to indicate the public and private in a submission. Participants do not need to use this column.
+3. SI-SDR will be calculated using the [si_sdr.py](./si_sdr.py) script.
+
 ## References
 
 [1] Wang, T., Li, X., Zhang, C., Wu, M., & Zhu, K. (2024, November). Phonetic and Lexical Discovery of Canine Vocalization. In *Findings of the Association for Computational Linguistics: EMNLP 2024* (pp. 13972-13983).

post_download.py

@@ -0,0 +1,67 @@
+#!python
+import os
+import shutil
+import argparse
+
+def combine_split_files(base_dir, subdir_prefix="subdir_"):
+    """
+    Moves all files from subdirectories (whose names start with subdir_prefix)
+    back to the base directory.
+
+    Args:
+        base_dir (str): Path to the base directory containing split subdirectories.
+        subdir_prefix (str): Prefix used for subdirectories created during split.
+                              Default is "subdir_".
+    """
+    # List items in the base directory
+    items = os.listdir(base_dir)
+    combined_count = 0
+
+    for item in items:
+        sub_dir_path = os.path.join(base_dir, item)
+        # Process only directories with the given prefix
+        if os.path.isdir(sub_dir_path) and item.startswith(subdir_prefix):
+            print(f"Processing directory: {sub_dir_path}")
+            for file_name in os.listdir(sub_dir_path):
+                src_file = os.path.join(sub_dir_path, file_name)
+                dst_file = os.path.join(base_dir, file_name)
+                # If a file with the same name already exists, handle it (here we skip)
+                if os.path.exists(dst_file):
+                    print(f"Warning: {dst_file} already exists. Skipping {src_file}.")
+                    continue
+                try:
+                    shutil.move(src_file, dst_file)
+                    combined_count += 1
+                except Exception as e:
+                    print(f"Error moving {src_file} to {dst_file}: {e}")
+            # After moving, attempt to remove the now-empty subdirectory
+            try:
+                os.rmdir(sub_dir_path)
+                print(f"Removed directory: {sub_dir_path}")
+            except Exception as e:
+                print(f"Could not remove directory {sub_dir_path}: {e}")
+
+    print(f"\nCombined {combined_count} files into {base_dir}.")
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Rollback split files by moving files from split subdirectories back into the base directory."
+    )
+    parser.add_argument("base_dir", help="Base directory containing the split subdirectories")
+    parser.add_argument(
+        "--prefix",
+        default="subdir_",
+        help="Prefix of the split subdirectories (default: 'subdir_')"
+    )
+    args = parser.parse_args()
+
+    # Validate the base directory exists
+    if not os.path.isdir(args.base_dir):
+        print(f"Error: {args.base_dir} is not a valid directory.")
+        return
+
+    combine_split_files(args.base_dir, args.prefix)
+
+if __name__ == "__main__":
+    main()
+

prepare_upload.py

@@ -0,0 +1,72 @@
+#!python3
+import os
+import math
+import argparse
+
+def split_directory(base_dir, max_files=10000, prefix="subdir_"):
+    """
+    Splits the files in the given base directory into multiple subdirectories,
+    each containing at most 'max_files' files.
+
+    Args:
+        base_dir (str): The directory containing the files to be split.
+        max_files (int): Maximum number of files allowed per subdirectory.
+                         Defaults to 10000.
+        prefix (str): Prefix for the names of the created subdirectories.
+                      Defaults to "subdir_".
+    """
+    # Get a sorted list of only the files in the base directory
+    files = [f for f in sorted(os.listdir(base_dir)) if os.path.isfile(os.path.join(base_dir, f))]
+    total_files = len(files)
+    num_subdirs = math.ceil(total_files / max_files)
+
+    if total_files == 0:
+        print("No files found in the provided base directory.")
+        return
+
+    print(f"Found {total_files} files in {base_dir}. Creating {num_subdirs} subdirectories...")
+
+    for i in range(num_subdirs):
+        # Create subdirectory name (e.g., subdir_0, subdir_1, etc.)
+        subdir_name = f"{prefix}{i}"
+        subdir_path = os.path.join(base_dir, subdir_name)
+        os.makedirs(subdir_path, exist_ok=True)
+
+        # Determine the start and end indices for the files of this subdirectory
+        start_index = i * max_files
+        end_index = min(start_index + max_files, total_files)
+
+        # Move each file from the base directory to the subdirectory
+        for file in files[start_index:end_index]:
+            src_path = os.path.join(base_dir, file)
+            dst_path = os.path.join(subdir_path, file)
+            try:
+                os.rename(src_path, dst_path)
+            except Exception as e:
+                print(f"Error moving {src_path} to {dst_path}: {e}")
+
+        print(f"Moved files {start_index} to {end_index - 1} into {subdir_path}")
+
+    print(f"\nSuccessfully moved {total_files} files into {num_subdirs} subdirectories.")
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Split a directory with many files into subdirectories with a maximum file count per subdirectory."
+    )
+    parser.add_argument("base_dir", help="The base directory containing the files to split.")
+    parser.add_argument("--max-files", type=int, default=10000,
+                        help="Maximum number of files per subdirectory (default: 10000).")
+    parser.add_argument("--prefix", default="subdir_",
+                        help="Prefix for the created subdirectories (default: 'subdir_').")
+
+    args = parser.parse_args()
+
+    # Validate that the provided base directory exists
+    if not os.path.isdir(args.base_dir):
+        parser.error(f"Error: {args.base_dir} is not a valid directory.")
+
+    split_directory(args.base_dir, args.max_files, args.prefix)
+
+if __name__ == "__main__":
+    main()
+

si_sdr.py

@@ -0,0 +1,68 @@
+import torch
+
+
+def _normalize(tensor: torch.Tensor, eps=1e-10) -> torch.Tensor:
+    """
+    Helper function to normalize a tensor
+    Args:
+        tensor (torch.Tensor): input tensor
+        eps (float): small value to avoid division by zero
+    Returns:
+        normalized_tensor (torch.Tensor): normalized tensor
+    """
+    norm = torch.norm(tensor, dim=-1, keepdim=True)
+    normalized_tensor = tensor / (norm + eps)
+    return normalized_tensor
+
+
+def _calculate_alpha(preds, targets, eps=1e-10) -> torch.Tensor:
+    """
+    Helper function to calculate alpha
+    Args:
+        preds (torch.Tensor): predicted sources
+        targets (torch.Tensor): target sources
+        eps (float): small value to avoid division by zero
+    Returns:
+        alpha (torch.Tensor): alpha value
+    """
+    dot = torch.sum(preds * targets, dim=-1, keepdim=True)
+    target_energy = torch.sum(targets**2, dim=-1, keepdim=True)
+    alpha = (dot + eps) / (target_energy + eps)
+    return alpha
+
+
+def _calculate_metric(numerator, denominator, eps=1e-10) -> torch.Tensor:
+    """
+    Helper function to calculate sdr and its variants
+    Args:
+        numerator (torch.Tensor): numerator tensor
+        denominator (torch.Tensor): denominator tensor
+        eps (float): small value to avoid division by zero
+    Returns:
+        dB (torch.Tensor): dB value
+    """
+    numerator = torch.sum(numerator, dim=-1) + eps
+    denominator = torch.sum(denominator, dim=-1) + eps
+    dB = 10 * torch.log10(numerator / denominator)
+    return dB
+
+
+def si_sdr(preds, targets, eps=1e-10) -> torch.Tensor:
+    """
+    Scale Invariant Signal Distortion Ratio (SI-SDR) metric
+    Args:
+        preds (torch.Tensor): predicted sources. (batch, time)
+        targets (torch.Tensor): target sources. (batch, time)
+        eps (float): small value to avoid division by zero
+    Returns:
+        si_sdr (torch.Tensor): SI-SDR value
+    """
+    preds = _normalize(preds, eps=eps)
+    targets = _normalize(targets, eps=eps)
+
+    alpha = _calculate_alpha(preds, targets, eps=eps)
+
+    # compute SI-SDR (in dB)
+    numerator = torch.square(alpha * targets)
+    denominator = torch.square(preds - alpha * targets)
+    return _calculate_metric(numerator, denominator, eps=eps)