README.md

---
license: cc-by-nc-4.0
language:
- en
size_categories:
- 10K<n<100K
tags:
  - music
  - music recommendation
  - video-to-music retrieval
  - grounding
modality:
- video
- audio
- tabular
- text
formats:
  - csv
  - zip
configs:
- config_name: default
  data_files:
  - split: train
    path: "dataset/MGSV-EC/train_data.csv"
  - split: val
    path: "dataset/MGSV-EC/val_data.csv"
  - split: test
    path: "dataset/MGSV-EC/test_data.csv"
  zip_files:
  - path: "MGSV_feature.zip"
    description: "Pre-extracted features for video and music clips. Use hf_hub_download() to retrieve."
---
<h1 align="center">Music Grounding by Short Video E-commerce (MGSV-EC) Dataset</h1>



📄 [[Paper]](https://arxiv.org/abs/2408.16990v2)

📦 [[Feature File]](./MGSV_feature.zip) (or [Baidu drive](https://pan.baidu.com/s/1vfuBO47lq1VGt4yg3-Wjew) (P:5cbq) / [Google drive](https://drive.google.com/file/d/15xU9ml6MELN1_JZRftbaxIkHfmZ3bgx0/view?usp=drive_link))

🔧 [[PyTorch Dataloader]](./dataloader/dataloader_MGSV_EC_feature.py)

🧬 [[Model Code]](https://github.com/xxayt/MGSV)

---
## 📝 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

## 🚀 Quick Setup

To prepare and organize the dataset for local use, simply run the following code:

```python
import datasets
from huggingface_hub import hf_hub_download
import os
import zipfile

# Load dataset splits (CSV)
dataset_map = datasets.load_dataset("xxayt/MGSV-EC")

# Save splits locally
csv_dir = "dataset/MGSV-EC"  # specify your local directory
os.makedirs(csv_dir, exist_ok=True)
dataset_map["train"].to_csv(os.path.join(csv_dir, "train_data.csv"))
dataset_map["val"].to_csv(os.path.join(csv_dir, "val_data.csv"))
dataset_map["test"].to_csv(os.path.join(csv_dir, "test_data.csv"))

# see dataset_map["train"][0] for more details

# Download and extract pre-extracted features (ZIP)
zip_path = hf_hub_download(  # here may take ~13 minutes
    repo_id="xxayt/MGSV-EC",
    filename="MGSV_feature.zip",
    repo_type="dataset"
)
target_dir = "features"  # specify your local directory
os.makedirs(target_dir, exist_ok=True)
with zipfile.ZipFile(zip_path, "r") as zip_ref:
    zip_ref.extractall(target_dir)
```

- Final Directory Structure
```shell
.
├── dataset
│   └── MGSV-EC
│       ├── train_data.csv
│       ├── val_data.csv
│       └── test_data.csv
├── features
│   └── Kuai_feature
│       ├── ast_feature2p5/
│       └── vit_feature1/
└── README.md
```


## 📁 Data Format

Each row in the loaded 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., "Beauty", "Food"). |


## 🧩 Feature Directory Structure

For each video-music pair, we provide pre-extracted visual and audio features for efficient training in [Baidu drive](https://pan.baidu.com/s/1vfuBO47lq1VGt4yg3-Wjew) (P:5cbq) / [Google drive](https://drive.google.com/file/d/15xU9ml6MELN1_JZRftbaxIkHfmZ3bgx0/view?usp=drive_link) / [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


## 🔧 Demo Code for Sample Construction


```python
import os
import torch
import pandas as pd

def get_cw_propotion(gt_spans, max_m_duration):
    """
    Calculate the center and width proportions based on gt_spans and maximum music duration.

    Parameters:
        gt_spans: torch.Tensor of shape [1, 2], representing the start and end times of a music segment.
        max_m_duration: float, the maximum duration of the music.

    Returns:
        torch.Tensor of shape [1, 2], where the first column is the center proportion and the second is the width proportion.
    """
    # Clamp the end time to the maximum music duration
    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
    width_propotion = (gt_spans[:, 1] - gt_spans[:, 0]) / max_m_duration
    return torch.stack([center_propotion, width_propotion], dim=-1)

def get_data(data_csv_path, max_m_duration=240, frame_frozen_feature_path=None, music_frozen_feature_path=None):
    """
    Load CSV data and extract sample information.

    Parameters:
        data_csv_path: str, path to the CSV file.
        max_m_duration: float, maximum duration of the music.
        frame_frozen_feature_path: str, root directory for video features.
        music_frozen_feature_path: str, root directory for music features.

    Returns:
        List of dictionaries, each containing:
            - data_map: dict with loaded video and music features.
            - meta_map: dict with metadata information.
            - spans_target: torch.Tensor with target span proportions.
    """
    csv_data = pd.read_csv(data_csv_path)
    data_samples = []
    
    for idx in range(len(csv_data)):
        video_id = csv_data.loc[idx, 'video_id']
        music_id = csv_data.loc[idx, 'music_id']
        m_duration = float(csv_data.loc[idx, 'music_total_duration'])
        video_start_time = csv_data.loc[idx, 'video_start']
        video_end_time = csv_data.loc[idx, 'video_end']
        music_start_time = csv_data.loc[idx, 'music_start']
        music_end_time = csv_data.loc[idx, 'music_end']
        
        # Construct gt_windows and convert to torch.Tensor
        gt_windows = torch.tensor([[music_start_time, music_end_time]], dtype=torch.float)
        
        # Construct meta_map information
        meta_map = {
            "video_id": str(video_id),
            "music_id": str(music_id),
            "v_duration": torch.tensor(video_end_time - video_start_time, dtype=torch.float),
            "m_duration": torch.tensor(m_duration, dtype=torch.float),
            "gt_moment": gt_windows,
        }
        
        # Compute target span proportions, ensuring original gt_windows remains unchanged
        spans_target = get_cw_propotion(gt_windows.clone(), max_m_duration)
        
        # Load video features
        video_feature_path = os.path.join(frame_frozen_feature_path, 'vit_feature', f'{video_id}.pt')
        video_mask_path = os.path.join(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')
        # Apply mask to zero out invalid regions
        frame_feats = frame_feats.masked_fill(frame_mask.unsqueeze(-1) == 0, 0)
        
        # Load music features
        music_feature_path = os.path.join(music_frozen_feature_path, 'ast_feature', f'{music_id}.pt')
        music_mask_path = os.path.join(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)
        
        # Construct data_map information
        data_map = {
            "frame_feats": frame_feats,
            "frame_mask": frame_mask,
            "segment_feats": segment_feats,
            "segment_mask": segment_mask,
        }
        
        data_samples.append({
            "data_map": data_map,
            "meta_map": meta_map,
            "spans_target": spans_target
        })
    
    return data_samples

```



Note:
- These pre-extracted features are compatible with our released PyTorch dataloader, **see more details in [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 find this work useful, please cite the following paper:

```bibtex
@inproceedings{xin2025mgsv,
  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},
  booktitle={Proceedings of the IEEE/CVF International Conference on Computer Vision},
  year={2025}
}
```


## 📜 License
License: **CC BY-NC 4.0**
This work 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: [wangminquan@kuaishou.com](mailto:wangminquan@kuaishou.com).

📬 **Contact for Issues**
For any questions about this project (e.g., corrupted files or loading errors), please reach out at: [xinzijie@ruc.edu.cn](mailto:xinzijie@ruc.edu.cn)