diff --git a/evaluation_function/compare_MIDI.py b/evaluation_function/compare_MIDI.py index 98302a2..445aefb 100644 --- a/evaluation_function/compare_MIDI.py +++ b/evaluation_function/compare_MIDI.py @@ -17,6 +17,7 @@ import numpy as np +from collections import Counter # Default thresholds / parameters # Teachers can override any of these via the params dict in evaluation_function. @@ -94,12 +95,14 @@ def identify_chord_name(notes): def compute_chord_accuracy(ref_notes, res_notes): """ - Compute the chord accuracy score A from (Devaney, n.d.): + Compute the chord accuracy score A (modified Devaney's method), but + use the actual MIDI pitch (with octave) instead of pitch class, + so that the score is sensitive to octave errors.: A = (C - I + |y|) / (2 * |y|) where: - C = |y ∩ y_hat| (correctly played pitch classes) - I = |y_hat - y| (unexpected pitch classes played) - |y| (number of pitch classes in the reference chord) + C = number of correctly matched notes + I = number of extra notes + |y| = number of notes in the reference chord A = 1.0 means perfectly correct. A = 0.0 means nothing correct and many unexpected notes are played. @@ -109,28 +112,43 @@ def compute_chord_accuracy(ref_notes, res_notes): Returns: accuracy: float in [0, 1] - correct_pitches: sorted list of pitch class ints in both chords - missing_pitches: sorted list of pitch class ints in ref - extra_pitches: sorted list of pitch class ints in response + correct_pitches: sorted list of matched MIDI pitches + missing_pitches: sorted list of missing MIDI pitches + extra_pitches: sorted list of extra MIDI pitches """ - ref_pcs = get_pitch_class_set(ref_notes) - res_pcs = get_pitch_class_set(res_notes) - - correct_pcs = ref_pcs & res_pcs - missing_pcs = ref_pcs - res_pcs - extra_pcs = res_pcs - ref_pcs - - C = len(correct_pcs) - I = len(extra_pcs) - ref_size = len(ref_pcs) - + ref_counts = Counter(note["pitch"] for note in ref_notes) + res_counts = Counter(note["pitch"] for note in res_notes) + + correct_pitches = [] + missing_pitches = [] + extra_pitches = [] + + # For every distinct pitch on either side, match up copies one-to-one. + # Any leftover ref copies are missing; any leftover res copies are extra. + all_pitches = sorted(set(ref_counts) | set(res_counts)) + for pitch in all_pitches: + matched = min(ref_counts[pitch], res_counts[pitch]) + correct_pitches.extend([pitch] * matched) + if ref_counts[pitch] > matched: + missing_pitches.extend( + [pitch] * (ref_counts[pitch] - matched) + ) + if res_counts[pitch] > matched: + extra_pitches.extend( + [pitch] * (res_counts[pitch] - matched) + ) + + C = len(correct_pitches) + I = len(extra_pitches) + ref_size = len(ref_notes) # total note count, repeats included + if ref_size == 0: accuracy = 0.0 else: accuracy = (C - I + ref_size) / (2.0 * ref_size) accuracy = max(0.0, min(1.0, accuracy)) - - return accuracy, sorted(correct_pcs), sorted(missing_pcs), sorted(extra_pcs) + + return accuracy, correct_pitches, missing_pitches, extra_pitches # Step 0 - make first note start at t = 0.0 @@ -150,16 +168,15 @@ def normalize_start_times(notes): if not notes: return [] - first_start = notes[0]["start"] + # Use the earliest onset rather than assuming notes[0] is the first note. + first_start = min(note["start"] for note in notes) shifted_notes = [] for note in notes: - # Create a copy of the note dict with the "start" time shifted - note_copy = { - "pitch": note["pitch"], - "start": note["start"] - first_start, - "duration": note["duration"], - } + # Copy the complete dictionary so that additional metadata is retained. + note_copy = note.copy() + # Only modify the copied note's start time. + note_copy["start"] = note["start"] - first_start shifted_notes.append(note_copy) return shifted_notes @@ -246,86 +263,89 @@ def group_notes_into_events(notes, chord_onset_window=DEFAULT_CHORD_ONSET_WINDOW # Step 1 -- edit-distance alignment to identify missing/extra notes and pitch errors # ------------------------------------------------------------------------------ -def compute_note_cost(note1, note2): +def build_cost_matrix(response_events, ref_events, gap_penalty=DEFAULT_GAP_PENALTY): """ - Cost of aligning (replacing) one note with another, based on pitch. - - cost = 0: pitches are identical (a 'match'). - cost > 0: different pitches (a 'replacement') - + Precompute the full (N x M) event-alignment cost matrix using vectorised + NumPy broadcasting, instead of compute event cost one at a + time inside a Python loop. This also removes the redundant cost + computation that used to happen a second time during backtracking. + Args: - note1: dict with keys "pitch" (int), "start" (float), "duration" (float) - note2: dict with keys "pitch" (int), "start" (float), "duration" (float) - + response_events: list of event dicts (from group_notes_into_events) + ref_events: list of event dicts (from group_notes_into_events) + gap_penalty: cost used when event types (note vs chord) do not match + Returns: - int: cost value >= 0 (lower means more similar pitch) + numpy array of shape (N, M): cost of aligning each response event + to each reference event. """ - return int(abs(note1["pitch"] - note2["pitch"])) + N = len(response_events) + M = len(ref_events) + # Build simple per-event arrays: is this event a chord, and (if it is a + # single note) what is its pitch. + res_is_chord = np.array([event["event_type"] == "chord" for event in response_events]) + ref_is_chord = np.array([event["event_type"] == "chord" for event in ref_events]) + + res_pitch = np.array([ + event["notes"][0]["pitch"] if event["event_type"] == "note" else 0 + for event in response_events + ]) + ref_pitch = np.array([ + event["notes"][0]["pitch"] if event["event_type"] == "note" else 0 + for event in ref_events + ]) + + # Note-vs-note cost: vectorised absolute pitch difference for every pair. + # Shape (N, 1) - shape (1, M) broadcasts to (N, M) + note_cost_matrix = np.abs(res_pitch.reshape(N, 1) - ref_pitch.reshape(1, M)) + + # Chord-vs-chord cost: build a 12-dim binary pitch-class vector per chord, + # then compute Hamming distance for every pair using broadcasting. + res_pitch_vector = np.zeros((N, 12), dtype=int) + for i in range(N): + if res_is_chord[i]: + for note in response_events[i]["notes"]: + res_pitch_vector[i, note["pitch"] % 12] = 1 + + ref_pitch_vector = np.zeros((M, 12), dtype=int) + for j in range(M): + if ref_is_chord[j]: + for note in ref_events[j]["notes"]: + ref_pitch_vector[j, note["pitch"] % 12] = 1 + + # (N, 1, 12) vs (1, M, 12) broadcasts to (N, M, 12); summing the last + # axis gives the Hamming distance for every (response, ref) pair at once. + differs = res_pitch_vector.reshape(N, 1, 12) != ref_pitch_vector.reshape(1, M, 12) + chord_cost_matrix = differs.sum(axis=2) + + # Type-mismatch mask: True where one side is a note and the other a chord. + type_mismatch = res_is_chord.reshape(N, 1) != ref_is_chord.reshape(1, M) + both_chords = res_is_chord.reshape(N, 1) & ref_is_chord.reshape(1, M) + + # Combine the three cases -- np.where(condition, true, false) + cost_matrix = np.where( + type_mismatch, + gap_penalty, + np.where(both_chords, chord_cost_matrix, note_cost_matrix), + ) -def compute_event_cost(event1, event2, gap_penalty=DEFAULT_GAP_PENALTY): - """ - Cost of aligning (substituting) one event with another. - - Rules: - - note vs note: absolute pitch difference - - chord vs chord: Hamming distance on 12-dim pitch class binary vectors - - note vs chord (type mismatch): return gap_penalty so the aligner - treats them as unaligned (insertion + deletion is preferred) - - For chord vs chord, the Hamming distance counts how many of the 12 - pitch classes differ between the two chords (symmetric difference size). - - Args: - event1: event dict (from group_notes_into_events) - event2: event dict (from group_notes_into_events) - gap_penalty: cost of an unaligned event; used as the type-mismatch cost - - Returns: - int: alignment cost >= 0 - """ - type1 = event1["event_type"] - type2 = event2["event_type"] - - # Type mismatch: note vs chord or chord vs note. - # Return gap_penalty so alignment prefers to leave them unmatched. - if type1 != type2: - return gap_penalty - - # Both are single notes: use pitch difference (same as Phase 1) - elif type1 == "note" and type2 == "note": - return compute_note_cost(event1["notes"][0], event2["notes"][0]) - - # Both are chords: Hamming distance on 12-dimensional pitch class vectors. - # i.e. count how many of the 12 pitch classes differ between the two chords. - else: - vec1 = [0] * 12 - vec2 = [0] * 12 - for note in event1["notes"]: - vec1[note["pitch"] % 12] = 1 - for note in event2["notes"]: - vec2[note["pitch"] % 12] = 1 - hamming = sum(1 for i in range(12) if vec1[i] != vec2[i]) - return hamming + return cost_matrix.astype(int) def event_alignment_ED(response_events, ref_events, gap_penalty=DEFAULT_GAP_PENALTY): """ - Align events (notes or chords) using edit distance (ED). - The ED allows for insertions and deletions, which can be useful for - evaluating musical practice containing missing/extra notes. - + Same algorithm as the production event_alignment_ED(), but the N x M + substitution costs are looked up from a precomputed cost matrix instead + of being recomputed on every DP cell and again during backtracking. + Args: response_events: list of event dicts from group_notes_into_events ref_events: list of event dicts from group_notes_into_events gap_penalty: cost of leaving an event unaligned (insertion/deletion) - + Returns: - operations: list of transformation ops dicts, in order from first event to last: - {'type': 'match' or 'replacement' or 'missing' or 'extra', - 'response_idx': int or None, - 'reference_idx': int or None, - 'cost': int} + operations: list of operation dicts, same format as event_alignment_ED() D: accumulated cost matrix, shape (N+1, M+1) """ # if a raw note dict with "pitch"/"start"/"duration" but no "event_type" is @@ -340,6 +360,9 @@ def event_alignment_ED(response_events, ref_events, gap_penalty=DEFAULT_GAP_PENA # the columns of D correspond to reference events M = len(ref_events) + # Precompute every substitution cost once + cost_matrix = build_cost_matrix(response_events, ref_events, gap_penalty) + # Build the accumulated cost matrix D of size (N+1 x M+1) D = np.zeros((N + 1, M + 1), dtype=int) @@ -353,7 +376,7 @@ def event_alignment_ED(response_events, ref_events, gap_penalty=DEFAULT_GAP_PENA # Recursion (accumulated cost / score matrix D): for n in range(1, N + 1): for m in range(1, M + 1): - replace_cost = compute_event_cost(response_events[n-1], ref_events[m-1], gap_penalty) + replace_cost = cost_matrix[n - 1, m - 1] D[n, m] = min( D[n-1, m-1] + replace_cost, # diagonal: match or replacement D[n-1, m] + gap_penalty, # vertical: extra event response[n-1] @@ -386,11 +409,11 @@ def event_alignment_ED(response_events, ref_events, gap_penalty=DEFAULT_GAP_PENA n -= 1 # For all other cases, we can move in any direction (diagonal, vertical, horizontal) else: - replace_cost = compute_event_cost(response_events[n - 1], ref_events[m - 1], gap_penalty) - diag = D[n - 1, m - 1] + replace_cost # diagonal: match or replacement - up = D[n - 1, m] + gap_penalty # vertical: extra event response[n-1] - left = D[n, m - 1] + gap_penalty # horizontal: missing response for ref[m-1] - min_cost = min(diag, up, left) # find the minimum cost step + replace_cost = cost_matrix[n - 1, m - 1] + diag = D[n - 1, m - 1] + replace_cost # Diagonal -> match or replacement + up = D[n - 1, m] + gap_penalty # Vertical -> response[n-1] is extra (insertion) + left = D[n, m - 1] + gap_penalty # Horizontal -> response is missing for ref[m-1] (deletion) + min_cost = min(diag, up, left) # classify the transformation ops based on the minimum cost step # rule: always prefer diagonal > insertion or deletion @@ -399,7 +422,7 @@ def event_alignment_ED(response_events, ref_events, gap_penalty=DEFAULT_GAP_PENA "type": "match" if replace_cost == 0 else "replacement", "response_idx": n - 1, "reference_idx": m - 1, - "cost": replace_cost, + "cost": int(replace_cost), }) n, m = n - 1, m - 1 elif min_cost == up: # Vertical -> response[n-1] is extra (insertion) @@ -419,7 +442,7 @@ def event_alignment_ED(response_events, ref_events, gap_penalty=DEFAULT_GAP_PENA }) m -= 1 - operations.reverse() # Reverse to get ops in order from first note to last + operations.reverse() return operations, D @@ -1006,10 +1029,10 @@ def generate_feedback_message(event_details, response_events, ref_events, stats, f"{accuracy_pct}% accurate. " ) if ch["missing_pitches"]: - missing_names = [PITCH_CLASS_NAMES[pc] for pc in ch["missing_pitches"]] + missing_names = [PITCH_CLASS_NAMES[pitch % 12] for pitch in ch["missing_pitches"]] message = message + "Missing note(s): " + ", ".join(missing_names) + ". " if ch["extra_pitches"]: - extra_names = [PITCH_CLASS_NAMES[pc] for pc in ch["extra_pitches"]] + extra_names = [PITCH_CLASS_NAMES[pitch % 12] for pitch in ch["extra_pitches"]] message = message + "Extra note(s) played: " + ", ".join(extra_names) + "." chord_detail_messages.append(message) # Local timing errors for chords diff --git a/evaluation_function/evaluation_test.py b/evaluation_function/evaluation_test.py index b7d4480..ac23a8e 100755 --- a/evaluation_function/evaluation_test.py +++ b/evaluation_function/evaluation_test.py @@ -26,8 +26,7 @@ normalize_start_times, group_notes_into_events, make_event, - compute_note_cost, - compute_event_cost, + build_cost_matrix, get_pitch_class_set, identify_chord_name, compute_chord_accuracy, @@ -46,6 +45,7 @@ ) from .evaluation import evaluation_function + # 0. Helper: create a minimal MIDI dictionary for testing # ------------------------------------------------------------------------------ def make_midi(pitches, starts, durations): @@ -92,26 +92,80 @@ def test_perfect_accuracy_is_one(self): res = [{"pitch": 60}, {"pitch": 64}, {"pitch": 67}] accuracy, correct, missing, extra = compute_chord_accuracy(ref, res) assert accuracy == 1.0 + assert correct == [60, 64, 67] assert missing == [] assert extra == [] - + def test_completely_wrong_notes(self): # Response has no overlap with reference ref = [{"pitch": 60}, {"pitch": 64}, {"pitch": 67}] res = [{"pitch": 61}, {"pitch": 65}, {"pitch": 69}] accuracy, correct, missing, extra = compute_chord_accuracy(ref, res) assert accuracy == 0.0 - assert len(correct) == 0 - + assert correct == [] + def test_partial_match_returns_score_between_0_and_1(self): - # C major ref (0,4,7) vs C-minor response (0,3,7) -- one note off + # One note off: E4 (64) replaced by D#4 (63) ref = [{"pitch": 60}, {"pitch": 64}, {"pitch": 67}] res = [{"pitch": 60}, {"pitch": 63}, {"pitch": 67}] accuracy, correct, missing, extra = compute_chord_accuracy(ref, res) assert 0.0 < accuracy < 1.0 - assert len(correct) == 2 - assert 4 in missing # pitch class 4 (E) is missing - assert 3 in extra # pitch class 3 (D#) is extra + assert correct == [60, 67] + assert missing == [64] # the actual MIDI pitch of the missing note (E4) + assert extra == [63] # the actual MIDI pitch of the extra note (D#4) + + def test_octave_doubling_matches_when_both_sides_double(self): + # Both reference and response double the root an octave up + # (C4=60 and C5=72) -- since we compare actual MIDI pitch, both + # copies match individually, no pitch-class merging involved. + ref = [{"pitch": 60}, {"pitch": 72}, {"pitch": 64}, {"pitch": 67}] + res = [{"pitch": 60}, {"pitch": 72}, {"pitch": 64}, {"pitch": 67}] + accuracy, correct, missing, extra = compute_chord_accuracy(ref, res) + assert accuracy == 1.0 + assert correct == [60, 64, 67, 72] + assert missing == [] + assert extra == [] + + def test_extra_octave_doubled_note_is_flagged(self): + # Reference has a single root note; performer adds an extra + # octave-doubled copy (C5=72) that was never asked for. Because we + # compare actual MIDI pitch (not pitch class), 72 is simply a + # pitch that is not in the reference -- no special-casing needed. + ref = [{"pitch": 60}, {"pitch": 64}, {"pitch": 67}] # C4, E4, G4 + res = [{"pitch": 60}, {"pitch": 72}, {"pitch": 64}, {"pitch": 67}] # + extra C5 + accuracy, correct, missing, extra = compute_chord_accuracy(ref, res) + assert extra == [72] + assert correct == [60, 64, 67] + + def test_missing_octave_doubled_note_is_detected(self): + # Reference doubles the root (C4=60 and C5=72); performer only + # plays C4, dropping the C5. Since MIDI pitch (not pitch class) is + # compared, 72 simply never appears in the response, so it is + # correctly flagged as missing -- and this now also lowers the + # accuracy score itself (unlike the original pitch-class-only + # definition, which would consider {0, 7} == {0, 7} and hide this). + ref = [{"pitch": 60}, {"pitch": 72}, {"pitch": 67}] # C4, C5, G4 + res = [{"pitch": 60}, {"pitch": 67}] # C4, G4 only + accuracy, correct, missing, extra = compute_chord_accuracy(ref, res) + assert accuracy == 5 / 6 # C=2, I=0, |y|=3 -> (2-0+3)/6 + assert correct == [60, 67] + assert missing == [72] + assert extra == [] + + def test_missing_exact_duplicate_pitch_is_detected(self): + # Reference has the EXACT same MIDI pitch twice (e.g. a fast + # repeated note landing in the same onset window as other notes), + # not just an octave doubling. A plain set comparison would merge + # both copies of 60 into one and hide a dropped repeat; the + # Counter-based multiset matching below must catch it. + ref = [{"pitch": 60}, {"pitch": 60}, {"pitch": 67}] # C4, C4 (repeat), G4 + res = [{"pitch": 60}, {"pitch": 67}] # only one C4 played + accuracy, correct, missing, extra = compute_chord_accuracy(ref, res) + assert accuracy == 5 / 6 # C=2, I=0, |y|=3 -> (2-0+3)/6 + assert correct == [60, 67] + assert missing == [60] # the dropped repeat, not merged away + assert extra == [] + # 2. Tests for normalize_start_times @@ -194,28 +248,46 @@ def test_custom_window_zero_means_no_grouping(self): assert len(events) == 2 -# 4. Tests for compute_note_cost and compute_event_cost +# 4. Tests for build_cost_matrix # ------------------------------------------------------------------------------ class TestCostComputations(unittest.TestCase): - + # compute_event_cost (single event-pair cost) was folded into + # build_cost_matrix (whole-matrix, vectorised). To test a single pair, + # just pass a 1-event list on each side and read the [0, 0] cell. + def test_note_vs_note_different_pitch(self): e1 = make_event(make_midi([60], [0.0], [0.5])["notes"]) e2 = make_event(make_midi([65], [0.0], [0.5])["notes"]) - assert compute_event_cost(e1, e2) == 5 - + cost = build_cost_matrix([e1], [e2])[0, 0] + assert cost == 5 + def test_chord_vs_chord_one_note_different(self): # C major (0,4,7) vs C-minor (0,3,7): one pitch differs -> Hamming = 2 e1 = make_event(make_midi([60, 64, 67], [0.0, 0.0, 0.0], [0.5, 0.5, 0.5])["notes"]) e2 = make_event(make_midi([60, 63, 67], [0.0, 0.0, 0.0], [0.5, 0.5, 0.5])["notes"]) - cost = compute_event_cost(e1, e2) + cost = build_cost_matrix([e1], [e2])[0, 0] assert cost == 2 def test_type_mismatch_returns_gap_penalty(self): # note vs chord -- should return the gap_penalty regardless of pitches note_event = make_event(make_midi([60], [0.0], [0.5])["notes"]) chord_event = make_event(make_midi([60, 64], [0.0, 0.0], [0.5, 0.5])["notes"]) - cost = compute_event_cost(note_event, chord_event, gap_penalty=10) + cost = build_cost_matrix([note_event], [chord_event], gap_penalty=10)[0, 0] assert cost == 10 + + def test_matrix_shape_for_multiple_events(self): + # 2 response events x 3 reference events -> (2, 3) matrix + res = [ + make_event(make_midi([60], [0.0], [0.5])["notes"]), + make_event(make_midi([62], [0.5], [0.5])["notes"]), + ] + ref = [ + make_event(make_midi([60], [0.0], [0.5])["notes"]), + make_event(make_midi([62], [0.5], [0.5])["notes"]), + make_event(make_midi([64], [1.0], [0.5])["notes"]), + ] + cost_matrix = build_cost_matrix(res, ref) + assert cost_matrix.shape == (2, 3) # 5. Tests for event_alignment_ED @@ -632,5 +704,4 @@ def test_realistic_scenario(case): ] assert len(matching_notes) == 1 flagged_note = matching_notes[0] - assert flagged_note["timing_correct"] is False - \ No newline at end of file + assert flagged_note["timing_correct"] is False \ No newline at end of file diff --git a/notebooks/Alignment_on_ASAPdataset.ipynb b/notebooks/Alignment_on_ASAPdataset.ipynb deleted file mode 100644 index d7b5b34..0000000 --- a/notebooks/Alignment_on_ASAPdataset.ipynb +++ /dev/null @@ -1,953 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# ED Alignment Algorithm on Real Piano Performances\n", - "\n", - "This notebook evaluates the ED alignment algorithm in `compareMusic` on real piano performances from the [(n)ASAP: the (note-)Aligned Scores And Performances dataset](https://github.com/CPJKU/asap-dataset) (Peter et al., 2023).\n", - "\n", - "(n)ASAP is a dataset of aligned musical scores and performances built by extending the ASAP dataset with note-level annotations. The ASAP contains 236 distinct musical scores and 1067 performances of Western classical piano music from 15 different composers, the piece directory contains the XML and MIDI score, plus all of the performances of a specific piece, including: \n", - "- `midi_score`: the MIDI score (what should be played) — used as **reference**\n", - "- `midi_performance`: what the pianist actually played — used as **response**\n", - "- `note_alignments.tsv`: official note-level alignment annotations — used as **ground truth**" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "bib citation:\n", - "\n", - "@article{Peter-2023,\n", - " title = {Automatic Note-Level Score-to-Performance Alignments in the ASAP Dataset},\n", - " author = {Peter, Silvan David and Cancino-Chacón, Carlos Eduardo and Foscarin, Francesco and McLeod, Andrew Philip and Henkel, Florian and Karystinaios, Emmanouil and Widmer, Gerhard},\n", - " doi = {10.5334/tismir.149},\n", - " journal = {Transactions of the International Society for Music Information Retrieval {(TISMIR)}},\n", - " year = {2023}\n", - "}\n", - "\n", - "relevant paper: https://transactions.ismir.net/articles/10.5334/tismir.149#5-alignment-of-the-asap-dataset" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Download the (n)ASAP Dataset" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "asap-dataset already exists, skipping download.\n" - ] - } - ], - "source": [ - "import os\n", - "\n", - "# Note: use CPJKU version (not fosfrancesco) because only CPJKU has\n", - "# the note_alignments TSV files are needed for ground truth comparison.\n", - "if not os.path.exists(\"asap-dataset\"):\n", - " os.system(\"git clone https://github.com/CPJKU/asap-dataset.git\")\n", - "else:\n", - " print(\"asap-dataset already exists, skipping download.\")\n", - "\n", - "ASAP_PATH = \"asap-dataset\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Load the Ground Truth (GT)\n", - "\n", - "The `note_alignment.tsv` file in each performance contains the official note-level alignment annotations. Each row represents one note, with columns: `xml_id`, `midi_id`, `track`, `channel`, `pitch`, `onset`.\n", - "- If `midi_id == \"deletion\"`: the score note was not played → label `deletion`\n", - "- If `xml_id == \"insertion\"`: an extra note was played → label `insertion`\n", - "- Otherwise: a matched pair → label `paired`\n", - "\n", - "For `match` and `insertion` rows, the TSV provides `onset` (onset time in seconds) and `pitch` (MIDI pitch) for the performance note." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import csv\n", - "\n", - "def load_ground_truth(tsv_path):\n", - " \"\"\"\n", - " Read a note_alignments TSV file from the CPJKU ASAP dataset.\n", - "\n", - " Args:\n", - " tsv_path: str, path to the note_alignments.tsv file\n", - "\n", - " Returns:\n", - " list of dicts, each with keys:\n", - " label -> 'paired', 'insertion', or 'deletion'\n", - " onset -> float (seconds) or None for deletions\n", - " pitch -> int (MIDI pitch number) or None for deletions\n", - " \"\"\"\n", - " rows = []\n", - " with open(tsv_path, \"r\", encoding=\"utf-8\") as f:\n", - " reader = csv.DictReader(f, delimiter=\"\\t\")\n", - " \n", - " for row in reader:\n", - " xml_id = row[\"xml_id\"].strip()\n", - " midi_id = row[\"midi_id\"].strip()\n", - "\n", - " if midi_id == \"deletion\":\n", - " rows.append({\"label\": \"deletion\", \"onset\": None, \"pitch\": None})\n", - " elif xml_id == \"insertion\":\n", - " rows.append({\n", - " \"label\": \"insertion\",\n", - " \"onset\": float(row[\"onset\"]),\n", - " \"pitch\": int(row[\"pitch\"]),\n", - " })\n", - " else:\n", - " rows.append({\n", - " \"label\": \"paired\",\n", - " \"onset\": float(row[\"onset\"]),\n", - " \"pitch\": int(row[\"pitch\"]),\n", - " })\n", - " return rows" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Load Score (reference)/Performance (response) pairs" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Helper functions for format conversion: These functions convert a MIDI file into the `{pitch, start, duration}` format used by `compare_MIDI.py`." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import pretty_midi\n", - "\n", - "def midi_file_to_notes(midi_path):\n", - " \"\"\"\n", - " Parse a MIDI file and return all its notes in compareMusic format.\n", - " \n", - " Args:\n", - " midi_path: str, path to the MIDI file\n", - "\n", - " Returns:\n", - " list of dicts sorted by onset time, each with keys:\n", - " pitch -> int, MIDI note number\n", - " start -> float, onset time in seconds\n", - " duration -> float, note length in seconds\n", - " \"\"\"\n", - " midi_data = pretty_midi.PrettyMIDI(midi_path)\n", - " all_notes = []\n", - " for instrument in midi_data.instruments:\n", - " if instrument.is_drum: # Ignore drum tracks\n", - " continue\n", - " for note in instrument.notes:\n", - " all_notes.append({\n", - " \"pitch\": note.pitch,\n", - " \"start\": round(note.start, 3),\n", - " \"duration\": round(note.end - note.start, 3),\n", - " })\n", - " # Sort by onset time, then by pitch (ensures consistent ordering for chords)\n", - " all_notes.sort(key=lambda n: (n[\"start\"], n[\"pitch\"]))\n", - " return all_notes\n", - "\n", - "\n", - "def build_sample(ref_path, response_path, composer, title, metadata_row):\n", - " \"\"\"\n", - " Convert one score/performance MIDI pair into a sample dict\n", - " ready for compare_performance_ED.\n", - "\n", - " Args:\n", - " ref_path: str, path to the score (reference) MIDI file\n", - " response_path: str, path to the performance (response) MIDI file\n", - " composer: str\n", - " title: str\n", - " metadata_row: dict, one row from metadata.csv\n", - "\n", - " Returns:\n", - " sample dict with keys: composer, title, reference, response, metadata_row\n", - " Returns None if either MIDI file produces zero notes.\n", - " \"\"\"\n", - " score_notes = midi_file_to_notes(ref_path)\n", - " perf_notes = midi_file_to_notes(response_path)\n", - "\n", - " # If either MIDI file has no notes, return None to indicate that this sample\n", - " # should be skipped (e.g., some ASAP pieces have empty score or performance).\n", - " if not score_notes or not perf_notes:\n", - " return None\n", - "\n", - " return {\n", - " \"composer\": composer,\n", - " \"title\": title,\n", - " \"reference\": {\"notes\": score_notes},\n", - " \"response\": {\"notes\": perf_notes},\n", - " \"metadata_row\": metadata_row,\n", - " }" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "For the (n)ASAP dataset, the `metadata.csv` lists every score/performance pair in the dataset, check that both MIDI files exist on disk." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/jz7125/compareMusic/.venv/lib/python3.13/site-packages/pretty_midi/pretty_midi.py:122: RuntimeWarning: Tempo, Key or Time signature change events found on non-zero tracks. This is not a valid type 0 or type 1 MIDI file. Tempo, Key or Time Signature may be wrong.\n", - " warnings.warn(\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Loaded 169 score (reference) /performance (response) pairs.\n", - "1. Bach(Fugue_bwv_846) | ref notes: 755 | response notes: 754\n", - "2. Bach(Fugue_bwv_848) | ref notes: 1429 | response notes: 1435\n", - "3. Bach(Fugue_bwv_848) | ref notes: 1429 | response notes: 1438\n", - "4. Bach(Fugue_bwv_848) | ref notes: 1429 | response notes: 1429\n", - "5. Bach(Fugue_bwv_848) | ref notes: 1429 | response notes: 1431\n", - "6. Bach(Fugue_bwv_848) | ref notes: 1429 | response notes: 1433\n", - "7. Bach(Fugue_bwv_848) | ref notes: 1429 | response notes: 1438\n", - "8. Bach(Fugue_bwv_848) | ref notes: 1429 | response notes: 1440\n", - "9. Bach(Fugue_bwv_848) | ref notes: 1429 | response notes: 1431\n", - "10. Bach(Fugue_bwv_848) | ref notes: 1429 | response notes: 1430\n" - ] - } - ], - "source": [ - "def load_samples(asap_path, composer):\n", - " \"\"\"\n", - " Read the ASAP metadata CSV and return a list of sample dicts\n", - " for a specific composer only.\n", - "\n", - " Args:\n", - " asap_path: str, path to the cloned ASAP repo\n", - " composer: str, e.g. \"Bach\"\n", - "\n", - " Returns:\n", - " list of sample dicts (see build_sample)\n", - " \"\"\"\n", - " metadata_path = os.path.join(asap_path, \"metadata.csv\")\n", - " samples = []\n", - "\n", - " with open(metadata_path, \"r\", encoding=\"utf-8\") as csv_file:\n", - " reader = csv.DictReader(csv_file)\n", - " for row in reader:\n", - " if row.get(\"composer\", \"\").strip() == composer:\n", - " ref_path = os.path.join(asap_path, row.get(\"midi_score\", \"\").strip())\n", - " response_path = os.path.join(asap_path, row.get(\"midi_performance\", \"\").strip())\n", - "\n", - " if os.path.isfile(ref_path) and os.path.isfile(response_path):\n", - " sample = build_sample(\n", - " ref_path, response_path,\n", - " row.get(\"composer\", \"Unknown\"),\n", - " row.get(\"title\", \"Unknown\"),\n", - " dict(row),\n", - " )\n", - " if sample is not None:\n", - " samples.append(sample)\n", - "\n", - " return samples\n", - "\n", - "samples = load_samples(ASAP_PATH, \"Bach\")\n", - "\n", - "print(\"Loaded\", len(samples), \"score (reference) /performance (response) pairs.\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Run Alignment on Each Pair\n", - "\n", - "Passing each score/performance pair through `compare_performance_ED`, where score MIDI is the reference and the performance MIDI is the response.\n", - "\n", - "**Why do we need the normalised events? - to fix the onset mismatch bug**\n", - "- Inside `compare_performance_ED`, `normalize_start_times` shifts the first note to t = 0, and `group_notes_into_events` groups simultaneous notes into chords. The `response_index` values stored in `event_details` refer to positions in these grouped events, not in the original flat note list. Therefore, need to reproduce these two steps here so that the correct onset and pitch for each event during ground truth comparison can be looked up.\n", - "- The `response_onset_offset` (the original first-note onset before normalisation) will also be recorded, and will be added back when comparing normalised pipeline onsets against the original (absolute) times stored in the ground truth TSV." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Alignment complete for 169 pieces.\n" - ] - } - ], - "source": [ - "from evaluation_function.compare_MIDI import (\n", - " compare_performance_ED,\n", - " normalize_start_times,\n", - " group_notes_into_events,\n", - ")\n", - "\n", - "\n", - "def run_alignment_on_samples(samples):\n", - " \"\"\"\n", - " Run compare_performance_ED on every sample and collect results.\n", - "\n", - " In addition to the pipeline result, we also store:\n", - " - response_events_normalized: the grouped event list after start-time\n", - " normalisation, needed to look up correct onset/pitch during evaluation.\n", - " - response_onset_offset: the original first-note onset time, needed to\n", - " convert normalised onsets back to absolute time for GT comparison.\n", - "\n", - " Args:\n", - " samples: list of sample dicts from load_samples()\n", - "\n", - " Returns:\n", - " list of result dicts, each with keys:\n", - " composer, title, stats, event_details, is_correct,\n", - " response_events_normalized, response_onset_offset\n", - " \"\"\"\n", - " results = []\n", - " for sample in samples:\n", - " result = compare_performance_ED(\n", - " sample[\"response\"],\n", - " sample[\"reference\"],\n", - " )\n", - "\n", - " # Reproduce the same normalisation + grouping done inside the pipeline.\n", - " # This gives us the event list whose indices match event_details.\n", - " response_notes_norm = normalize_start_times(sample[\"response\"][\"notes\"])\n", - " response_events_norm = group_notes_into_events(response_notes_norm)\n", - "\n", - " # Record the offset that normalize_start_times subtracted from every onset.\n", - " # Adding it back can convert a normalised onset to the original onset.\n", - " if sample[\"response\"][\"notes\"]:\n", - " response_onset_offset = sample[\"response\"][\"notes\"][0][\"start\"]\n", - " else:\n", - " response_onset_offset = 0.0\n", - "\n", - " results.append({\n", - " \"composer\": sample[\"composer\"],\n", - " \"title\": sample[\"title\"],\n", - " \"stats\": result.stats,\n", - " \"event_details\": result.event_details,\n", - " \"is_correct\": result.is_correct,\n", - " \"response_events_normalized\": response_events_norm,\n", - " \"response_onset_offset\": response_onset_offset,\n", - " })\n", - "\n", - " return results\n", - "\n", - "all_results = run_alignment_on_samples(samples)\n", - "print(\"Alignment complete for\", len(all_results), \"pieces.\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Compute Precision, Recall, and F1 " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**our pipeline vs GT**\n", - "\n", - "The GT has three different labels, while our pipeline has four operations:\n", - "\n", - "| Pipeline operation | GT label | Explanation |\n", - "|---|---|---|\n", - "| `match` | `paired` | Same pitch — GT still calls this `paired` |\n", - "| `replacement` | `paired` | Different pitch — GT still calls this `paired`, because the score note *was* played at approximately the right time |\n", - "| `missing` | `deletion` | Score note not found in response |\n", - "| `extra` | `insertion` | Response note has no score counterpart |\n", - "\n", - "**Evaluation metrics design**\n", - "\n", - "GT does not distinguish `match` from `replacement` because the alignment methods in GT are based on the temporal information. However, the cost function in our edit distance algorithm is based on the pitch correctness. \n", - "\n", - "Following Peter et al. (2023, TISMIR), label-level F1 would be applied as the main metric where TP, FP, and FN are computed separately for each label type and then summed:\n", - "\n", - "| Label | Matching method | Rationale |\n", - "|---|---|---|\n", - "| `paired` | Onset key only (rounded to 1 d.p.) | GT does not check pitch correctness for alignment |\n", - "| `deletion` | Count-based: TP = min(GT count, predicted count) | No onset or pitch available for deletions |\n", - "| `insertion` | `(pitch, onset)` key | Both sides have onset and pitch info for extra notes |\n", - "\n", - "- Precision: TP / (TP + FP), i.e. of all labels the pipeline predicted, how many were correct \n", - "- Recall: TP / (TP + FN), i.e. of all GT labels, how many the pipeline found \n", - "- F1: the harmonic mean of precision and recall " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def convert_pipeline_output(event_details, response_events_normalized):\n", - " \"\"\"\n", - " Convert event_details from compare_performance_ED into a list of\n", - " dicts with keys: onset, pitch, label.\n", - " Label mapping from pipeline operations to GT labels:\n", - " match or replacement -> 'paired'\n", - " missing -> 'deletion'\n", - " extra -> 'insertion'\n", - "\n", - " Chord events are expanded note-by-note using correct_pitches /\n", - " missing_pitches / extra_pitches from event_level_feedback.\n", - "\n", - " Args:\n", - " event_details: list of dicts from compare_performance_ED\n", - " response_events_normalized: list of event dicts produced by\n", - " group_notes_into_events on the normalised\n", - " response notes — NOT the flat note list.\n", - "\n", - " Returns:\n", - " list of dicts with keys:\n", - " onset -> float (normalised seconds) or None for deletions\n", - " pitch -> int (MIDI pitch) or None for deletions\n", - " label -> 'paired', 'insertion', or 'deletion'\n", - " \"\"\"\n", - " my_pairs = []\n", - "\n", - " for event in event_details:\n", - " op = event[\"operation_type\"]\n", - "\n", - " if event[\"event_type\"] == \"note\":\n", - " if op in (\"match\", \"replacement\"):\n", - " # Look up onset and pitch from the grouped event list.\n", - " ev = response_events_normalized[event[\"response_index\"] - 1]\n", - " my_pairs.append({\n", - " \"onset\": ev[\"event_start\"],\n", - " \"pitch\": ev[\"notes\"][0][\"pitch\"],\n", - " \"label\": \"paired\",\n", - " })\n", - " elif op == \"missing\":\n", - " my_pairs.append({\"onset\": None, \"pitch\": None, \"label\": \"deletion\"})\n", - " elif op == \"extra\":\n", - " ev = response_events_normalized[event[\"response_index\"] - 1]\n", - " my_pairs.append({\n", - " \"onset\": ev[\"event_start\"],\n", - " \"pitch\": ev[\"notes\"][0][\"pitch\"],\n", - " \"label\": \"insertion\",\n", - " })\n", - "\n", - " elif event[\"event_type\"] == \"chord\":\n", - " if op == \"missing\":\n", - " # Entire chord missing: one deletion per note in the ref chord\n", - " # correct_pitches + missing_pitches = all ref notes in this chord\n", - " num_ref_notes = (\n", - " len(event[\"correct_pitches\"] or [])\n", - " + len(event[\"missing_pitches\"] or [])\n", - " )\n", - " for i in range(num_ref_notes):\n", - " my_pairs.append({\"onset\": None, \"pitch\": None, \"label\": \"deletion\"})\n", - " elif op == \"extra\":\n", - " # Every note in the extra response chord counts as an insertion.\n", - " ev = response_events_normalized[event[\"response_index\"] - 1]\n", - " for note in ev[\"notes\"]:\n", - " my_pairs.append({\n", - " \"onset\": ev[\"event_start\"],\n", - " \"pitch\": note[\"pitch\"],\n", - " \"label\": \"insertion\",\n", - " })\n", - " else:\n", - " # Aligned chord pair (match or replacement).\n", - " ev = response_events_normalized[event[\"response_index\"] - 1]\n", - " onset = ev[\"event_start\"]\n", - "\n", - " # Build a pitch-class -> MIDI-pitch lookup from the response chord.\n", - " # This fixes the bug where the original code always used the first\n", - " # note's pitch regardless of which pitch class was being expanded.\n", - " pc_to_midi = {}\n", - " for note in ev[\"notes\"]:\n", - " pc = note[\"pitch\"] % 12\n", - " pc_to_midi[pc] = note[\"pitch\"]\n", - "\n", - " # Correctly matched pitch classes -> paired\n", - " for pc in (event[\"correct_pitches\"] or []):\n", - " midi_pitch = pc_to_midi.get(pc, pc) # fallback if lookup fails\n", - " my_pairs.append({\"onset\": onset, \"pitch\": midi_pitch, \"label\": \"paired\"})\n", - "\n", - " # Reference pitch classes not played -> deletion\n", - " for pc in (event[\"missing_pitches\"] or []):\n", - " my_pairs.append({\"onset\": None, \"pitch\": None, \"label\": \"deletion\"})\n", - "\n", - " # Response pitch classes with no reference counterpart -> insertion\n", - " for pc in (event[\"extra_pitches\"] or []):\n", - " midi_pitch = pc_to_midi.get(pc, pc)\n", - " my_pairs.append({\"onset\": onset, \"pitch\": midi_pitch, \"label\": \"insertion\"})\n", - "\n", - " return my_pairs" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def count_paired_matches(ground_truth, my_pairs, onset_offset):\n", - " \"\"\"\n", - " Count TP, FP, FN for 'paired' labels.\n", - "\n", - " Matching key: onset only (rounded to 1 d.p.).\n", - " Pitch is NOT used here because the GT 'paired' label means the score note\n", - " was aligned to a performance note regardless of whether the pitch is correct.\n", - " Both pipeline 'match' and 'replacement' operations map to 'paired'.\n", - "\n", - " Args:\n", - " ground_truth: list of dicts from load_ground_truth()\n", - " my_pairs: list of dicts from convert_pipeline_output()\n", - " onset_offset: float, added back to normalised onsets before comparison\n", - "\n", - " Returns:\n", - " tp, fp, fn: ints\n", - " \"\"\"\n", - " # Collect GT 'paired' onset keys\n", - " gt_paired_set = set()\n", - " for row in ground_truth:\n", - " if row[\"label\"] == \"paired\":\n", - " gt_paired_set.add(round(float(row[\"onset\"]), 1))\n", - "\n", - " # Collect predicted 'paired' onset keys, restoring absolute time\n", - " my_paired_set = set()\n", - " for row in my_pairs:\n", - " if row[\"label\"] == \"paired\" and row[\"onset\"] is not None:\n", - " absolute_onset = row[\"onset\"] + onset_offset\n", - " my_paired_set.add(round(float(absolute_onset), 1))\n", - "\n", - " tp = len(my_paired_set & gt_paired_set) # correctly predicted\n", - " fp = len(my_paired_set - gt_paired_set) # predicted but not in GT\n", - " fn = len(gt_paired_set - my_paired_set) # in GT but not predicted\n", - "\n", - " return tp, fp, fn\n", - "\n", - "\n", - "def count_deletion_matches(ground_truth, my_pairs):\n", - " \"\"\"\n", - " Count TP, FP, FN for 'deletion' labels.\n", - "\n", - " Deletions have no onset or pitch (the note was never played), so\n", - " identity-based matching is not possible. Count-based matching is used:\n", - " TP = min(GT deletion count, predicted deletion count)\n", - " FP = max(0, predicted count - GT count)\n", - " FN = max(0, GT count - predicted count)\n", - "\n", - " Args:\n", - " ground_truth: list of dicts from load_ground_truth()\n", - " my_pairs: list of dicts from convert_pipeline_output()\n", - "\n", - " Returns:\n", - " tp, fp, fn: ints\n", - " \"\"\"\n", - " gt_deletion_count = sum(1 for row in ground_truth if row[\"label\"] == \"deletion\")\n", - " my_deletion_count = sum(1 for row in my_pairs if row[\"label\"] == \"deletion\")\n", - "\n", - " tp = min(gt_deletion_count, my_deletion_count)\n", - " fp = max(0, my_deletion_count - gt_deletion_count)\n", - " fn = max(0, gt_deletion_count - my_deletion_count)\n", - "\n", - " return tp, fp, fn\n", - "\n", - "\n", - "def count_insertion_matches(ground_truth, my_pairs, onset_offset):\n", - " \"\"\"\n", - " Count TP, FP, FN for 'insertion' labels.\n", - "\n", - " Matching key: (pitch, onset) -- pitch IS included here because GT\n", - " insertion records carry a pitch value, and we want to verify that\n", - " the correct extra note was identified.\n", - "\n", - " Args:\n", - " ground_truth: list of dicts from load_ground_truth()\n", - " my_pairs: list of dicts from convert_pipeline_output()\n", - " onset_offset: float, added back to normalised onsets before comparison\n", - "\n", - " Returns:\n", - " tp, fp, fn: ints\n", - " \"\"\"\n", - " # Collect GT 'insertion' (pitch, onset) keys\n", - " gt_insertion_set = set()\n", - " for row in ground_truth:\n", - " if row[\"label\"] == \"insertion\":\n", - " key = (int(row[\"pitch\"]), round(float(row[\"onset\"]), 1))\n", - " gt_insertion_set.add(key)\n", - "\n", - " # Collect predicted 'insertion' (pitch, onset) keys, restoring absolute time\n", - " my_insertion_set = set()\n", - " for row in my_pairs:\n", - " if row[\"label\"] == \"insertion\" and row[\"onset\"] is not None:\n", - " absolute_onset = row[\"onset\"] + onset_offset\n", - " key = (int(row[\"pitch\"]), round(float(absolute_onset), 1))\n", - " my_insertion_set.add(key)\n", - "\n", - " tp = len(my_insertion_set & gt_insertion_set)\n", - " fp = len(my_insertion_set - gt_insertion_set)\n", - " fn = len(gt_insertion_set - my_insertion_set)\n", - "\n", - " return tp, fp, fn" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def compute_metrics_label_level(ground_truth, my_pairs, onset_offset=0.0):\n", - " \"\"\"\n", - " Compute label-level precision, recall, and F1 following Peter et al. (2023).\n", - " Args:\n", - " ground_truth: list of dicts from load_ground_truth()\n", - " my_pairs: list of dicts from convert_pipeline_output()\n", - " onset_offset: float, the first-note onset before normalisation.\n", - " Added back to convert normalised onsets to absolute time.\n", - "\n", - " Returns:\n", - " dict with keys:\n", - " precision, recall, f1 -> floats (rounded to 4 d.p.)\n", - " tp, fp, fn -> ints (totals across all labels)\n", - " tp_paired, fp_paired, fn_paired\n", - " tp_deletion, fp_deletion, fn_deletion\n", - " tp_insertion, fp_insertion, fn_insertion\n", - " \"\"\"\n", - " # Count TP/FP/FN separately for each label type\n", - " tp_p, fp_p, fn_p = count_paired_matches(ground_truth, my_pairs, onset_offset)\n", - " tp_d, fp_d, fn_d = count_deletion_matches(ground_truth, my_pairs)\n", - " tp_i, fp_i, fn_i = count_insertion_matches(ground_truth, my_pairs, onset_offset)\n", - "\n", - " # Sum across all label types for overall metrics\n", - " tp = tp_p + tp_d + tp_i\n", - " fp = fp_p + fp_d + fp_i\n", - " fn = fn_p + fn_d + fn_i\n", - "\n", - " # Precision: of all labels predicted, how many are correct\n", - " if tp + fp > 0:\n", - " precision = tp / (tp + fp)\n", - " else:\n", - " precision = 0.0\n", - "\n", - " # Recall: of all GT labels, how many the pipeline found\n", - " if tp + fn > 0:\n", - " recall = tp / (tp + fn)\n", - " else:\n", - " recall = 0.0\n", - "\n", - " # F1: harmonic mean of precision and recall\n", - " if precision + recall > 0:\n", - " f1 = 2 * precision * recall / (precision + recall)\n", - " else:\n", - " f1 = 0.0\n", - "\n", - " return {\n", - " \"precision\": round(precision, 4),\n", - " \"recall\": round(recall, 4),\n", - " \"f1\": round(f1, 4),\n", - " \"tp\": tp, \"fp\": fp, \"fn\": fn,\n", - " # Per-label breakdown -- useful for diagnosing which label type is weakest\n", - " \"tp_paired\": tp_p, \"fp_paired\": fp_p, \"fn_paired\": fn_p,\n", - " \"tp_deletion\": tp_d, \"fp_deletion\": fp_d, \"fn_deletion\": fn_d,\n", - " \"tp_insertion\": tp_i, \"fp_insertion\": fp_i, \"fn_insertion\": fn_i,\n", - " }" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Evaluate against ground truth:" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "def evaluate_one_piece(asap_path, metadata_row, event_details,\n", - " response_events_normalized, response_onset_offset):\n", - " \"\"\"\n", - " Run ground truth comparison for each score/performance pair.\n", - "\n", - " Args:\n", - " asap_path: str, path to ASAP repo root\n", - " metadata_row: dict, one row from metadata.csv\n", - " event_details: list from compare_performance_ED result\n", - " response_events_normalized: list of event dicts (normalized + grouped)\n", - " response_onset_offset: float, onset of the first response note\n", - " before normalization — added back to convert\n", - " normalised onsets to absolute times for GT comparison.\n", - "\n", - " Returns:\n", - " metrics dict, or None if the TSV file is not found\n", - " \"\"\"\n", - " tsv_rel = metadata_row.get(\"note_alignments\", \"\").strip()\n", - " tsv_path = os.path.join(asap_path, tsv_rel)\n", - "\n", - " if not os.path.isfile(tsv_path):\n", - " print(\"TSV not found:\", tsv_path)\n", - " return None\n", - "\n", - " ground_truth = load_ground_truth(tsv_path)\n", - " my_pairs = convert_pipeline_output(event_details, response_events_normalized)\n", - " metrics = compute_metrics(ground_truth, my_pairs, onset_offset=response_onset_offset)\n", - "\n", - " return metrics" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
PiecePrecisionRecallF1TPFPFN
0Bach (Fugue_bwv_846)0.94440.87400.90786453893
1Bach (Fugue_bwv_848)0.96140.93220.946513195396
2Bach (Fugue_bwv_848)0.93760.90310.9200127785137
3Bach (Fugue_bwv_848)0.94940.91710.9329129469117
4Bach (Fugue_bwv_848)0.93700.90830.9224127886129
5Bach (Fugue_bwv_848)0.94700.91900.9328130473115
6Bach (Fugue_bwv_848)0.95850.92940.9437131657100
7Bach (Fugue_bwv_848)0.94530.90710.9258127974131
8Bach (Fugue_bwv_848)0.95630.92730.9416131360103
9Bach (Fugue_bwv_848)0.95410.92510.9394131063106
\n", - "
" - ], - "text/plain": [ - " Piece Precision Recall F1 TP FP FN\n", - "0 Bach (Fugue_bwv_846) 0.9444 0.8740 0.9078 645 38 93\n", - "1 Bach (Fugue_bwv_848) 0.9614 0.9322 0.9465 1319 53 96\n", - "2 Bach (Fugue_bwv_848) 0.9376 0.9031 0.9200 1277 85 137\n", - "3 Bach (Fugue_bwv_848) 0.9494 0.9171 0.9329 1294 69 117\n", - "4 Bach (Fugue_bwv_848) 0.9370 0.9083 0.9224 1278 86 129\n", - "5 Bach (Fugue_bwv_848) 0.9470 0.9190 0.9328 1304 73 115\n", - "6 Bach (Fugue_bwv_848) 0.9585 0.9294 0.9437 1316 57 100\n", - "7 Bach (Fugue_bwv_848) 0.9453 0.9071 0.9258 1279 74 131\n", - "8 Bach (Fugue_bwv_848) 0.9563 0.9273 0.9416 1313 60 103\n", - "9 Bach (Fugue_bwv_848) 0.9541 0.9251 0.9394 1310 63 106" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Mean Precision: 0.941\n", - "Mean Recall : 0.9044\n", - "Mean F1 : 0.9221\n" - ] - } - ], - "source": [ - "import pandas as pd\n", - "\n", - "eval_rows = []\n", - "for sample, result in zip(samples, all_results):\n", - " metrics = evaluate_one_piece(\n", - " ASAP_PATH,\n", - " sample[\"metadata_row\"],\n", - " result[\"event_details\"],\n", - " result[\"response_events_normalized\"],\n", - " result[\"response_onset_offset\"],\n", - " )\n", - " if metrics is not None:\n", - " eval_rows.append({\n", - " \"Piece\": result[\"composer\"] + \" (\" + result[\"title\"] + \")\",\n", - " \"Precision\": metrics[\"precision\"],\n", - " \"Recall\": metrics[\"recall\"],\n", - " \"F1\": metrics[\"f1\"],\n", - " \"TP\": metrics[\"tp\"],\n", - " \"FP\": metrics[\"fp\"],\n", - " \"FN\": metrics[\"fn\"],\n", - " })\n", - "\n", - "df_eval = pd.DataFrame(eval_rows)\n", - "display(df_eval.head(10))\n", - "\n", - "print(\"Mean Precision:\", round(df_eval[\"Precision\"].mean(), 4))\n", - "print(\"Mean Recall :\", round(df_eval[\"Recall\"].mean(), 4))\n", - "print(\"Mean F1 :\", round(df_eval[\"F1\"].mean(), 4))" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "compareMusic", - "language": "python", - "name": "comparemusic" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.13.5" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/notebooks/Alignment_on_nASAPdataset.ipynb b/notebooks/Alignment_on_nASAPdataset.ipynb new file mode 100644 index 0000000..14bfdfb --- /dev/null +++ b/notebooks/Alignment_on_nASAPdataset.ipynb @@ -0,0 +1,1262 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Evaluate the Alignment Algorithm on Real Piano Performances\n", + "\n", + "This notebook evaluates the edit-distance (ED) alignment algorithm in `compareMusic` on real piano performances from the [(n)ASAP dataset](https://github.com/CPJKU/asap-dataset) (Peter, 2023).\n", + "\n", + "(n)ASAP is a dataset of aligned musical scores and performances built by extending the ASAP dataset with note-level annotations. The ASAP contains 236 distinct musical scores and 1067 performances of Western classical piano music from 15 different composers, the piece directory contains the XML and MIDI score, plus all of the performances of a specific piece.\n", + "\n", + "The `note_alignments.tsv` contains official note-level alignment annotations, which can be used as **ground truth**, it uses:\n", + "- MusicXML score notes (`xml_id`) as reference\n", + "- Performance MIDI notes (`midi_id`) as performance\n", + "\n", + "Therefore, this notebook deliberately loads:\n", + "- `xml_score.musicxml` as the pipeline reference\n", + "- `midi_performance` as the pipeline response" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "bib citation:\n", + "\n", + "@article{Peter-2023,\n", + " title = {Automatic Note-Level Score-to-Performance Alignments in the ASAP Dataset},\n", + " author = {Peter, Silvan David and Cancino-Chacón, Carlos Eduardo and Foscarin, Francesco and McLeod, Andrew Philip and Henkel, Florian and Karystinaios, Emmanouil and Widmer, Gerhard},\n", + " doi = {10.5334/tismir.149},\n", + " journal = {Transactions of the International Society for Music Information Retrieval {(TISMIR)}},\n", + " year = {2023}\n", + "}\n", + "\n", + "relevant paper: https://transactions.ismir.net/articles/10.5334/tismir.149#5-alignment-of-the-asap-dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Download the (n)ASAP Dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "asap-dataset already exists, skipping download.\n" + ] + } + ], + "source": [ + "import os\n", + "\n", + "# Note: use CPJKU version (not fosfrancesco) because only CPJKU has\n", + "# the note_alignments TSV files are needed for ground truth comparison.\n", + "if not os.path.exists(\"asap-dataset\"):\n", + " os.system(\"git clone https://github.com/CPJKU/asap-dataset.git\")\n", + "else:\n", + " print(\"asap-dataset already exists, skipping download.\")\n", + "\n", + "ASAP_PATH = \"asap-dataset\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load the Ground Truth (GT)\n", + "\n", + "The `note_alignment.tsv` file in each performance contains the official note-level alignment annotations. Each row represents one note, with columns: `xml_id`, `midi_id`, `track`, `channel`, `pitch`, `onset`.\n", + "- If `midi_id == \"deletion\"`: the score note was not played → label `deletion`\n", + "- If `xml_id == \"insertion\"`: an extra note was played → label `insertion`\n", + "- Otherwise: a matched pair → label `paired`\n", + "\n", + "For `match` and `insertion` rows, the TSV provides `onset` (onset time in seconds) and `pitch` (MIDI pitch) for the performance note." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import csv\n", + "\n", + "def load_ground_truth(tsv_path):\n", + " \"\"\"\n", + " Read a note_alignment.tsv file from the CPJKU nASAP dataset.\n", + " Returns one dictionary per TSV row. XML and MIDI identifiers are retained\n", + " so that individual alignment errors can be traced later.\n", + " Keys:\n", + " label -> 'paired', 'insertion', or 'deletion'\n", + " xml_id -> score-note identifier, or None for insertions\n", + " midi_id -> performance-note identifier, or None for deletions\n", + " onset -> performance onset in seconds, or None for deletions\n", + " pitch -> performance MIDI pitch, or None for deletions\n", + " \"\"\"\n", + " rows = []\n", + "\n", + " with open(tsv_path, \"r\", encoding=\"utf-8\") as f:\n", + " reader = csv.DictReader(f, delimiter=\"\\t\")\n", + "\n", + " for row in reader:\n", + " xml_id = row[\"xml_id\"].strip()\n", + " midi_id = row[\"midi_id\"].strip()\n", + "\n", + " if midi_id == \"deletion\":\n", + " rows.append({\n", + " \"label\": \"deletion\",\n", + " \"xml_id\": xml_id,\n", + " \"midi_id\": None,\n", + " \"onset\": None,\n", + " \"pitch\": None,\n", + " })\n", + "\n", + " elif xml_id == \"insertion\":\n", + " rows.append({\n", + " \"label\": \"insertion\",\n", + " \"xml_id\": None,\n", + " \"midi_id\": midi_id,\n", + " \"onset\": float(row[\"onset\"]),\n", + " \"pitch\": int(row[\"pitch\"]),\n", + " })\n", + "\n", + " else:\n", + " rows.append({\n", + " \"label\": \"paired\",\n", + " \"xml_id\": xml_id,\n", + " \"midi_id\": midi_id,\n", + " \"onset\": float(row[\"onset\"]),\n", + " \"pitch\": int(row[\"pitch\"]),\n", + " })\n", + "\n", + " return rows" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load MusicXML (reference) / MIDI Performance (response) pairs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The score reference is loaded from `xml_score.musicxml` with Partitura (https://partitura.readthedocs.io/en/latest/).\n", + "\n", + "The score onset and duration values are kept in symbolic beat units. This is suitable for the current pipeline because it estimates a global timing transformation between the reference and performance. The response remains in seconds because the ground-truth TSV stores performance onsets in seconds.\n", + "\n", + "\n", + "Helper functions for format conversion:\n", + "\n", + "- `xml_score_to_notes` converts MusicXML score notes into the `{pitch, start, duration}` structure used by `compareMusic`.\n", + "- `midi_file_to_notes` converts the performed MIDI into the same structure." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import partitura as pt\n", + "import pretty_midi\n", + "\n", + "def xml_score_to_notes(xml_path):\n", + " \"\"\"\n", + " Parse a MusicXML score into the format used by compareMusic.\n", + "\n", + " Partitura's note array provides score pitch and symbolic timing.\n", + " Beat-based timing is preferred because it remains meaningful even when\n", + " the MusicXML contains tempo-independent symbolic notation.\n", + " \"\"\"\n", + " score = pt.load_score(xml_path)\n", + " note_array = score.note_array()\n", + "\n", + " field_names = set(note_array.dtype.names or [])\n", + "\n", + " if \"onset_beat\" in field_names:\n", + " onset_field = \"onset_beat\"\n", + " elif \"onset_quarter\" in field_names:\n", + " onset_field = \"onset_quarter\"\n", + " elif \"onset_div\" in field_names:\n", + " onset_field = \"onset_div\"\n", + " else:\n", + " raise KeyError(\n", + " \"Could not find an onset field in the Partitura score note array.\"\n", + " )\n", + "\n", + " if \"duration_beat\" in field_names:\n", + " duration_field = \"duration_beat\"\n", + " elif \"duration_quarter\" in field_names:\n", + " duration_field = \"duration_quarter\"\n", + " elif \"duration_div\" in field_names:\n", + " duration_field = \"duration_div\"\n", + " else:\n", + " raise KeyError(\n", + " \"Could not find a duration field in the Partitura score note array.\"\n", + " )\n", + "\n", + " if \"pitch\" not in field_names:\n", + " raise KeyError(\"The Partitura score note array has no 'pitch' field.\")\n", + "\n", + " notes = []\n", + "\n", + " for row in note_array:\n", + " note = {\n", + " \"pitch\": int(row[\"pitch\"]),\n", + " \"start\": float(row[onset_field]),\n", + " \"duration\": float(row[duration_field]),\n", + " }\n", + "\n", + " # Retain the MusicXML note ID when Partitura supplies it.\n", + " if \"id\" in field_names:\n", + " note[\"xml_id\"] = str(row[\"id\"])\n", + "\n", + " notes.append(note)\n", + "\n", + " notes.sort(key=lambda note: (note[\"start\"], note[\"pitch\"]))\n", + " return notes\n", + "\n", + "\n", + "def midi_file_to_notes(midi_path):\n", + " \"\"\"Parse a performance MIDI file into the format used by compareMusic.\"\"\"\n", + " midi_data = pretty_midi.PrettyMIDI(midi_path)\n", + " all_notes = []\n", + "\n", + " for instrument in midi_data.instruments:\n", + " if instrument.is_drum:\n", + " continue\n", + "\n", + " for note in instrument.notes:\n", + " all_notes.append({\n", + " \"pitch\": int(note.pitch),\n", + " # Keep full precision because rounding may change tolerance-based\n", + " # evaluation near a matching boundary.\n", + " \"start\": float(note.start),\n", + " \"duration\": float(note.end - note.start),\n", + " })\n", + "\n", + " all_notes.sort(key=lambda note: (note[\"start\"], note[\"pitch\"]))\n", + " return all_notes\n", + "\n", + "\n", + "def build_sample(xml_path, response_path, composer, title, metadata_row):\n", + " \"\"\"\n", + " Build one MusicXML-score / performance-MIDI sample.\n", + "\n", + " The score reference and ground-truth TSV now share the same MusicXML\n", + " score-note representation.\n", + " \"\"\"\n", + " score_notes = xml_score_to_notes(xml_path)\n", + " performance_notes = midi_file_to_notes(response_path)\n", + "\n", + " if not score_notes or not performance_notes:\n", + " return None\n", + "\n", + " return {\n", + " \"composer\": composer,\n", + " \"title\": title,\n", + " \"reference\": {\"notes\": score_notes},\n", + " \"response\": {\"notes\": performance_notes},\n", + " \"metadata_row\": metadata_row,\n", + " }\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The nASAP `metadata.csv` gives the path to the MusicXML score, performance MIDI, and note-alignment TSV for each performance. " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jz7125/compareMusic/.venv/lib/python3.13/site-packages/partitura/directions.py:526: UserWarning: error parsing \"( )\" (UnexpectedCharacters)\n", + " warnings.warn('error parsing \"{}\" ({})'.format(string, type(e).__name__))\n", + "/Users/jz7125/compareMusic/.venv/lib/python3.13/site-packages/partitura/io/importmusicxml.py:1112: UserWarning: ignoring direction type: metronome {'parentheses': 'no', 'default-x': '-51.17', 'relative-y': '20.00'}\n", + " warnings.warn(\"ignoring direction type: {} {}\".format(dt.tag, dt.attrib))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loaded 169 MusicXML-score (reference) / MIDI-performance (response) pairs.\n" + ] + } + ], + "source": [ + "def load_samples(asap_path, composer):\n", + " \"\"\"\n", + " Read metadata.csv and return MusicXML-score / MIDI-performance samples\n", + " for one composer.\n", + " \"\"\"\n", + " metadata_path = os.path.join(asap_path, \"metadata.csv\")\n", + " samples = []\n", + "\n", + " with open(metadata_path, \"r\", encoding=\"utf-8\") as csv_file:\n", + " reader = csv.DictReader(csv_file)\n", + "\n", + " for row in reader:\n", + " if row.get(\"composer\", \"\").strip() != composer:\n", + " continue\n", + "\n", + " xml_path = os.path.join(asap_path, row.get(\"xml_score\", \"\").strip())\n", + " response_path = os.path.join(asap_path, row.get(\"midi_performance\", \"\").strip())\n", + " tsv_path = os.path.join(asap_path, row.get(\"note_alignments\", \"\").strip())\n", + " \n", + " if os.path.isfile(xml_path) and os.path.isfile(response_path) and os.path.isfile(tsv_path):\n", + " sample = build_sample(\n", + " xml_path,\n", + " response_path,\n", + " row.get(\"composer\", \"Unknown\"),\n", + " row.get(\"title\", \"Unknown\"),\n", + " dict(row),\n", + " )\n", + " if sample is not None:\n", + " samples.append(sample)\n", + "\n", + " return samples\n", + "\n", + "samples = load_samples(ASAP_PATH, \"Bach\")\n", + "\n", + "print(\"Loaded\", len(samples), \"MusicXML-score (reference) / MIDI-performance (response) pairs.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Run Alignment on Each Pair\n", + "\n", + "Each score/performance pair is passed through `compare_performance_ED`. The current pipeline normalises the first onset to zero and groups nearby notes into events. Because `event_details` stores event indices, the same normalisation and grouping steps are reproduced here tso that the correct onset and pitch for each event during ground truth comparison can be looked up.\n", + "\n", + "The original response onset offset is retained and added back only during comparison with the absolute performance times in the TSV file." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Alignment complete for 169 pieces.\n" + ] + } + ], + "source": [ + "from evaluation_function.compare_MIDI import (\n", + " compare_performance_ED,\n", + " normalize_start_times,\n", + " group_notes_into_events,\n", + ")\n", + "\n", + "\n", + "def run_alignment_on_samples(samples):\n", + " \"\"\"Run compare_performance_ED for every loaded sample.\"\"\"\n", + " results = []\n", + "\n", + " for sample_index, sample in enumerate(samples):\n", + " result = compare_performance_ED(\n", + " sample[\"response\"],\n", + " sample[\"reference\"],\n", + " )\n", + "\n", + " response_notes_normalized = normalize_start_times(\n", + " sample[\"response\"][\"notes\"]\n", + " )\n", + " response_events_normalized = group_notes_into_events(\n", + " response_notes_normalized\n", + " )\n", + "\n", + " ref_notes_normalized = normalize_start_times(\n", + " sample[\"reference\"][\"notes\"]\n", + " )\n", + " ref_events_normalized = group_notes_into_events(\n", + " ref_notes_normalized\n", + " )\n", + "\n", + " response_onset_offset = float(\n", + " sample[\"response\"][\"notes\"][0][\"start\"]\n", + " )\n", + "\n", + " results.append({\n", + " \"sample_index\": sample_index,\n", + " \"composer\": sample[\"composer\"],\n", + " \"title\": sample[\"title\"],\n", + " \"metadata_row\": sample[\"metadata_row\"],\n", + " \"stats\": result.stats,\n", + " \"event_details\": result.event_details,\n", + " \"is_correct\": result.is_correct,\n", + " \"response_events_normalized\": response_events_normalized,\n", + " \"ref_events_normalized\": ref_events_normalized,\n", + " \"response_onset_offset\": response_onset_offset,\n", + " })\n", + "\n", + " return results\n", + "\n", + "\n", + "all_results = run_alignment_on_samples(samples)\n", + "print(\"Alignment complete for\", len(all_results), \"pieces.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Compute Precision, Recall, and F1 " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Pipeline output vs ground truth**\n", + "\n", + "he GT has three different labels, while our pipeline has four operations:\n", + "\n", + "| Pipeline operation | GT label | Explanation |\n", + "|---|---|---|\n", + "| `match` | `paired` | Same pitch — GT still calls this `paired` |\n", + "| `replacement` | `paired` | Different pitch — GT still calls this `paired`, because the score note *was* played at approximately the right time |\n", + "| `missing` | `deletion` | Score note not found in response |\n", + "| `extra` | `insertion` | Response note has no score counterpart |\n", + "\n", + "**Evaluation metrics design**\n", + "\n", + "Evaluation is performed at **note level** after expanding chord events. Matches are one-to-one, so three notes at the same chord onset remain three separate observations.\n", + "\n", + "| Label | Matching key | TP | FP | FN |\n", + "|---|---|---|---|---|\n", + "| `paired` (pipeline `match` / `replacement`) | onset-only matching within `ONSET_TOLERANCE`; pitch is intentionally ignored because this evaluates alignment rather than pitch correctness| Pipeline and ground truth both contain a paired label at matching performance onsets within the tolerance | Pipeline predicts a pairing at this onset that the ground truth does not recognise | Ground truth expects a pairing at this onset that the pipeline fails to find |\n", + "| `deletion` (pipeline `missing`) | count only as no onset or pitch available for deletions | Overlap between the pipeline deletion count and the ground-truth deletion count | The pipeline predicts more deletions than appear in the ground truth; the excess count is treated as FP | The ground truth contains more deletions than the pipeline predicts; the missing count is treated as FN |\n", + "| `insertion` (pipeline `extra`) | pitch must be equal and onset must be within `ONSET_TOLERANCE` | Pipeline and ground truth agree an extra, unexpected note was played at this pitch and onset | Pipeline flags a note as extra that the ground truth does not agree with | Ground truth marks a note as extra that the pipeline fails to identify |\n", + "\n", + "- Precision: TP / (TP + FP), i.e. of all labels the pipeline predicted, how many were correct \n", + "- Recall: TP / (TP + FN), i.e. of all GT labels, how many the pipeline found \n", + "- F1: the harmonic mean of precision and recall " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def convert_pipeline_output(event_details, response_events, ref_events):\n", + " \"\"\"\n", + " Convert event-level alignment output into note-level alignment labels.\n", + " Alignment labels describe note correspondence, not pitch correctness.\n", + "\n", + " Rules:\n", + " missing:\n", + " Every note in the reference event becomes a deletion.\n", + " extra:\n", + " Every note in the response event becomes an insertion.\n", + " match/replacement:\n", + " Pair as many response and reference notes as possible.\n", + " Different pitches may still form a paired alignment.\n", + " Remaining response notes become insertions.\n", + " Remaining reference notes become deletions.\n", + "\n", + " This implementation guarantees:\n", + " paired + insertion == total response notes\n", + " paired + deletion == total reference notes\n", + " \"\"\"\n", + " predictions = []\n", + "\n", + " for event in event_details:\n", + " operation = event[\"operation_type\"]\n", + "\n", + " response_event = None\n", + " reference_event = None\n", + "\n", + " if event.get(\"response_index\") is not None:\n", + " response_index = event[\"response_index\"] - 1\n", + " if (response_index < 0) or (response_index >= len(response_events)):\n", + " raise IndexError(\"response_index is outside response_events\")\n", + " response_event = response_events[response_index]\n", + "\n", + " if event.get(\"reference_index\") is not None:\n", + " reference_index = event[\"reference_index\"] - 1\n", + " if (reference_index < 0) or (reference_index >= len(ref_events)):\n", + " raise IndexError(\"reference_index is outside ref_events\")\n", + " reference_event = ref_events[reference_index]\n", + "\n", + " # for missing event\n", + " if operation == \"missing\":\n", + " for reference_note in reference_event[\"notes\"]:\n", + " predictions.append({\n", + " \"onset\": None,\n", + " \"pitch\": None,\n", + " \"label\": \"deletion\",\n", + " })\n", + " # for extra event\n", + " elif operation == \"extra\":\n", + " for response_note in response_event[\"notes\"]:\n", + " predictions.append({\n", + " \"onset\": float(response_note[\"start\"]),\n", + " \"pitch\": int(response_note[\"pitch\"]),\n", + " \"label\": \"insertion\",\n", + " })\n", + " # for matched or replacement event\n", + " else:\n", + " response_notes = sorted(\n", + " response_event[\"notes\"],\n", + " key=lambda note: int(note[\"pitch\"])\n", + " )\n", + " reference_notes = sorted(\n", + " reference_event[\"notes\"],\n", + " key=lambda note: int(note[\"pitch\"])\n", + " )\n", + " pair_count = min(len(response_notes), len(reference_notes))\n", + "\n", + " # A pitch difference does not change the alignment label:\n", + " # it remains paired.\n", + " for index in range(pair_count):\n", + " response_note = response_notes[index]\n", + " predictions.append({\n", + " \"onset\": float(response_note[\"start\"]),\n", + " \"pitch\": int(response_note[\"pitch\"]),\n", + " \"label\": \"paired\",\n", + " })\n", + "\n", + " # Response side contains more notes.\n", + " for response_note in response_notes[pair_count:]:\n", + " predictions.append({\n", + " \"onset\": float(response_note[\"start\"]),\n", + " \"pitch\": int(response_note[\"pitch\"]),\n", + " \"label\": \"insertion\",\n", + " })\n", + "\n", + " # Reference side contains more notes.\n", + " missing_count = len(reference_notes) - pair_count\n", + " for i in range(missing_count):\n", + " predictions.append({\n", + " \"onset\": None,\n", + " \"pitch\": None,\n", + " \"label\": \"deletion\",\n", + " })\n", + "\n", + " return predictions" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "ONSET_TOLERANCE = 0.05 # 50 milliseconds\n", + "\n", + "def count_onset_matches(gt_onsets, predicted_onsets, tolerance):\n", + " \"\"\"Count one-to-one onset matches while preserving chord notes.\"\"\"\n", + " gt_onsets = sorted(gt_onsets)\n", + " predicted_onsets = sorted(predicted_onsets)\n", + "\n", + " gt_index = 0\n", + " predicted_index = 0\n", + " matches = 0\n", + "\n", + " while gt_index < len(gt_onsets) and predicted_index < len(predicted_onsets):\n", + " difference = predicted_onsets[predicted_index] - gt_onsets[gt_index]\n", + "\n", + " if abs(difference) <= tolerance:\n", + " matches += 1\n", + " gt_index += 1\n", + " predicted_index += 1\n", + " elif difference < -tolerance:\n", + " predicted_index += 1\n", + " else:\n", + " gt_index += 1\n", + "\n", + " return matches" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def compute_metrics(ground_truth, predictions, onset_offset=0.0):\n", + " \"\"\"Compute note-level precision, recall, and F1.\"\"\"\n", + " total_tp = 0\n", + " total_fp = 0\n", + " total_fn = 0\n", + "\n", + " # 1. Paired notes: compare onset only.\n", + " gt_paired = [\n", + " row[\"onset\"]\n", + " for row in ground_truth\n", + " if row[\"label\"] == \"paired\" and row[\"onset\"] is not None\n", + " ]\n", + " predicted_paired = [\n", + " row[\"onset\"] + onset_offset\n", + " for row in predictions\n", + " if row[\"label\"] == \"paired\" and row[\"onset\"] is not None\n", + " ]\n", + "\n", + " paired_tp = count_onset_matches(\n", + " gt_paired, predicted_paired, ONSET_TOLERANCE\n", + " )\n", + " total_tp += paired_tp\n", + " total_fp += len(predicted_paired) - paired_tp\n", + " total_fn += len(gt_paired) - paired_tp\n", + "\n", + " # 2. Insertions: compare both pitch and onset.\n", + " gt_insertions = {}\n", + " predicted_insertions = {}\n", + "\n", + " for row in ground_truth:\n", + " if (\n", + " row[\"label\"] == \"insertion\"\n", + " and row[\"pitch\"] is not None\n", + " and row[\"onset\"] is not None\n", + " ):\n", + " pitch = int(row[\"pitch\"])\n", + " if pitch not in gt_insertions:\n", + " gt_insertions[pitch] = []\n", + " gt_insertions[pitch].append(float(row[\"onset\"]))\n", + "\n", + " for row in predictions:\n", + " if (\n", + " row[\"label\"] == \"insertion\"\n", + " and row[\"pitch\"] is not None\n", + " and row[\"onset\"] is not None\n", + " ):\n", + " pitch = int(row[\"pitch\"])\n", + " if pitch not in predicted_insertions:\n", + " predicted_insertions[pitch] = []\n", + " predicted_insertions[pitch].append(\n", + " float(row[\"onset\"]) + onset_offset\n", + " )\n", + "\n", + " for pitch in set(gt_insertions) | set(predicted_insertions):\n", + " gt_onsets = gt_insertions.get(pitch, [])\n", + " predicted_onsets = predicted_insertions.get(pitch, [])\n", + "\n", + " insertion_tp = count_onset_matches(\n", + " gt_onsets,\n", + " predicted_onsets,\n", + " ONSET_TOLERANCE,\n", + " )\n", + " total_tp += insertion_tp\n", + " total_fp += len(predicted_onsets) - insertion_tp\n", + " total_fn += len(gt_onsets) - insertion_tp\n", + "\n", + " # 3. Deletions: count-based because the pipeline does not return xml_id.\n", + " gt_deletions = sum(\n", + " row[\"label\"] == \"deletion\" for row in ground_truth\n", + " )\n", + " predicted_deletions = sum(\n", + " row[\"label\"] == \"deletion\" for row in predictions\n", + " )\n", + "\n", + " deletion_tp = min(gt_deletions, predicted_deletions)\n", + " total_tp += deletion_tp\n", + " total_fp += predicted_deletions - deletion_tp\n", + " total_fn += gt_deletions - deletion_tp\n", + "\n", + " precision = (\n", + " total_tp / (total_tp + total_fp)\n", + " if total_tp + total_fp > 0 else 0.0\n", + " )\n", + " recall = (\n", + " total_tp / (total_tp + total_fn)\n", + " if total_tp + total_fn > 0 else 0.0\n", + " )\n", + " f1 = (\n", + " 2 * precision * recall / (precision + recall)\n", + " if precision + recall > 0 else 0.0\n", + " )\n", + "\n", + " return {\n", + " \"precision\": precision,\n", + " \"recall\": recall,\n", + " \"f1\": f1,\n", + " \"tp\": total_tp,\n", + " \"fp\": total_fp,\n", + " \"fn\": total_fn,\n", + " }" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Evaluate all pieces\n", + "\n", + "The evaluation is note-level. Notes inside a chord are kept as separate notes. Paired notes use a 50 ms onset tolerance, while insertions require both the same MIDI pitch and a matching onset." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Piece Precision Recall F1 TP FP FN\n", + "153 Bach (Prelude_bwv_885) 0.8389 0.8903 0.8638 479 92 59\n", + "134 Bach (Prelude_bwv_874) 0.8941 0.9249 0.9092 1477 175 120\n", + "135 Bach (Prelude_bwv_874) 0.9012 0.9345 0.9176 1469 161 103\n", + "86 Bach (Italian_concerto) 0.9016 0.9330 0.9170 1100 120 79\n", + "84 Bach (Italian_concerto) 0.9031 0.9325 0.9175 1146 123 83\n", + "110 Bach (Prelude_bwv_858) 0.9111 0.9204 0.9157 451 44 39\n", + "76 Bach (Fugue_bwv_889) 0.9126 0.9126 0.9126 783 75 75\n", + "152 Bach (Prelude_bwv_885) 0.9129 0.9384 0.9255 503 48 33\n", + "77 Bach (Fugue_bwv_889) 0.9134 0.9189 0.9161 770 73 68\n", + "108 Bach (Prelude_bwv_857) 0.9143 0.9437 0.9288 587 55 35\n", + "Mean Precision: 0.971\n", + "Mean Recall : 0.9759\n", + "Mean F1 : 0.9734\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "evaluation_rows = []\n", + "\n", + "for sample, result in zip(samples, all_results):\n", + " metadata_row = sample[\"metadata_row\"]\n", + " tsv_relative_path = (metadata_row.get(\"note_alignments\") or \"\").strip()\n", + " tsv_path = os.path.join(ASAP_PATH, tsv_relative_path)\n", + "\n", + " if not os.path.isfile(tsv_path):\n", + " print(\"TSV not found:\", tsv_path)\n", + " continue\n", + "\n", + " ground_truth = load_ground_truth(tsv_path)\n", + " predictions = convert_pipeline_output(\n", + " result[\"event_details\"],\n", + " result[\"response_events_normalized\"],\n", + " result[\"ref_events_normalized\"],\n", + " )\n", + "\n", + " metrics = compute_metrics(\n", + " ground_truth,\n", + " predictions,\n", + " onset_offset=result[\"response_onset_offset\"],\n", + " )\n", + "\n", + " evaluation_rows.append({\n", + " \"Piece\": f'{result[\"composer\"]} ({result[\"title\"]})',\n", + " \"Precision\": metrics[\"precision\"],\n", + " \"Recall\": metrics[\"recall\"],\n", + " \"F1\": metrics[\"f1\"],\n", + " \"TP\": metrics[\"tp\"],\n", + " \"FP\": metrics[\"fp\"],\n", + " \"FN\": metrics[\"fn\"],\n", + " })\n", + "\n", + "df_eval = pd.DataFrame(evaluation_rows)\n", + "print(df_eval.sort_values(\"Precision\", ascending=True).head(10).round(4))\n", + "\n", + "print(\"Mean Precision:\", round(df_eval[\"Precision\"].mean(), 4))\n", + "print(\"Mean Recall :\", round(df_eval[\"Recall\"].mean(), 4))\n", + "print(\"Mean F1 :\", round(df_eval[\"F1\"].mean(), 4))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Interpretation of results" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Piece: Bach Prelude_bwv_885\n", + "Ground-truth labels: 538\n", + "Pipeline labels: 571\n", + "=== Ground truth ===\n", + "Paired: 497\n", + "Insertion: 28\n", + "Deletion: 13\n", + "Performance notes represented: 525\n", + "Reference notes represented: 510\n", + "=== Pipeline predictions ===\n", + "Paired: 464\n", + "Insertion: 61\n", + "Deletion: 46\n", + "Performance notes represented: 525\n", + "Reference notes represented: 510\n", + "=== Original event data ===\n", + "Notes in response_events: 525\n", + "Notes in ref_events: 510\n", + "=== Conservation checks ===\n", + "Every response note represented exactly once: True\n", + "Every reference note represented exactly once: True\n" + ] + } + ], + "source": [ + "SELECTED_SAMPLE_INDEX = 153\n", + "\n", + "selected_sample = samples[SELECTED_SAMPLE_INDEX]\n", + "selected_result = all_results[SELECTED_SAMPLE_INDEX]\n", + "\n", + "ref_events = selected_result[\"ref_events_normalized\"]\n", + "response_events = selected_result[\"response_events_normalized\"]\n", + "event_details = selected_result[\"event_details\"]\n", + "\n", + "metadata_row = selected_sample[\"metadata_row\"]\n", + "\n", + "tsv_path = os.path.join(ASAP_PATH, metadata_row[\"note_alignments\"].strip())\n", + "xml_path = os.path.join(ASAP_PATH, metadata_row[\"xml_score\"].strip())\n", + "midi_score_path = os.path.join(ASAP_PATH, metadata_row[\"midi_score\"].strip())\n", + "midi_performance_path = os.path.join(ASAP_PATH, metadata_row[\"midi_performance\"].strip())\n", + "\n", + "ground_truth = load_ground_truth(tsv_path)\n", + "\n", + "predictions = convert_pipeline_output(\n", + " selected_result[\"event_details\"],\n", + " selected_result[\"response_events_normalized\"],\n", + " selected_result[\"ref_events_normalized\"],\n", + ")\n", + "\n", + "# Add the original response onset offset back.\n", + "for prediction in predictions:\n", + " if prediction[\"onset\"] is not None:\n", + " prediction[\"onset\"] += selected_result[\"response_onset_offset\"]\n", + "\n", + "print(\"Piece:\", selected_result[\"composer\"], selected_result[\"title\"])\n", + "print(\"Ground-truth labels:\", len(ground_truth))\n", + "print(\"Pipeline labels:\", len(predictions))\n", + "\n", + "\n", + "from collections import Counter\n", + "gt_counts = Counter(note[\"label\"] for note in ground_truth)\n", + "pipeline_counts = Counter(note[\"label\"] for note in predictions)\n", + "\n", + "gt_response_note_count = gt_counts[\"paired\"] + gt_counts[\"insertion\"]\n", + "gt_reference_note_count = gt_counts[\"paired\"] + gt_counts[\"deletion\"]\n", + "pipeline_response_note_count = pipeline_counts[\"paired\"] + pipeline_counts[\"insertion\"]\n", + "pipeline_reference_note_count = pipeline_counts[\"paired\"] + pipeline_counts[\"deletion\"]\n", + "\n", + "actual_response_event_note_count = sum(len(event[\"notes\"]) for event in response_events)\n", + "actual_reference_event_note_count = sum(len(event[\"notes\"]) for event in ref_events)\n", + "\n", + "print(\"=== Ground truth ===\")\n", + "print(\"Paired:\", gt_counts[\"paired\"])\n", + "print(\"Insertion:\", gt_counts[\"insertion\"])\n", + "print(\"Deletion:\", gt_counts[\"deletion\"])\n", + "print(\"Performance notes represented:\", gt_response_note_count)\n", + "print(\"Reference notes represented:\", gt_reference_note_count)\n", + "\n", + "print(\"=== Pipeline predictions ===\")\n", + "print(\"Paired:\", pipeline_counts[\"paired\"])\n", + "print(\"Insertion:\", pipeline_counts[\"insertion\"])\n", + "print(\"Deletion:\", pipeline_counts[\"deletion\"])\n", + "print(\"Performance notes represented:\", pipeline_response_note_count)\n", + "print(\"Reference notes represented:\", pipeline_reference_note_count)\n", + "\n", + "print(\"=== Original event data ===\")\n", + "print(\"Notes in response_events:\", actual_response_event_note_count)\n", + "print(\"Notes in ref_events:\", actual_reference_event_note_count)\n", + "\n", + "print(\"=== Conservation checks ===\")\n", + "print(\n", + " \"Every response note represented exactly once:\",\n", + " pipeline_response_note_count\n", + " == actual_response_event_note_count\n", + ")\n", + "print(\n", + " \"Every reference note represented exactly once:\",\n", + " pipeline_reference_note_count\n", + " == actual_reference_event_note_count\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The pipeline produced 571 note-level labels while the the GT has 538 labels. Specifically, the pipeline predicted 33 more insertions, 33 more deletions and 33 fewer pairs than the GT. This is because 'paired' can be represented by a single label whereas 'unpaired' requires both an insertion and a deletion. The paper (Peter, 2023) suggests that a misalignment pair (which is unaligned in GT) will create one FP and two FNs (i.e. label as paired instead of a deletion + an insertion). In this case here, it appears as the reverse: a GT paired correspondence is split into a predicted insertion and deletion, such an error can produce two FPs and one FN, which helps explain why precision is lower than recall in this case.\n", + "\n", + "As the ground truth is chosen to be the result of another alignment algorithm, the metrics actually measures the agreement between the existing alignment algorithm and mine, rather than absolute musical correctness. This occurrence of FPs and FNs is likely related to the alignment strategy (based on pitch difference) and parameter settings, and it appears that my pipeline with default parameters favours gap operations (insertion/deletion) rather than pairing up 2 notes (match/replacement). In educational applications, pairing a wrong note with its intended score note may provide more informative feedback than treating the same event as an insertion and a deletion. The default parameters are set to be strict, but my pipeline allows teachers to adjust parameters so that the this alignment can be adapted to different musical contexts. For example, the gap penalty and timing thresholds can be adjusted depending on whether the target application is beginner practice, examination recordings or expert concert performances. \n", + "\n", + "Additionally, the nASAP contains performances data from a competition, consequently, the dataset contains expressive timing, tempo fluctuations and ornament that are less representative of beginner practice, makes it differ substantially from the intended application of this project—providing feedback for student practice. (However, this is the most suitable public dataset to use, so the lacking of large-scale students' practice data remains the biggest limitation of this project)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Bach Prelude_bwv_885\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Selected operations: 45\n", + "Missing note markers: 0\n", + "Extra note markers: 3\n" + ] + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "from matplotlib.patches import ConnectionPatch\n", + "from matplotlib.lines import Line2D\n", + "\n", + "SELECTED_SAMPLE_INDEX = 153\n", + "\n", + "selected_result = all_results[SELECTED_SAMPLE_INDEX]\n", + "ref_events = selected_result[\"ref_events_normalized\"]\n", + "response_events = selected_result[\"response_events_normalized\"]\n", + "event_details = selected_result[\"event_details\"]\n", + "\n", + "print(selected_result[\"composer\"], selected_result[\"title\"])\n", + "\n", + "def get_note_centre(note):\n", + " return note[\"start\"] + note[\"duration\"] / 2, note[\"pitch\"]\n", + "\n", + "def get_event_anchor(event):\n", + " \"\"\"\n", + " Return an anchor located on a real note.\n", + "\n", + " For a single-note event, use that note.\n", + " For a chord, use the middle note after sorting by pitch.\n", + " \"\"\"\n", + " notes = sorted(event[\"notes\"], key=lambda note: note[\"pitch\"])\n", + " anchor_note = notes[len(notes) // 2]\n", + " return get_note_centre(anchor_note)\n", + "\n", + "def event_overlaps_range(event, start, end):\n", + " for note in event[\"notes\"]:\n", + " note_start = note[\"start\"]\n", + " note_end = note[\"start\"] + note[\"duration\"]\n", + " if note_end >= start and note_start <= end:\n", + " return True\n", + " return False\n", + "\n", + "def plot_alignment(ref_events, response_events, event_details, ref_start, ref_end):\n", + "\n", + " reference_positions = []\n", + "\n", + " for position, detail in enumerate(event_details):\n", + " reference_index = detail.get(\"reference_index\")\n", + "\n", + " if reference_index is not None:\n", + " ref_event = ref_events[reference_index - 1]\n", + " ref_onset = ref_event[\"event_start\"]\n", + "\n", + " if ref_start <= ref_onset <= ref_end:\n", + " reference_positions.append(position)\n", + "\n", + " if not reference_positions:\n", + " raise ValueError(\"No reference events were found in this range.\")\n", + "\n", + " first_position = min(reference_positions)\n", + " last_position = max(reference_positions)\n", + "\n", + " selected_details = []\n", + "\n", + " for position in range(first_position, last_position + 1):\n", + " detail = event_details[position]\n", + " operation = detail[\"operation_type\"]\n", + " reference_index = detail.get(\"reference_index\")\n", + " include_detail = operation == \"extra\"\n", + "\n", + " if reference_index is not None:\n", + " ref_event = ref_events[reference_index - 1]\n", + " ref_onset = ref_event[\"event_start\"]\n", + "\n", + " if ref_start <= ref_onset <= ref_end:\n", + " include_detail = True\n", + "\n", + " if include_detail:\n", + " selected_details.append(detail)\n", + "\n", + " response_starts = []\n", + " response_ends = []\n", + "\n", + " for detail in selected_details:\n", + " response_index = detail.get(\"response_index\")\n", + "\n", + " if response_index is not None:\n", + " response_event = response_events[response_index - 1]\n", + "\n", + " for note in response_event[\"notes\"]:\n", + " response_starts.append(note[\"start\"])\n", + " response_ends.append(note[\"start\"] + note[\"duration\"])\n", + "\n", + " if response_starts:\n", + " response_start = min(response_starts) - 0.5\n", + " response_end = max(response_ends) + 0.5\n", + " else:\n", + " response_start = ref_start\n", + " response_end = ref_end\n", + "\n", + " visible_response_events = []\n", + "\n", + " for event in response_events:\n", + " if event_overlaps_range(event, response_start, response_end):\n", + " visible_response_events.append(event)\n", + "\n", + " visible_ref_events = []\n", + "\n", + " for event in ref_events:\n", + " if event_overlaps_range(event, ref_start, ref_end):\n", + " visible_ref_events.append(event)\n", + "\n", + " visible_pitches = []\n", + "\n", + " for event in visible_response_events:\n", + " for note in event[\"notes\"]:\n", + " visible_pitches.append(note[\"pitch\"])\n", + "\n", + " for event in visible_ref_events:\n", + " for note in event[\"notes\"]:\n", + " visible_pitches.append(note[\"pitch\"])\n", + "\n", + " fig, (ax_response, ax_ref) = plt.subplots(\n", + " 2, 1, figsize=(15, 8), height_ratios=[1, 1])\n", + "\n", + " note_colour = \"tab:blue\"\n", + " match_colour = \"0.65\"\n", + " replacement_colour = \"tab:orange\"\n", + " missing_colour = \"tab:red\"\n", + " extra_colour = \"tab:purple\"\n", + "\n", + " for event in visible_response_events:\n", + " for note in event[\"notes\"]:\n", + " ax_response.hlines(\n", + " y=note[\"pitch\"],\n", + " xmin=note[\"start\"],\n", + " xmax=note[\"start\"] + note[\"duration\"],\n", + " linewidth=5,\n", + " color=note_colour,\n", + " )\n", + "\n", + " ax_response.set_xlim(response_start, response_end)\n", + " ax_response.set_ylabel(\"Performance MIDI pitch\")\n", + " ax_response.set_title(\"Performance\")\n", + "\n", + " for event in visible_ref_events:\n", + " for note in event[\"notes\"]:\n", + " ax_ref.hlines(\n", + " y=note[\"pitch\"],\n", + " xmin=note[\"start\"],\n", + " xmax=note[\"start\"] + note[\"duration\"],\n", + " linewidth=5,\n", + " color=note_colour,\n", + " )\n", + "\n", + " ax_ref.set_xlim(ref_start, ref_end)\n", + " ax_ref.set_xlabel(\"Normalised time (seconds)\")\n", + " ax_ref.set_ylabel(\"Reference MIDI pitch\")\n", + " ax_ref.set_title(\"Reference\")\n", + "\n", + " if visible_pitches:\n", + " pitch_min = min(visible_pitches) - 1\n", + " pitch_max = max(visible_pitches) + 1\n", + " ax_response.set_ylim(pitch_min, pitch_max)\n", + " ax_ref.set_ylim(pitch_min, pitch_max)\n", + "\n", + " for detail in selected_details:\n", + " operation = detail[\"operation_type\"]\n", + " reference_index = detail.get(\"reference_index\")\n", + " response_index = detail.get(\"response_index\")\n", + "\n", + " if reference_index is not None and response_index is not None:\n", + " ref_event = ref_events[reference_index - 1]\n", + " response_event = response_events[response_index - 1]\n", + "\n", + " ref_x, ref_y = get_event_anchor(ref_event)\n", + " response_x, response_y = get_event_anchor(response_event)\n", + "\n", + " response_visible = response_start <= response_x <= response_end\n", + " reference_visible = ref_start <= ref_x <= ref_end\n", + "\n", + " if operation == \"match\":\n", + " line_style = \"-\"\n", + " line_width = 0.8\n", + " line_alpha = 0.35\n", + " line_colour = match_colour\n", + " else:\n", + " line_style = \"--\"\n", + " line_width = 2.2\n", + " line_alpha = 0.9\n", + " line_colour = replacement_colour\n", + "\n", + " if response_visible and reference_visible:\n", + " connector = ConnectionPatch(\n", + " xyA=(response_x, response_y),\n", + " coordsA=ax_response.transData,\n", + " xyB=(ref_x, ref_y),\n", + " coordsB=ax_ref.transData,\n", + " linestyle=line_style,\n", + " linewidth=line_width,\n", + " color=line_colour,\n", + " alpha=line_alpha,\n", + " clip_on=True,\n", + " zorder=2,\n", + " )\n", + "\n", + " fig.add_artist(connector)\n", + "\n", + " missing_count = 0\n", + " extra_count = 0\n", + "\n", + " for detail in selected_details:\n", + " operation = detail[\"operation_type\"]\n", + "\n", + " if operation == \"missing\":\n", + " reference_index = detail.get(\"reference_index\")\n", + "\n", + " if reference_index is not None:\n", + " ref_event = ref_events[reference_index - 1]\n", + "\n", + " for note in ref_event[\"notes\"]:\n", + " marker_x = note[\"start\"]\n", + " marker_y = note[\"pitch\"]\n", + "\n", + " if ref_start <= marker_x <= ref_end:\n", + " ax_ref.scatter(\n", + " marker_x, marker_y, marker=\"x\",\n", + " s=130, linewidths=3,\n", + " color=missing_colour,\n", + " zorder=10,\n", + " )\n", + "\n", + " missing_count += 1\n", + "\n", + " elif operation == \"extra\":\n", + " response_index = detail.get(\"response_index\")\n", + "\n", + " if response_index is not None:\n", + " response_event = response_events[response_index - 1]\n", + "\n", + " for note in response_event[\"notes\"]:\n", + " marker_x = note[\"start\"]\n", + " marker_y = note[\"pitch\"]\n", + "\n", + " if response_start <= marker_x <= response_end:\n", + " ax_response.scatter(\n", + " marker_x, marker_y, marker=\"^\",\n", + " s=110, color=extra_colour,\n", + " edgecolors=\"black\",\n", + " linewidths=1, zorder=10,\n", + " )\n", + "\n", + " extra_count += 1\n", + "\n", + " legend_items = [\n", + " Line2D([0], [0], color=note_colour, linewidth=5, label=\"MIDI note\"),\n", + " Line2D([0], [0], color=match_colour, linestyle=\"-\", linewidth=1.2, label=\"Matched event\"),\n", + " Line2D([0], [0], color=replacement_colour, linestyle=\"--\", \n", + " linewidth=2.2, label=\"Replacement event\"),\n", + " Line2D([0], [0], color=missing_colour, marker=\"x\", linestyle=\"None\", \n", + " markersize=9, markeredgewidth=2.5, label=\"Missing note\"),\n", + " Line2D([0], [0], color=extra_colour, marker=\"^\", markeredgecolor=\"black\", \n", + " linestyle=\"None\", markersize=9, label=\"Extra note\"),\n", + " ]\n", + "\n", + " ax_response.legend(\n", + " handles=legend_items,\n", + " loc=\"upper right\",\n", + " framealpha=0.9,\n", + " )\n", + "\n", + " ax_response.grid(axis=\"x\", alpha=0.25)\n", + " ax_ref.grid(axis=\"x\", alpha=0.25)\n", + "\n", + " fig.suptitle(\"Event-level alignment with one connector per event\")\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + " print(\"Selected operations:\", len(selected_details))\n", + " print(\"Missing note markers:\", missing_count)\n", + " print(\"Extra note markers:\", extra_count)\n", + "\n", + "\n", + "plot_alignment(ref_events, response_events, event_details, ref_start=70.0, ref_end=80.0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## limitation\n", + "\n", + "- The evaluation uses the nASAP note-alignment benchmark, which is designed to evaluate the alignment results of between music score and expert performance during competitions. In contrast, the objective of this project is to generate educational feedback for student practice, however, there is no large-scale public dataset contains students' practice MIDI and references. \n", + "\n", + "- The default alignment parameters (e.g., gap penalty, timing tolerance and chord onset window) were chosen empirically and may not be optimal for all musical styles, therefore these parameters are designed to be allowed for configuration.\n", + "\n", + "- My alignment algorithm is event-level, however, the grouping of chords currently relies on a fixed onset threshold, identification of broken chords (Arpeggios), ornaments and other highly expressive performance strategies are left as future work." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "compareMusic", + "language": "python", + "name": "comparemusic" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/optimise_alignment.ipynb b/notebooks/optimise_alignment.ipynb new file mode 100644 index 0000000..70c7f6b --- /dev/null +++ b/notebooks/optimise_alignment.ipynb @@ -0,0 +1,543 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "67c86ddb", + "metadata": {}, + "source": [ + "The `event_alignment_ED` is basically an O(N×M) dynamic programming procedure, and is implemented as a nested for-loop. For a Bach fugue with roughly 1,400 events on each side, this already amounts to close to 2 million cell computations. For a substantially longer piece such as a Liszt piano sonata (~16,000 notes), the same recursion would require on the order of 2.5×10⁸ cell computations. Consider that students' practice is usually not that long as the sonata, `max_notes = 3500` was introduced as a hard cut-off to skip such pieces during evaluation.\n", + "\n", + "In order to make the evaluation more comprehensive and improve the algorithm, can consider optimisation methods such as:\n", + "\n", + "**Precomputes the whole cost matrix:**\n", + "- using numpy broadcasting for note-vs-note pairs, instead of calling compute_event_cost() once per cell in a pure Python loop. \n", + "- chord vs chord: encode each chord as a 12-dimensional pitch-class binary vector, then compute all pairwise Hamming distances using broadcasting\n", + "- note vs chord (type mismatch): fill directly with `gap_penalty`\n", + "\n", + "\n", + "**Add a band around the diagonal** (future work)\n", + "- See Muller's book section 3.2.2.3 (Sakoe-Chiba band used in DTW), instead of filling the whole (N+1) x (M+1) matrix, this constrained version only fills a band around the diagonal. This is safe as long as the student performance is not wildly different in length from the reference (which is true in almost all practice scenarios). Cells outside the band are treated as \"too expensive\", so the aligner will never choose a path through them.\n", + "\n", + "**Numba** (future work)\n", + "\n", + "**Multiprocessing** during algorithm evaluation with many MIDI files" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "11c82556", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-08T19:50:26.720009Z", + "iopub.status.busy": "2026-07-08T19:50:26.719339Z", + "iopub.status.idle": "2026-07-08T19:50:28.604012Z", + "shell.execute_reply": "2026-07-08T19:50:28.602549Z" + } + }, + "outputs": [], + "source": [ + "import json\n", + "import os\n", + "import random\n", + "import time\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from evaluation_function.compare_MIDI import (\n", + " compute_event_cost,\n", + " group_notes_into_events,\n", + " normalize_start_times,\n", + " event_alignment_ED,\n", + " DEFAULT_GAP_PENALTY,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "ccba850e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-08T19:50:28.607168Z", + "iopub.status.busy": "2026-07-08T19:50:28.606866Z", + "iopub.status.idle": "2026-07-08T19:50:28.619428Z", + "shell.execute_reply": "2026-07-08T19:50:28.618085Z" + } + }, + "outputs": [], + "source": [ + "def build_cost_matrix(response_events, ref_events, gap_penalty=DEFAULT_GAP_PENALTY):\n", + " \"\"\"\n", + " Precompute the full (N x M) event-alignment cost matrix using vectorised\n", + " NumPy broadcasting, instead of calling compute_event_cost() one cell at a\n", + " time inside a Python loop. This also removes the redundant cost\n", + " computation that used to happen a second time during backtracking.\n", + "\n", + " Args:\n", + " response_events: list of event dicts (from group_notes_into_events)\n", + " ref_events: list of event dicts (from group_notes_into_events)\n", + " gap_penalty: cost used when event types (note vs chord) do not match\n", + "\n", + " Returns:\n", + " numpy array of shape (N, M): cost of aligning each response event\n", + " to each reference event, matching compute_event_cost() exactly.\n", + " \"\"\"\n", + " N = len(response_events)\n", + " M = len(ref_events)\n", + "\n", + " # Build simple per-event arrays: is this event a chord, and (if it is a\n", + " # single note) what is its pitch.\n", + " res_is_chord = np.array([event[\"event_type\"] == \"chord\" for event in response_events])\n", + " ref_is_chord = np.array([event[\"event_type\"] == \"chord\" for event in ref_events])\n", + "\n", + " res_pitch = np.array([\n", + " event[\"notes\"][0][\"pitch\"] if event[\"event_type\"] == \"note\" else 0\n", + " for event in response_events\n", + " ])\n", + " ref_pitch = np.array([\n", + " event[\"notes\"][0][\"pitch\"] if event[\"event_type\"] == \"note\" else 0\n", + " for event in ref_events\n", + " ])\n", + "\n", + " # Note-vs-note cost: vectorised absolute pitch difference for every pair.\n", + " # Shape (N, 1) - shape (1, M) broadcasts to (N, M)\n", + " note_cost_matrix = np.abs(res_pitch.reshape(N, 1) - ref_pitch.reshape(1, M))\n", + "\n", + " # Chord-vs-chord cost: build a 12-dim binary pitch-class vector per chord,\n", + " # then compute Hamming distance for every pair using broadcasting.\n", + " res_pitch_vector = np.zeros((N, 12), dtype=int)\n", + " for i in range(N):\n", + " if res_is_chord[i]:\n", + " for note in response_events[i][\"notes\"]:\n", + " res_pitch_vector[i, note[\"pitch\"] % 12] = 1\n", + "\n", + " ref_pitch_vector = np.zeros((M, 12), dtype=int)\n", + " for j in range(M):\n", + " if ref_is_chord[j]:\n", + " for note in ref_events[j][\"notes\"]:\n", + " ref_pitch_vector[j, note[\"pitch\"] % 12] = 1\n", + "\n", + " # (N, 1, 12) vs (1, M, 12) broadcasts to (N, M, 12); summing the last\n", + " # axis gives the Hamming distance for every (response, ref) pair at once.\n", + " differs = res_pitch_vector.reshape(N, 1, 12) != ref_pitch_vector.reshape(1, M, 12)\n", + " chord_cost_matrix = differs.sum(axis=2)\n", + "\n", + " # Type-mismatch mask: True where one side is a note and the other a chord.\n", + " type_mismatch = res_is_chord.reshape(N, 1) != ref_is_chord.reshape(1, M)\n", + " both_chords = res_is_chord.reshape(N, 1) & ref_is_chord.reshape(1, M)\n", + "\n", + " # Combine the three cases -- np.where(condition, true, false)\n", + " cost_matrix = np.where(\n", + " type_mismatch,\n", + " gap_penalty,\n", + " np.where(both_chords, chord_cost_matrix, note_cost_matrix),\n", + " )\n", + "\n", + " return cost_matrix.astype(int)\n", + "\n", + "\n", + "def event_alignment_ED_vectorised(response_events, ref_events, gap_penalty=DEFAULT_GAP_PENALTY):\n", + " \"\"\"\n", + " Same algorithm as the production event_alignment_ED(), but the N x M\n", + " substitution costs are looked up from a precomputed cost matrix instead\n", + " of being recomputed on every DP cell and again during backtracking.\n", + "\n", + " Args:\n", + " response_events: list of event dicts from group_notes_into_events\n", + " ref_events: list of event dicts from group_notes_into_events\n", + " gap_penalty: cost of leaving an event unaligned (insertion/deletion)\n", + "\n", + " Returns:\n", + " operations: list of operation dicts, same format as event_alignment_ED()\n", + " D: accumulated cost matrix, shape (N+1, M+1)\n", + " \"\"\"\n", + " if \"event_type\" not in response_events[0]:\n", + " response_events = group_notes_into_events(response_events)\n", + " if \"event_type\" not in ref_events[0]:\n", + " ref_events = group_notes_into_events(ref_events)\n", + "\n", + " N = len(response_events)\n", + " M = len(ref_events)\n", + "\n", + " # Precompute every substitution cost once, instead of calling\n", + " # compute_event_cost() inside the double loop below.\n", + " cost_matrix = build_cost_matrix(response_events, ref_events, gap_penalty)\n", + "\n", + " D = np.zeros((N + 1, M + 1), dtype=int)\n", + " for n in range(1, N + 1):\n", + " D[n, 0] = n * gap_penalty\n", + " for m in range(1, M + 1):\n", + " D[0, m] = m * gap_penalty\n", + "\n", + " for n in range(1, N + 1):\n", + " for m in range(1, M + 1):\n", + " replace_cost = cost_matrix[n - 1, m - 1]\n", + " D[n, m] = min(\n", + " D[n - 1, m - 1] + replace_cost,\n", + " D[n - 1, m] + gap_penalty,\n", + " D[n, m - 1] + gap_penalty,\n", + " )\n", + "\n", + " operations = []\n", + " n, m = N, M\n", + " while n > 0 or m > 0:\n", + " if n == 0:\n", + " operations.append({\n", + " \"type\": \"missing\",\n", + " \"response_idx\": None,\n", + " \"reference_idx\": m - 1,\n", + " \"cost\": gap_penalty,\n", + " })\n", + " m -= 1\n", + " elif m == 0:\n", + " operations.append({\n", + " \"type\": \"extra\",\n", + " \"response_idx\": n - 1,\n", + " \"reference_idx\": None,\n", + " \"cost\": gap_penalty,\n", + " })\n", + " n -= 1\n", + " else:\n", + " replace_cost = cost_matrix[n - 1, m - 1]\n", + " diag = D[n - 1, m - 1] + replace_cost\n", + " up = D[n - 1, m] + gap_penalty\n", + " left = D[n, m - 1] + gap_penalty\n", + " min_cost = min(diag, up, left)\n", + "\n", + " if min_cost == diag:\n", + " operations.append({\n", + " \"type\": \"match\" if replace_cost == 0 else \"replacement\",\n", + " \"response_idx\": n - 1,\n", + " \"reference_idx\": m - 1,\n", + " \"cost\": int(replace_cost),\n", + " })\n", + " n, m = n - 1, m - 1\n", + " elif min_cost == up:\n", + " operations.append({\n", + " \"type\": \"extra\",\n", + " \"response_idx\": n - 1,\n", + " \"reference_idx\": None,\n", + " \"cost\": gap_penalty,\n", + " })\n", + " n -= 1\n", + " else:\n", + " operations.append({\n", + " \"type\": \"missing\",\n", + " \"response_idx\": None,\n", + " \"reference_idx\": m - 1,\n", + " \"cost\": gap_penalty,\n", + " })\n", + " m -= 1\n", + "\n", + " operations.reverse()\n", + " return operations, D" + ] + }, + { + "cell_type": "markdown", + "id": "e1ff03f8", + "metadata": {}, + "source": [ + "**Verify Equivalence with test cases**" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "95a6044d", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-08T19:50:28.632709Z", + "iopub.status.busy": "2026-07-08T19:50:28.632444Z", + "iopub.status.idle": "2026-07-08T19:50:29.078084Z", + "shell.execute_reply": "2026-07-08T19:50:29.076689Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loaded 14 test cases:\n", + " - twinkle_perfect (long_melody)\n", + " - twinkle_scattered_errors (long_melody)\n", + " - twinkle_repeated_note_correct (repeated_notes)\n", + " - twinkle_repeated_note_missing (repeated_notes)\n", + " - twinkle_repeated_note_extra (repeated_notes)\n", + " - twinkle_hesitation_mid_phrase (hesitation)\n", + " - twinkle_hesitation_plus_missing (hesitation)\n", + " - twinkle_long_break_no_notes_lost (long_break)\n", + " - twinkle_long_break_with_skip (long_break)\n", + " - chord_all_correct (broken_chord)\n", + " - chord_one_wrong_note (broken_chord)\n", + " - chord_entirely_missing (broken_chord)\n", + " - chord_arpeggiated_within_window (broken_chord)\n", + " - chord_arpeggiated_beyond_window (broken_chord)\n" + ] + } + ], + "source": [ + "cwd = os.getcwd()\n", + "dir = os.path.dirname(cwd)\n", + "TEST_CASE_PATH = os.path.join(dir, \"data\", \"longMIDIsequence.json\")\n", + "\n", + "# Fall back to the current directory if the notebook is run from elsewhere.\n", + "if not os.path.exists(TEST_CASE_PATH):\n", + " TEST_CASE_PATH = \"longMIDIsequence.json\"\n", + "\n", + "with open(TEST_CASE_PATH) as f:\n", + " test_case_data = json.load(f)\n", + "\n", + "test_cases = test_case_data[\"test_cases\"]\n", + "print(\"Loaded\", len(test_cases), \"test cases:\")\n", + "for case in test_cases:\n", + " print(\" -\", case[\"name\"], \"(\" + case[\"category\"] + \")\")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "52ab0dea", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PASSED - twinkle_perfect\n", + "PASSED - twinkle_scattered_errors\n", + "PASSED - twinkle_repeated_note_correct\n", + "PASSED - twinkle_repeated_note_missing\n", + "PASSED - twinkle_repeated_note_extra\n", + "PASSED - twinkle_hesitation_mid_phrase\n", + "PASSED - twinkle_hesitation_plus_missing\n", + "PASSED - twinkle_long_break_no_notes_lost\n", + "PASSED - twinkle_long_break_with_skip\n", + "PASSED - chord_all_correct\n", + "PASSED - chord_one_wrong_note\n", + "PASSED - chord_entirely_missing\n", + "PASSED - chord_arpeggiated_within_window\n", + "PASSED - chord_arpeggiated_beyond_window\n", + "\n", + "ALL TEST CASES PASSED: vectorised alignment is identical to production.\n" + ] + } + ], + "source": [ + "all_passed = True\n", + "\n", + "for case in test_cases:\n", + " response_notes = normalize_start_times(case[\"response\"][\"notes\"])\n", + " ref_notes = normalize_start_times(case[\"reference\"][\"notes\"])\n", + " response_events = group_notes_into_events(response_notes)\n", + " ref_events = group_notes_into_events(ref_notes)\n", + "\n", + " production_ops, production_D = event_alignment_ED(response_events, ref_events)\n", + " vectorised_ops, vectorised_D = event_alignment_ED_vectorised(response_events, ref_events)\n", + "\n", + " ops_match = production_ops == vectorised_ops\n", + " matrix_match = np.array_equal(production_D, vectorised_D)\n", + " passed = ops_match and matrix_match\n", + "\n", + " if not passed:\n", + " all_passed = False\n", + "\n", + " status = \"PASSED\" if passed else \"FAILED\"\n", + " print(status, \"-\", case[\"name\"])\n", + "\n", + "print()\n", + "if all_passed:\n", + " print(\"ALL TEST CASES PASSED: vectorised alignment is identical to production.\")\n", + "else:\n", + " print(\"Some test cases failed, see above.\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a38e9f27", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "note_count~50 events=41x43 match=True\n", + "note_count~300 events=246x240 match=True\n", + "note_count~800 events=657x651 match=True\n", + "\n", + "If all lines above say match=True, the vectorised version is verified correct at scale.\n" + ] + } + ], + "source": [ + "def make_random_notes(count, chord_probability=0.15, seed=0):\n", + " \"\"\"\n", + " Generate a random note stream for stress-testing, occasionally grouping\n", + " several notes into a chord (same onset time) to exercise the chord-vs-chord\n", + " and chord-vs-note code paths.\n", + "\n", + " Args:\n", + " count: int, approximate number of notes to generate\n", + " chord_probability: float, chance that a given onset becomes a chord\n", + " seed: int, random seed for reproducibility\n", + "\n", + " Returns:\n", + " list of note dicts with keys pitch, start, duration\n", + " \"\"\"\n", + " rng = random.Random(seed)\n", + " notes = []\n", + " t = 0.0\n", + " while len(notes) < count:\n", + " t += rng.uniform(0.2, 0.6)\n", + " if rng.random() < chord_probability:\n", + " chord_size = rng.choice([2, 3])\n", + " root = rng.randint(48, 80)\n", + " offsets = rng.sample([0, 3, 4, 7, 8, 10], chord_size - 1)\n", + " pitches = [root] + [root + offset for offset in offsets]\n", + " for pitch in pitches:\n", + " notes.append({\"pitch\": pitch, \"start\": t, \"duration\": 0.4})\n", + " else:\n", + " notes.append({\"pitch\": rng.randint(48, 84), \"start\": t, \"duration\": 0.4})\n", + " return notes[:count]\n", + "\n", + "\n", + "for size in [50, 300, 800]:\n", + " res_notes = make_random_notes(size, seed=1)\n", + " ref_notes_r = make_random_notes(size, seed=2)\n", + " res_events = group_notes_into_events(normalize_start_times(res_notes))\n", + " ref_events_r = group_notes_into_events(normalize_start_times(ref_notes_r))\n", + "\n", + " production_ops, production_D = event_alignment_ED(res_events, ref_events_r)\n", + " vectorised_ops, vectorised_D = event_alignment_ED_vectorised(res_events, ref_events_r)\n", + " match = production_ops == vectorised_ops and np.array_equal(production_D, vectorised_D)\n", + "\n", + " print(\"note_count~\" + str(size), \" events=\" + str(len(res_events)) + \"x\" + str(len(ref_events_r)), \" match=\" + str(match))\n", + "\n", + "print()\n", + "print(\"If all lines above say match=True, the vectorised version is verified correct at scale.\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "2aab57c9", + "metadata": {}, + "source": [ + "**Timing Comparison**\n", + "\n", + "Measure the runtime of both implementations at several data sizes, and plot \"time vs. piece size\" " + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "d310e8fb", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-08T19:50:29.081318Z", + "iopub.status.busy": "2026-07-08T19:50:29.079824Z", + "iopub.status.idle": "2026-07-08T19:50:30.631757Z", + "shell.execute_reply": "2026-07-08T19:50:30.630381Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "N=M~50: production=0.0013s vectorised=0.0023s speedup=0.6x\n", + "N=M~100: production=0.0047s vectorised=0.0050s speedup=0.9x\n", + "N=M~200: production=0.0200s vectorised=0.0170s speedup=1.2x\n", + "N=M~400: production=0.1051s vectorised=0.0684s speedup=1.5x\n", + "N=M~800: production=0.3403s vectorised=0.2814s speedup=1.2x\n", + "N=M~1500: production=1.2428s vectorised=1.0064s speedup=1.2x\n" + ] + } + ], + "source": [ + "sizes = [50, 100, 200, 400, 800, 1500]\n", + "old_times = []\n", + "new_times = []\n", + "\n", + "for size in sizes:\n", + " res_notes = make_random_notes(size, seed=3)\n", + " ref_notes_r = make_random_notes(size, seed=4)\n", + " res_events = group_notes_into_events(normalize_start_times(res_notes))\n", + " ref_events_r = group_notes_into_events(normalize_start_times(ref_notes_r))\n", + "\n", + " t0 = time.perf_counter()\n", + " event_alignment_ED(res_events, ref_events_r)\n", + " t1 = time.perf_counter()\n", + " event_alignment_ED_vectorised(res_events, ref_events_r)\n", + " t2 = time.perf_counter()\n", + "\n", + " old_time = t1 - t0\n", + " new_time = t2 - t1\n", + " old_times.append(old_time)\n", + " new_times.append(new_time)\n", + "\n", + " speedup = old_time / new_time if new_time > 0 else float(\"inf\")\n", + " print(\"N=M~\" + str(size) + \": production=\" + format(old_time, \".4f\") + \"s vectorised=\" + format(new_time, \".4f\") + \"s speedup=\" + format(speedup, \".1f\") + \"x\")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "0335fb99", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-08T19:50:30.633793Z", + "iopub.status.busy": "2026-07-08T19:50:30.633523Z", + "iopub.status.idle": "2026-07-08T19:50:30.803542Z", + "shell.execute_reply": "2026-07-08T19:50:30.802265Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(8, 5))\n", + "plt.plot(sizes, old_times, marker=\"o\", label=\"Production event_alignment_ED\")\n", + "plt.plot(sizes, new_times, marker=\"o\", label=\"Vectorised event_alignment_ED\")\n", + "plt.xlabel(\"Number of events (N = M)\")\n", + "plt.ylabel(\"Time (seconds)\")\n", + "plt.title(\"Full alignment time: production vs vectorised\")\n", + "plt.legend()\n", + "plt.grid(True, alpha=0.3)\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "compareMusic", + "language": "python", + "name": "comparemusic" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/poetry.lock b/poetry.lock index db22435..34eb223 100644 --- a/poetry.lock +++ b/poetry.lock @@ -430,7 +430,7 @@ files = [ {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"}, {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, ] -markers = {main = "os_name == \"nt\" or sys_platform == \"win32\"", dev = "sys_platform == \"win32\""} +markers = {main = "os_name == \"nt\" or sys_platform == \"win32\" or platform_system == \"Windows\"", dev = "sys_platform == \"win32\""} [[package]] name = "contourpy" @@ -2662,6 +2662,27 @@ files = [ {file = "tomlkit-0.15.0.tar.gz", hash = "sha256:7d1a9ecba3086638211b13814ea79c90dd54dd11993564376f3aa92271f5c7a3"}, ] +[[package]] +name = "tqdm" +version = "4.68.4" +description = "Fast, Extensible Progress Meter" +optional = false +python-versions = ">=3.8" +groups = ["main"] +files = [ + {file = "tqdm-4.68.4-py3-none-any.whl", hash = "sha256:5168118b2368f48c561afda8020fd79195b1bdb0bdf8086b88442c267a315dc2"}, + {file = "tqdm-4.68.4.tar.gz", hash = "sha256:19829c9673638f2a0b8617da4cdcb927e831cd88bcfcb6e78d42a4d1af131520"}, +] + +[package.dependencies] +colorama = {version = "*", markers = "platform_system == \"Windows\""} + +[package.extras] +discord = ["envwrap", "requests"] +notebook = ["ipywidgets (>=6)"] +slack = ["envwrap", "slack-sdk"] +telegram = ["envwrap", "requests"] + [[package]] name = "trove-classifiers" version = "2026.6.1.19" @@ -3044,4 +3065,4 @@ cffi = ["cffi (>=1.17,<2.0) ; platform_python_implementation != \"PyPy\" and pyt [metadata] lock-version = "2.1" python-versions = "^3.11" -content-hash = "e2572e64cfb65e24d91c1cf604f2e59440d86cac35507649a2e522dba0a5a318" +content-hash = "ecdcfccfc009831d6b449c0b55f8f228de58f0537e64a57a2ae1843d238021af" diff --git a/pyproject.toml b/pyproject.toml index 9a6a00e..979f0bc 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -20,6 +20,7 @@ numpy = "^2.4.6" matplotlib = "^3.11.0" pretty-midi = "^0.2.11" pandas = "^3.0.3" +tqdm = "^4.68.4" [tool.poetry.group.dev.dependencies] pytest = "^8.2.2"