Datasets:

SyMuPe
/

PianoCoRe

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) 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.

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:

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:

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:

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 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 / Dataset	CC BY-NC-SA 4.0
ASAP	Foscarin et al. (2020)	Paper / Dataset	CC BY-NC-SA 4.0
(n)ASAP	Peter et al. (2023)	Paper / Dataset	CC BY-NC-SA 4.0
ATEPP	Zhang et al. (2022)	Paper / Dataset	CC BY 4.0
GiantMIDI-Piano	Kong et al. (2022)	Paper / Dataset	CC BY 4.0
Aria-MIDI	Bradshaw and Colton (2025)	Paper / Dataset	CC BY-NC-SA 4.0
PERiScoPe	Borovik et al. (2025)	Paper / Dataset	CC BY-NC-SA 4.0
PDMX	Long et al. (2025)	Paper / Dataset	CC BY 4.0

Citation

If you use this dataset in your research, please cite:

@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}
}