| --- |
| license: cc-by-nc-sa-4.0 |
| task_categories: |
| - audio-classification |
| tags: |
| - music |
| - piano |
| - midi |
| - symbolic-music |
| - expressive-performance |
| - score-to-performance |
| pretty_name: PianoCoRe |
| size_categories: |
| - 100K<n<1M |
| source_datasets: |
| - extended |
| - original |
| configs: |
| - config_name: default |
| data_files: |
| - split: train |
| path: data/train-* |
| - split: test |
| path: data/test-* |
| dataset_info: |
| features: |
| - name: id |
| dtype: string |
| - name: composer |
| dtype: string |
| - name: composition |
| dtype: string |
| - name: movement |
| dtype: string |
| - name: performance_id |
| dtype: string |
| - name: split |
| dtype: string |
| - name: tier_b |
| dtype: bool |
| - name: tier_a |
| dtype: bool |
| - name: tier_a_star |
| dtype: bool |
| - name: score_dataset |
| dtype: string |
| - name: score_id |
| dtype: string |
| - name: score_xml_path |
| dtype: string |
| - name: score_midi_path |
| dtype: string |
| - name: score_note_count |
| dtype: float32 |
| - name: score_duration |
| dtype: float32 |
| - name: performance_dataset |
| dtype: string |
| - name: performance_midi_path |
| dtype: string |
| - name: performance_note_count |
| dtype: float32 |
| - name: performance_duration |
| dtype: float32 |
| - name: performer |
| dtype: string |
| - name: is_transcription |
| dtype: bool |
| - name: capture_model |
| dtype: string |
| - name: raw_alignment_path |
| dtype: string |
| - name: raw_recall |
| dtype: float32 |
| - name: raw_precision |
| dtype: float32 |
| - name: raw_adjusted_alignment_ratio |
| dtype: float32 |
| - name: is_duplicate |
| dtype: bool |
| - name: lead_performance |
| dtype: string |
| - name: quality_label |
| dtype: string |
| - name: prob_score |
| dtype: float32 |
| - name: prob_high_quality |
| dtype: float32 |
| - name: prob_low_quality |
| dtype: float32 |
| - name: prob_corrupted |
| dtype: float32 |
| - name: is_refined |
| dtype: bool |
| - name: refined_score_midi_path |
| dtype: string |
| - name: refined_score_note_count |
| dtype: float32 |
| - name: refined_score_duration |
| dtype: float32 |
| - name: refined_performance_midi_path |
| dtype: string |
| - name: refined_performance_note_count |
| dtype: float32 |
| - name: refined_performance_interpolated_note_count |
| dtype: float32 |
| - name: refined_performance_duration |
| dtype: float32 |
| - name: refined_alignment_path |
| dtype: string |
| - name: refined_recall |
| dtype: float32 |
| - name: score_xml_bytes |
| dtype: binary |
| - name: score_midi_bytes |
| dtype: binary |
| - name: performance_midi_bytes |
| dtype: binary |
| - name: raw_alignment_bytes |
| dtype: binary |
| - name: refined_score_midi_bytes |
| dtype: binary |
| - name: refined_performance_midi_bytes |
| dtype: binary |
| - name: refined_alignment_bytes |
| dtype: binary |
| --- |
| |
|
|
| # PianoCoRe: Combined and Refined Piano MIDI Dataset |
|
|
| **PianoCoRe** is a large-scale piano MIDI dataset that unifies and refines major open-source piano corpora. |
| It contains **250,046 performances** of **5,625 pieces** written by **483 composers**, totaling **21,763 hours** of performed music. |
|
|
| **PianoCoRe** provides the most diverse composer- and composition-annotated piano MIDI data. |
| The metadata includes deduplication flags, MIDI quality labels and precise note-level score-performance alignments. |
|
|
| The alignments are refined using a **Refined Alignment for Scores and Performances (RAScoP)** pipeline, integrated into the [Symbolic Music Performance modeling (SyMuPe)](https://github.com/ilya16/SyMuPe) Python package. |
| The pipeline ensures perfect note-by-note score-performance synchronization for expressive performance modeling. |
|
|
| ## Related Resources |
|
|
| * **TISMIR:** https://doi.org/10.5334/tismir.333 |
| * **arXiv:** https://arxiv.org/abs/2605.06627 |
| * **GitHub:** https://github.com/ilya16/PianoCoRe |
| * **Zenodo:** https://doi.org/10.5281/zenodo.19186016 |
|
|
| **Note**: This Hugging Face version stores data in compressed Parquet files with raw bytes. |
| If you prefer the original MIDI files in a directory structure, please use the [Zenodo Mirror](https://doi.org/10.5281/zenodo.19186016). |
|
|
| ## Dataset Tiers |
|
|
| | Dataset | Composers | Pieces | Performances | Hours | Scores | Alignments | |
| | --- | :---: | :---: | :---: | :---: | :---: | :---: | |
| | **PianoCoRe-C** | 483 | 5,625 | 250,046 | 21,763 | 75.3% | no | |
| | **PianoCoRe-B** | 478 | 5,591 | 214,092 | 18,757 | 75.0% | no | |
| | **PianoCoRe-A** | 151 | 1,591 | 157,207 | 12,509 | 100% | note | |
| | **PianoCoRe-A\*** | 137 | 1,517 | 130,275 | 10,330 | 100% | note | |
|
|
| To support different research applications, the dataset is organized into tiered subsets: |
|
|
| - **PianoCoRe-C (Combined):** a complete mixed-source piano performance collection. |
|
|
| *Applications*: piano performance analysis, data cleaning algorithms. |
| - **PianoCoRe-B (Base):** a deduplicated and quality-filtered subset. |
|
|
| *Applications*: large-scale pre-training, piano performance generation. |
| - **PianoCoRe-A (Aligned):** a subset containing performances aligned to score. |
|
|
| *Applications*: score-performance analysis, expressive piano performance rendering. |
| - **PianoCoRe-A\*:** a high quality subset of the best-quality performances and note-level alignments. |
| |
| *Applications*: expressive piano performance rendering, performance-to-score transcription. |
| |
| ## Quick Start |
| |
| Use the following example code to access the metadata: |
| ```python |
| from datasets import load_dataset |
| |
| # Load the train split of the PianoCoRe dataset (streaming mode) |
| dataset = load_dataset("SyMuPe/PianoCoRe", split="train", streaming=True) |
| |
| # Optionally drop heavy columns with bytes (e.g., MusicXML/MXL data) |
| # dataset = dataset.remove_columns(["score_xml_bytes"]) |
| |
| # Filter for high-confidence samples (PianoCoRe-A*) |
| dataset_a_star = dataset.filter(lambda x: x["tier_a_star"]) |
| |
| # Take one sample |
| sample = next(iter(dataset_a_star)) |
| print(f"ID: {sample['id']}") |
| print(f"Work: {sample['composer']} - {sample['composition']}" + (f" - {sample['movement']}" if sample["movement"] else "")) |
| print(f"Score: {sample['score_midi_path']}") |
| print(f"Performance: {sample['performance_midi_path']}\n") |
| ``` |
| |
| The **raw** MIDI data and alignments can be accessed using: |
| ```python |
| from symusic import Score |
| from symupe import Alignment |
| |
| # Load raw score and performance MIDI data |
| score_midi = Score.from_midi(sample["score_midi_bytes"]) if sample["score_midi_bytes"] is not None else None |
| performance_midi = Score.from_midi(sample["performance_midi_bytes"]) |
| print(f"Score MIDI: {score_midi}") |
| print(f"Performance MIDI: {performance_midi}") |
| |
| # Load raw alignment |
| if sample['raw_alignment_bytes'] is not None: |
| raw_alignment = Alignment.from_bytes(sample["raw_alignment_bytes"]) |
| print(f"Raw alignment: {len(raw_alignment)} total and {raw_alignment.num_full_pairs} matched pairs") |
| |
| # Save in a human-readable format |
| # raw_alignment.save("alignment.txt") |
| ``` |
| |
| The **refined** MIDI data and alignments can be accessed using: |
| ```python |
| import io |
| import numpy as np |
| from symusic import Score |
| |
| if sample["refined_performance_midi_bytes"] is not None: |
| # Load refined score and performance MIDI data |
| score_midi = Score.from_midi(sample["refined_score_midi_bytes"]) |
| performance_midi = Score.from_midi(sample["refined_performance_midi_bytes"]) |
| print(f"Refined Score MIDI: {score_midi}") |
| print(f"Refined Performance MIDI: {performance_midi}") |
| |
| # Load refined alignment |
| refined_alignment = np.load(io.BytesIO(sample["refined_alignment_bytes"])) |
| print(f"Refined Alignment:") |
| print(f" performance indices: {refined_alignment['perf_idx']}") |
| print(f" interpolation mask: {refined_alignment['interpolated']}") |
| ``` |
| --- |
|
|
| ## Dataset Metadata |
|
|
| The **PianoCoRe** metadata rows are organized using a natural sort based on performance MIDI paths. |
| The following fields are defined for each entry: |
|
|
| ### Core: |
|
|
| - **id** (string): unique sample ID (format: `PianoCoRe_XXXXXX`) |
| - **composer** (string): name of the composer (format: `[last_name],_[first_name]`) |
| - **composition** (string): title of the musical work/composition |
| - **movement** (string, optional): name of the specific movement/part of the composition |
| - **performance_id** (string): ID of the performance MIDI file, derived from the source dataset name and its internal ID |
| |
| ### Subsets: |
| |
| - **split** (string): dataset split (`train` or `test`) |
| - **tier_b** (bool): whether the performance is in the **PianoCoRe-B** subset (deduplicated and quality-filtered) |
| - **tier_a** (bool):whether the performance is in the **PianoCoRe-A** subset (note-aligned to scores) |
| - **tier_a_star** (bool): whether the performance is in the **PianoCoRe-A*** subset (highest-confidence alignments) |
| |
| ### Score: |
| |
| - **score_dataset** (string, optional): source dataset for the score MusicXML/MXL files (ASAP/ATEPP/PDMX/MuseScore) |
| - **score_id** (string, optional): ID of the score MIDI file, either as in the source dataset or built using the source dataset name and ID |
| - **score_xml_path** (string, optional): path to the score MusicXML/MXL file within the `raw/` directory |
| - **score_midi_path** (string, optional): path to the score MIDI file within the `raw/` directory |
| - **score_note_count** (integer, optional): number of notes in the score MIDI |
| - **score_duration** (float, optional): duration of the score MIDI in seconds |
|
|
| ### Performance: |
|
|
| - **performance_dataset** (string): source dataset of the performance MIDI |
| - **performance_midi_path** (string): path to the performance MIDI file within the `raw/` directory |
| - **performance_note_count** (integer): number of notes in the performance MIDI |
| - **performance_duration** (float): duration of the performance MIDI in seconds |
| - **performer** (string, optional) name of the pianist (if available) |
| - **is_transcription** (bool): whether the performance MIDI was transcribed from audio |
| - **capture_model** (string): hardware (e.g., Yamaha Disklavier) or ML model used to transcribe the MIDI |
|
|
| ### Raw alignment: |
|
|
| - **raw_alignment_path** (string, optional): path to the raw `_align.npz` score-performance alignment file within the `raw/` directory, contains indices, pitches and onset for score and performance notes |
| - **raw_recall** (float, optional): $R_a$, raw alignment recall |
| - **raw_precision** (float, optional): $P_a$, raw alignment precision |
| - **raw_adjusted_alignment_ratio** (float, optional): $R'_a$, raw alignment adjusted alignment ratio, defined as $R'_a = \max(P_a, R_a)$ |
| |
| ### Deduplication (PianoCoRe-B): |
| |
| - **is_duplicate** (bool): whether the performance is a near-duplicate of the other performance (`lead_performance`) |
| - **lead_performance** (string, optional): path to the main (higher priority) version for the duplicate performance MIDI |
| |
| ### Quality labels (PianoCoRe-B): |
| |
| - **quality_label** (string): MIDI quality label predicted by the classifier ('score', 'high quality', 'low quality' or 'corrupted') |
| - **prob_score** (float): classifier confidence for Score (S) MIDI quality class |
| - **prob_high_quality** (float): classifier confidence for High Quality (HQ) MIDI quality class |
| - **prob_low_quality** (float): classifier confidence for Low Quality (LQ) MIDI quality class |
| - **prob_corrupted** (float): classifier confidence for Corrupted (C) MIDI quality class |
|
|
| ### Refined score, performance and alignment (PianoCoRe-A/A*): |
| |
| - **is_refined** (bool): whether the performance MIDI was cleaned and refined |
| - **refined_score_midi_path** (string, optional): path to the refined (single-track) score MIDI file within the `refined/` directory |
| - **refined_score_note_count** (integer, optional): number of notes in the refined score MIDI |
| - **refined_score_duration** (float, optional): duration of the refined score MIDI in seconds |
| - **refined_performance_midi_path** (string, optional): path to the refined (note-by-note aligned) performance MIDI file within the `refined/` directory |
| - **refined_performance_note_count** (integer, optional): number of notes in the refined performance MIDI |
| - **refined_performance_interpolated_note_count** (integer, optional): number of synthetic notes added during the interpolation stage |
| - **refined_performance_duration** (float, optional): duration of the refined performance MIDI in seconds |
| - **refined_alignment_path** (string, optional): path to the `_refined_align.npz` score-performance alignment file within the `refined/` directory, contains performance indices and boolean interpolation mask |
| - **refined_recall** (float, optional): $R_{RAScoP}$, refined alignment recall |
| |
| ### Binary data: |
| - **score_xml_bytes** (binary, optional) raw data for the score MusicXML/MXL file |
| - **score_midi_bytes** (binary, optional) raw data for the score MIDI file |
| - **performance_midi_bytes** (binary): raw data for the performance MIDI file |
| - **raw_alignment_bytes** (binary, optional): raw data for the raw `.npz` alignment file |
| - **refined_score_midi_bytes** (binary, optional): raw data for the refined score MIDI file |
| - **refined_performance_midi_bytes** (binary, optional): raw data for the refined performance MIDI file |
| - **refined_alignment_bytes** (binary, optional): raw data for the refined `.npz` alignment file |
| |
| --- |
| |
| ## Ethical Statement |
| |
| The curation of large-scale symbolic datasets presents challenges regarding copyright and intellectual property. |
| A best-effort attempt was made to filter PianoCoRe according to European Union public-domain regulations (works whose authors have been deceased for more than 70 years). |
| |
| ## Licensing and Terms of Use |
| |
| The dataset, original and processed files, metadata, and alignment annotations are published under a **[CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/)** license. |
| The license respects the licenses used for the source datasets. The underlying MIDI transcriptions are provided strictly for **non-commercial research and educational purposes**. |
| |
| ## Acknowledgments |
| |
| PianoCoRe is built upon the invaluable contributions of the open music information retrieval community and existing open-source datasets. |
| Acknowledgements and credits are given to the creators of the following source corpora: |
| |
| | Dataset | Reference | Links | License | |
| | ------------------- | -------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------- | |
| | **MAESTRO** | Hawthorne et al. (2019) | [Paper](https://openreview.net/forum?id=r1lYRjC9F7) / [Dataset](https://magenta.withgoogle.com/datasets/maestro) | [CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/) | |
| | **ASAP** | Foscarin et al. (2020) | [Paper](https://archives.ismir.net/ismir2020/paper/000127.pdf) / [Dataset](https://github.com/fosfrancesco/asap-dataset) | [CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/) | |
| | **(n)ASAP** | Peter et al. (2023) | [Paper](https://transactions.ismir.net/articles/10.5334/tismir.149) / [Dataset](https://github.com/CPJKU/asap-dataset) | [CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/) | |
| | **ATEPP** | Zhang et al. (2022) | [Paper](https://archives.ismir.net/ismir2022/paper/000053.pdf) / [Dataset](https://github.com/tangjjbetsy/ATEPP) | [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/) | |
| | **GiantMIDI-Piano** | Kong et al. (2022) | [Paper](https://transactions.ismir.net/articles/10.5334/tismir.80) / [Dataset](https://github.com/bytedance/GiantMIDI-Piano) | [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/) | |
| | **Aria-MIDI** | Bradshaw and Colton (2025) | [Paper](https://openreview.net/forum?id=X5hrhgndxW) / [Dataset](https://github.com/loubbrad/aria-midi) | [CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/) | |
| | **PERiScoPe** | Borovik et al. (2025) | [Paper](https://dl.acm.org/doi/10.1145/3746027.3755871) / [Dataset](https://huggingface.co/datasets/SyMuPe/PERiScoPe) | [CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/) | |
| | **PDMX** | Long et al. (2025) | [Paper](https://ieeexplore.ieee.org/document/10890217) / [Dataset](https://github.com/pnlong/PDMX/) | [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/) | |
| |
| ## Citation |
| |
| If you use this dataset in your research, please cite: |
| |
| ```bibtex |
| @article{borovik2026pianocore, |
| title={{PianoCoRe: Combined and Refined Piano MIDI Dataset}}, |
| author={Borovik, Ilya}, |
| journal={Transactions of the International Society for Music Information Retrieval}, |
| volume={9}, |
| number={1}, |
| pages={144--163}, |
| year={2026}, |
| doi={10.5334/tismir.333} |
| } |
| ``` |
