update

README.md

@@ -1,3 +1,130 @@
----
-license: mit
----
+---
+license: CC BY-NC 4.0
+---
+
+
+## Music Grounding by Short Video E-commerce (MGSV-EC) Dataset
+
+📄 [[Paper]](https://arxiv.org/abs/2408.16990v2)
+
+
+### 📝 Dataset Summary
+
+**MGSV-EC** is a large-scale dataset for the new task of **Music Grounding by Short Video (MGSV)**, which aims to localize a specific music segment that best serves as the background music (BGM) for a given query short video.  
+Unlike traditional video-to-music retrieval (V2MR), MGSV requires both identifying the relevant music track and pinpointing a precise moment from the track.
+
+The dataset contains **53,194 short e-commerce videos** paired with **35,393 music moments**, all derived from **4,050 unique music tracks**. It supports evaluation in two modes:
+
+- **Single-music Grounding (SmG)**: the relevant music track is known, and the task is to detect the correct segment.
+- **Music-set Grounding (MsG)**: the model must retrieve the correct music track and its corresponding segment.
+
+
+### 📐 Evaluation Protocol
+
+| Mode           | Sub-task               | Metric                                              |
+|:--------------|:----------------------|:-------------------------------------------------|
+| *Single-music* | Grounding (SmG)   | mIoU                                                |
+| *Music-set*    | Video-to-Music Retrieval (V2MR)     | R$k$   |
+| *Music-set*    | Grounding (MsG)     | MoR$k$ |
+
+
+
+---
+
+### 📊 Dataset Statistics
+
+| **Split**   | **#Music Tracks** | *Avg. Music Duration(sec)* | #Query Videos | *Avg. Video Duration(sec)* | **#Moments** |
+|---------|----------------|----------------------|---------|----------------------|-----------|
+| Total | 4,050      | 138.9 ± 69.6 | 53,194 | 23.9 ± 10.7 | 35,393 |
+| *Train*   | 3,496          | 138.3 ± 69.4     | 49,194  | 24.0 ± 10.7     | 31,660    |
+| *Val*     | 2,000          | 139.6 ± 70.0     | 2,000   | 22.8 ± 10.8     | 2,000     |
+| *Test*    | 2,000          | 139.9 ± 70.1     | 2,000   | 22.6 ± 10.7     | 2,000     |
+
+- 🎵 Music type ratio: **~60% songs**, **~40% instrumental**
+- 📹 Frame rate: 34 FPS; resolution: 1080×1920
+
+
+
+### 📁 Data Format
+
+Each row in the CSV file represents a query video paired with a music track and a localized music moment. The meaning of each column is as follows:
+
+| Column Name |	Description |
+|:-------------|--------------|
+| video_id	| Unique identifier for the short query video. |
+| music_id	| Unique identifier for the associated music track. |
+| video_start	| Start time of the video segment in full video. |
+| video_end	| End time of the video segment in full video. |
+| music_start	| Start time of the music segment in full track. |
+| music_end	| End time of the music segment in full track. |
+| music_total_duration	| Total duration of the music track. |
+| video_segment_duration	| Duration of the video segment. |
+| music_segment_duration	| Duration of the music segment. |
+| music_path	| Relative path to the music track file. |
+| video_total_duration	| Total duration of the video. |
+| video_width	| Width of the video frame. |
+| video_height	| Height of the video frame. |
+| video_total_frames	| Total number of frames in the video. |
+| video_frame_rate	| Frame rate of the video. |
+| video_category	| Category label of the video content (e.g., "美妆", "美食"). |
+
+
+
+### 🧩 Feature Directory Structure
+
+For each video-music pair, we provide pre-extracted visual and audio features for efficient training in [MGSV_feature.zip](./MGSV_feature.zip). The features are stored in the following directory structure:
+
+```shell
+[Your data feature path]
+.
+├── ast_feature2p5
+│   ├── ast_feature/      # Audio segment features extracted by AST (Audio Spectrogram Transformer)
+│   └── ast_mask/         # Segment-level masks indicating valid audio positions
+└── vit_feature1
+    ├── vit_feature/      # Frame-level visual features extracted by CLIP-ViT (ViT-B/32)
+    └── vit_mask/         # Frame-level masks indicating valid visual positions
+```
+Each .pt file corresponds to a single sample and includes:
+- frame_feats: shape `[B, max_v_frames, 512]`
+- frame_masks: shape `[B, max_v_frames]`, where 1 indicates valid frames, 0 for padding, used for padding control during batching
+- segment_feats: shape `[B, max_snippet_num, 768]`
+- segment_masks: shape `[B, max_snippet_num]`, indicating valid audio segments
+
+Note:
+- These pre-extracted features are compatible with our released PyTorch dataloader [dataloader_MGSV_EC_feature.py](./dataloader/dataloader_MGSV_EC_feature.py).
+- Feature file paths are not stored in the CSV. Instead, users should specify the base directories via the following arguments:
+  - frame_frozen_feature_path: `[Your data feature path]/vit_feature1`
+  - music_frozen_feature_path: `[Your data feature path]/ast_feature2p5`
+
+
+
+
+
+---
+
+### 📖 Citation
+
+If you use this dataset in your research, please cite:
+
+```bibtex
+@article{xin2024mgsv,
+  title={Music Grounding by Short Video},
+  author={Xin, Zijie and Wang, Minquan and Liu, Jingyu and Chen, Quan and Ma, Ye and Jiang, Peng and Li, Xirong},
+  journal={arXiv preprint arXiv:2408.16990},
+  year={2024}
+}
+```
+
+### 📜 License
+
+License: **CC BY-NC 4.0**
+It is intended **for non-commercial academic research and educational purposes only**.  
+For commercial licensing or any use beyond research, please contact the authors.
+
+📥 **Raw Vidoes/Music-tracks Access**  
+The raw video and music files are not publicly available due to copyright and privacy constraints.  
+Researchers interested in obtaining the full media content can contact **Kuaishou Technology** at: [[email protected]](mailto:[email protected]).
+
+📬 **Contact for Issues**
+For any dataset-related questions or problems (e.g., corrupted files or loading errors), please reach out to: [[email protected]](mailto:[email protected])
+

dataloader/data_dataloaders_feature.py

@@ -0,0 +1,72 @@
+import torch
+from torch.utils.data import DataLoader
+from dataloaders.dataloader_MGSV_EC_feature import MGSV_EC_DataLoader
+
+
+def dataloader_MGSV_EC_train(args):
+    MGSV_EC_trainset = MGSV_EC_DataLoader(
+        csv_path=args.train_csv,
+        args=args,
+    )
+    train_sampler = torch.utils.data.distributed.DistributedSampler(MGSV_EC_trainset, num_replicas=args.world_size, rank=args.rank)
+    dataloader = DataLoader(
+        MGSV_EC_trainset,
+        batch_size=args.batch_size_train // args.gpu_num,
+        num_workers=args.num_workers,
+        shuffle=(train_sampler is None),
+        sampler=train_sampler,
+        drop_last=True,
+        pin_memory=True,
+    )
+    return dataloader, len(MGSV_EC_trainset), train_sampler
+
+def dataloader_MGSV_EC_val(args):
+    MGSV_EC_valset = MGSV_EC_DataLoader(
+        csv_path=args.val_csv,
+        args=args,
+    )
+    val_sampler = torch.utils.data.distributed.DistributedSampler(MGSV_EC_valset, num_replicas=args.world_size, rank=args.rank)
+    dataloader = DataLoader(
+        MGSV_EC_valset,
+        batch_size=args.batch_size_val // args.gpu_num,
+        num_workers=args.num_workers,
+        shuffle=(val_sampler is None),
+        sampler=val_sampler,
+        drop_last=False,
+    )
+    return dataloader, len(MGSV_EC_valset), val_sampler
+
+def dataloader_MGSV_EC_test(args):
+    MGSV_EC_testset = MGSV_EC_DataLoader(
+        csv_path=args.val_csv,
+        args=args,
+    )
+    test_sampler = torch.utils.data.distributed.DistributedSampler(MGSV_EC_testset, num_replicas=args.world_size, rank=args.rank)
+    dataloader = DataLoader(
+        MGSV_EC_testset,
+        batch_size=args.batch_size_val // args.gpu_num,
+        num_workers=args.num_workers,
+        shuffle=(test_sampler is None),
+        sampler=test_sampler,
+        drop_last=False,
+    )
+    return dataloader, len(MGSV_EC_testset), test_sampler
+
+
+
+DATALOADER_DICT = {}
+DATALOADER_DICT["kuai50k_uni"] = {
+    "train": dataloader_MGSV_EC_train,
+    "val": dataloader_MGSV_EC_val,
+    "test": dataloader_MGSV_EC_test
+}
+# DATALOADER_DICT["kuai50k_vmr"] = {
+#     "train": dataloader_MGSV_EC_train,
+#     "val": dataloader_MGSV_EC_val,
+#     "test": dataloader_MGSV_EC_test
+# }
+# DATALOADER_DICT["kuai50k_mr"] = {
+#     "train": dataloader_MGSV_EC_train,
+#     "val": dataloader_MGSV_EC_val,
+#     "test": dataloader_MGSV_EC_test
+# }

dataloader/dataloader_MGSV_EC_feature.py

@@ -0,0 +1,75 @@
+import os
+from torch.utils.data import Dataset
+import torch
+import pandas as pd
+
+class MGSV_EC_DataLoader(Dataset):
+    def __init__(
+            self,
+            csv_path,
+            args=None,
+    ):
+        self.args = args
+        self.csv_data = pd.read_csv(csv_path)
+    
+    def __len__(self):
+        return len(self.csv_data)
+
+    def get_cw_propotion(self, gt_spans, max_m_duration):
+        '''
+        Inputs:
+            gt_spans: [1, 2]
+            max_m_duration: float
+        '''
+        gt_spans[:, 1] = torch.clamp(gt_spans[:, 1], max=max_m_duration)
+        center_propotion = (gt_spans[:, 0] + gt_spans[:, 1]) / 2.0 / max_m_duration  # [1]
+        width_propotion = (gt_spans[:, 1] - gt_spans[:, 0]) / max_m_duration  # [1]
+        return torch.stack([center_propotion, width_propotion], dim=-1)  # [1, 2]
+
+    def __getitem__(self, idx):
+        # id
+        video_id = self.csv_data['video_id'].to_numpy()[idx]
+        music_id = self.csv_data['music_id'].to_numpy()[idx]
+        # duration
+        # v_duration = self.csv_data['video_total_duration'].to_numpy()[idx]
+        m_duration = self.csv_data['music_total_duration'].to_numpy()[idx]
+        m_duration = float(m_duration)
+        # video moment st, ed
+        video_start_time = self.csv_data['video_start'].to_numpy()[idx]
+        video_end_time = self.csv_data['video_end'].to_numpy()[idx]
+        # music moment
+        music_start_time = self.csv_data['music_start'].to_numpy()[idx]
+        music_end_time = self.csv_data['music_end'].to_numpy()[idx]
+        gt_windows_list = [(music_start_time, music_end_time)]
+        gt_windows = torch.Tensor(gt_windows_list)  # [1, 2]
+        # time map
+        meta_map = {
+            "video_id": str(video_id),
+            "music_id": str(music_id),
+            "v_duration": torch.tensor(video_end_time - video_start_time),
+            "m_duration": torch.tensor(m_duration),
+            "gt_moment": gt_windows,  # [1, 2]
+        }
+        # target spans
+        spans_target = self.get_cw_propotion(gt_windows, self.args.max_m_duration)  # [1, 2]
+
+        # extract features
+        video_feature_path = os.path.join(self.args.frame_frozen_feature_path, 'vit_feature', f'{video_id}.pt')
+        video_mask_path = os.path.join(self.args.frame_frozen_feature_path, 'vit_mask', f'{video_id}.pt')
+        frame_feats = torch.load(video_feature_path, map_location='cpu')
+        frame_mask = torch.load(video_mask_path, map_location='cpu')
+        frame_feats = frame_feats.masked_fill(frame_mask.unsqueeze(-1) == 0, 0)  # [bs, max_frame_num, 512]
+
+        music_feature_path = os.path.join(self.args.music_frozen_feature_path, 'ast_feature', f'{music_id}.pt')
+        music_mask_path = os.path.join(self.args.music_frozen_feature_path, 'ast_mask', f'{music_id}.pt')
+        segment_feats = torch.load(music_feature_path, map_location='cpu')
+        segment_mask = torch.load(music_mask_path, map_location='cpu')  
+        segment_feats = segment_feats.masked_fill(segment_mask.unsqueeze(-1) == 0, 0)  # [bs, max_snippet_num, 768]
+
+        data_map = {
+            "frame_feats": frame_feats,
+            "frame_mask": frame_mask,
+            "segment_feats": segment_feats,
+            "segment_mask": segment_mask,
+        }
+        return data_map, meta_map, spans_target