diff --git a/.gitignore b/.gitignore index ce62690..1d25edb 100644 --- a/.gitignore +++ b/.gitignore @@ -134,7 +134,10 @@ dmypy.json # Test reports reports/ -# PianoVAM dataset -notebooks/data/ +# output data +/outputs -notebooks/outputs \ No newline at end of file +# large dataset +/data/asap-dataset +/data/PianoVAM_v1 +/data/real_recordings \ No newline at end of file diff --git a/evaluation_function/audio_processing.py b/evaluation_function/audio_processing.py index 4447f12..2efeaac 100644 --- a/evaluation_function/audio_processing.py +++ b/evaluation_function/audio_processing.py @@ -6,11 +6,9 @@ compare_performance_ED. Pipeline overview: - 1. loading the Basic Pitch model - 2. running the model on one audio file (or re-decoding already - computed raw model output) into a list of note dictionaries - 3. post-processing - 4. converting notes into the format compare_performance_ED expects + 1. run Basic Pitch + 2. optionally apply targeted post-processing steps + 3. return notes ready to hand to compare_MIDI.py """ @@ -26,10 +24,11 @@ # Parameters # ------------------------------------------------------------------------------ # configuration values for the Basic Pitch model (decoder) -ONSET_THRESHOLD = 0.7 # Minimum amplitude of an onset activation to be considered an onset -FRAME_THRESHOLD = 0.2 # Minimum amplitude of a frame activation for a note to remain 'on' -MINIMUM_NOTE_LENGTH = 75.0 # The minimum allowed note length in frames +ONSET_THRESHOLD = 0.6 # Minimum amplitude of an onset activation to be considered an onset +FRAME_THRESHOLD = 0.3 # Minimum amplitude of a frame activation for a note to remain 'on' +MINIMUM_NOTE_LENGTH = 50.0 # The minimum allowed note length in frames MELODIA_TRICK = False # Whether to use the "Melodia trick" to improve pitch estimation for monophonic instruments + # configuration values for the post-processing layer MIN_GAP_SECONDS = 0.5 MAX_LEADING_NOTES = 3 @@ -46,7 +45,7 @@ # Helper function to check if the response is audio -# ------------------------------------------------------------------------------ +# --------------------------------------------------------------------- def is_audio_input(response): """ Return True if response looks like an audio file that needs to go @@ -74,10 +73,10 @@ def is_audio_input(response): # Load the model -# ------------------------------------------------------------------------------ +# --------------------------------------------------------------------- def load_basic_pitch_model(model_path=ICASSP_2022_MODEL_PATH): """ - Load the Basic Pitch model once. + Load the pretrained Basic Pitch model once. """ return Model(model_path) @@ -162,25 +161,33 @@ def remove_leading_extra_notes(notes, - at least min_following_notes remain after the gap; - the possible performance start is within max_search_seconds. """ + # if there are no notes, return an empty list if len(notes) == 0: return [] + # sort the notes by onset time sorted_notes = sorted(notes, key=lambda note: note["onset"]) start_index = 0 + # find the first index where the gap to the next note is large enough for i in range(len(sorted_notes) - 1): current_onset = sorted_notes[i]["onset"] next_onset = sorted_notes[i + 1]["onset"] gap = next_onset - current_onset - leading_note_count = i + 1 - following_note_count = len(sorted_notes) - leading_note_count + leading_note_count = i + 1 # number of notes before the gap + following_note_count = len(sorted_notes) - leading_note_count # number of notes after the gap + # check if the gap is large enough is_large_gap = gap >= min_gap_seconds + # ensure number of leading notes does not exceed the maximum allowed has_few_leading_notes = leading_note_count <= max_leading_notes + # ensure number of following notes meets the minimum required has_enough_following_notes = following_note_count >= min_following_notes + # search the first few seconds only, to avoid removing valid early notes in long performances is_near_beginning = next_onset <= max_search_seconds + # if all conditions are met, move on to the next note if ( is_large_gap and has_few_leading_notes @@ -189,9 +196,9 @@ def remove_leading_extra_notes(notes, ): start_index = i + 1 - processed_notes = [] - - for note in sorted_notes[start_index:]: + processed_notes = [] # create a new list to hold the processed notes i.e. notes to be kept + # iterate over the notes starting from the determined start index + for note in sorted_notes[start_index:]: processed_notes.append(note.copy()) return processed_notes @@ -218,7 +225,7 @@ def merge_same_pitch_notes(notes, notes_by_pitch = {} for note in notes: pitch = note["pitch"] - # initialize the list for this pitch if it doesn't exist + # create a new list for this pitch if it doesn't exist in the dictionary yet if pitch not in notes_by_pitch: notes_by_pitch[pitch] = [] # append a copy of the note to avoid modifying the original @@ -226,6 +233,7 @@ def merge_same_pitch_notes(notes, merged_notes = [] for pitch_notes in notes_by_pitch.values(): + # sort the notes by onset time to ensure they are processed in order pitch_notes = sorted(pitch_notes, key=lambda note: note["onset"]) current_note = pitch_notes[0].copy() @@ -235,7 +243,7 @@ def merge_same_pitch_notes(notes, next_duration = next_note["offset"] - next_note["onset"] # Check if the gap is within the allowed range is_close_in_time = (-max_gap_seconds <= gap <= max_gap_seconds) - # Check if at least one of the notes is short enough to be considered a fragment + # Check if both notes are short enough to be considered a fragment looks_like_fragment = ( current_duration <= max_fragment_duration and next_duration <= max_fragment_duration @@ -243,9 +251,11 @@ def merge_same_pitch_notes(notes, should_merge = is_close_in_time and looks_like_fragment if should_merge: + # Merge the two notes by updating the offset and duration of the current note new_offset = max(current_note["offset"], next_note["offset"]) current_note["offset"] = new_offset current_note["duration"] = new_offset - current_note["onset"] + # If both notes have a velocity, take the maximum to represent the merged note if ("velocity" in current_note) and ("velocity" in next_note): current_note["velocity"] = max(current_note["velocity"], next_note["velocity"]) else: @@ -296,8 +306,8 @@ def build_compare_midi_input(notes, duration_key="duration"): # --------------------------------------------------------------------- def transcription_pipeline(audio_path, model, apply_postprocessing=True): """ - Full production pipeline: run Basic Pitch, optionally apply Layer 2 - post-processing, and return notes ready to hand to compare_MIDI.py. + Full production pipeline: run Basic Pitch, optionally apply post-processing, + and return notes ready to hand to compare_MIDI.py. Returns (compare_midi_input, predicted_notes, runtime_seconds). """ diff --git a/evaluation_function/compare_MIDI.py b/evaluation_function/compare_MIDI.py index 445aefb..8d72cc4 100644 --- a/evaluation_function/compare_MIDI.py +++ b/evaluation_function/compare_MIDI.py @@ -11,8 +11,8 @@ estimate_global_duration_scale Step 3 -- event_level_feedback (note/chord-level feedback) Step 4 -- compute_stats (summary counts) - Step 5 -- generate_feedback_message (human-readable text) - Step 6 -- is_correct (overall pass/fail judgement) + Step 5 -- version 1: generate_feedback_message (human-readable text) + version 2: polished_feedback_message (polished version of human-readable text) """ @@ -22,7 +22,7 @@ # Default thresholds / parameters # Teachers can override any of these via the params dict in evaluation_function. # ------------------------------------------------------------------------------ -# Gap penalty: cost of leaving a note unaligned (insertion/deletion) +# Gap penalty: cost of leaving an event unaligned (insertion/deletion) DEFAULT_GAP_PENALTY = 6 # Timing: |response_start - predicted_start| / Inter-Onset Interval (IOI) must be below this. @@ -85,11 +85,12 @@ def identify_chord_name(notes): pitch_classes = get_pitch_class_set(notes) for root_pc in pitch_classes: + # Normalise the pitch classes relative to the root note, so that the root is 0. normalised = set((pc - root_pc) % 12 for pc in pitch_classes) for chord_type, template in CHORD_TEMPLATES.items(): if normalised == template: - root_name = PITCH_CLASS_NAMES[root_pc] - return root_name + " " + chord_type + root_name = PITCH_CLASS_NAMES[root_pc] # convert root pitch class to name + return root_name + " " + chord_type # return e.g. "C major" return "unknown chord" @@ -97,7 +98,7 @@ def compute_chord_accuracy(ref_notes, res_notes): """ 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.: + so that the score is sensitive to octave errors: A = (C - I + |y|) / (2 * |y|) where: C = number of correctly matched notes @@ -116,8 +117,8 @@ def compute_chord_accuracy(ref_notes, res_notes): missing_pitches: sorted list of missing MIDI pitches extra_pitches: sorted list of extra MIDI pitches """ - ref_counts = Counter(note["pitch"] for note in ref_notes) - res_counts = Counter(note["pitch"] for note in res_notes) + ref_counts = Counter(note["pitch"] for note in ref_notes) # count each pitch in the reference chord + res_counts = Counter(note["pitch"] for note in res_notes) # count each pitch in the response chord correct_pitches = [] missing_pitches = [] @@ -125,28 +126,28 @@ def compute_chord_accuracy(ref_notes, res_notes): # 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)) + all_pitches = sorted(set(ref_counts) | set(res_counts)) # union of all distinct pitches in both chords for pitch in all_pitches: - matched = min(ref_counts[pitch], res_counts[pitch]) - correct_pitches.extend([pitch] * matched) - if ref_counts[pitch] > matched: + matched = min(ref_counts[pitch], res_counts[pitch]) # number of copies that can be matched + correct_pitches.extend([pitch] * matched) + if ref_counts[pitch] > matched: # if there are more copies in the reference than matched, they are missing missing_pitches.extend( [pitch] * (ref_counts[pitch] - matched) ) - if res_counts[pitch] > matched: + if res_counts[pitch] > matched: # if there are more copies in the response than matched, they are extra 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 + C = len(correct_pitches) # number of correctly matched notes + I = len(extra_pitches) # number of extra notes played + 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)) + accuracy = (C - I + ref_size) / (2.0 * ref_size) + accuracy = max(0.0, min(1.0, accuracy)) # clamp to [0, 1] in case of negative values return accuracy, correct_pitches, missing_pitches, extra_pitches @@ -266,8 +267,8 @@ def group_notes_into_events(notes, chord_onset_window=DEFAULT_CHORD_ONSET_WINDOW def build_cost_matrix(response_events, ref_events, gap_penalty=DEFAULT_GAP_PENALTY): """ 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 + NumPy broadcasting, instead of computing event cost one at a + time inside a loop. This also removes the redundant cost computation that used to happen a second time during backtracking. Args: @@ -287,6 +288,7 @@ def build_cost_matrix(response_events, ref_events, gap_penalty=DEFAULT_GAP_PENAL 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]) + # For note events, extract the pitch; for chords, use 0 as a placeholder. res_pitch = np.array([ event["notes"][0]["pitch"] if event["event_type"] == "note" else 0 for event in response_events @@ -304,24 +306,24 @@ def build_cost_matrix(response_events, ref_events, gap_penalty=DEFAULT_GAP_PENAL # 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 + if res_is_chord[i]: # only fill in the pitch vector for chords + for note in response_events[i]["notes"]: # iterate over all notes in the chord + res_pitch_vector[i, note["pitch"] % 12] = 1 # set the corresponding pitch class to 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 + 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) + differs = (res_pitch_vector.reshape(N, 1, 12) != ref_pitch_vector.reshape(1, M, 12)) # shape (N, M, 12) + chord_cost_matrix = differs.sum(axis=2) # sum over the last axis to get the Hamming distance for each pair # 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) + 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( @@ -335,9 +337,9 @@ def build_cost_matrix(response_events, ref_events, gap_penalty=DEFAULT_GAP_PENAL def event_alignment_ED(response_events, ref_events, gap_penalty=DEFAULT_GAP_PENALTY): """ - 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. + Aligns response and reference events using edit distance. + Costs are precomputed once via build_cost_matrix() for efficiency, + rather than recomputed inside the loop and during backtracking Args: response_events: list of event dicts from group_notes_into_events @@ -345,7 +347,7 @@ def event_alignment_ED(response_events, ref_events, gap_penalty=DEFAULT_GAP_PENA gap_penalty: cost of leaving an event unaligned (insertion/deletion) Returns: - operations: list of operation dicts, same format as event_alignment_ED() + operations: list of operation dicts D: accumulated cost matrix, shape (N+1, M+1) """ # if a raw note dict with "pitch"/"start"/"duration" but no "event_type" is @@ -591,7 +593,7 @@ def event_level_feedback(operations, response_events, ref_events, "duration_abs_diff" -> float (seconds) or None "duration_relative_diff" -> float or None """ - # Compute IOI for each reference note: ioi[m] = ref_notes[m]["start"] - ref_notes[m-1]["start"] + # Compute IOI for each reference note: ioi[m] = ref_events[m]["start"] - ref_events[m-1]["start"] # floor at 0.05s to avoid division by zero issues ref_ioi = [None] * len(ref_events) for m in range(1, len(ref_events)): @@ -764,7 +766,8 @@ def compute_stats(event_level_results, ref_events, timing_scale=1.0, """ note_events = [n for n in event_level_results if n["event_type"] == "note"] chord_events = [ch for ch in event_level_results if ch["event_type"] == "chord"] - + + # Count the total number of notes and chords in the reference events ref_note_count = sum(1 for n in ref_events if n["event_type"] == "note") ref_chord_count = sum(1 for ch in ref_events if ch["event_type"] == "chord") @@ -1062,6 +1065,257 @@ def generate_feedback_message(event_details, response_events, ref_events, stats, return "\n".join(all_messages) +def polished_feedback_message(event_details, response_events, ref_events, stats, + global_slow_threshold=GLOBAL_SLOW_THRESHOLD, + global_fast_threshold=GLOBAL_FAST_THRESHOLD): + """ + Generate concise, practice-oriented feedback that aims to: + 1. summarise current performance level qualitatively + 2. provide encouraging actionable advice for improvement + 3. suggest a measurable goal for the next attempt with a main focus area + Individual note and chord errors remain available in event_details but + will not list each of them in the message. + + Args: + event_details: list of dicts, output of event_level_feedback() + response_events: list of event dicts from group_notes_into_events + ref_events: list of event dicts from group_notes_into_events + stats: dict, output of compute_stats() + global_slow_threshold: timing_scale above this triggers "too slow" message + global_fast_threshold: timing_scale below this triggers "too fast" message + + Returns: + feedback_message (str) + """ + note_events = [n for n in event_details if n["event_type"] == "note"] + chord_events = [ch for ch in event_details if ch["event_type"] == "chord"] + + paired_notes = [ + n for n in note_events + if n["operation_type"] in ("match", "replacement") + ] + paired_chords = [ + ch for ch in chord_events + if ch["operation_type"] in ("match", "replacement") + ] + + total_reference_notes = stats["total_notes_in_reference"] + total_reference_chords = stats["total_chords_in_reference"] + total_reference_events = total_reference_notes + total_reference_chords + + # --------------- summarise current performance level --------------- + # compute note-level accuracy metrics for pitch, timing, and duration + # ------------------------------------------------------------------- + if total_reference_notes > 0: + note_pitch_correct = (total_reference_notes + - stats["total_notes_wrong_pitch"] - stats["total_notes_missing"]) + note_pitch_accuracy = note_pitch_correct / total_reference_notes + + note_timing_correct = (total_reference_notes + - stats["total_notes_wrong_timing"] - stats["total_notes_missing"]) + note_timing_accuracy = note_timing_correct / total_reference_notes + + note_duration_correct = (total_reference_notes + - stats["total_notes_wrong_duration"] - stats["total_notes_missing"]) + note_duration_accuracy = note_duration_correct / total_reference_notes + else: + note_pitch_accuracy = None + note_timing_accuracy = None + note_duration_accuracy = None + + paired_chord_accuracies = [event["chord_accuracy"] + for event in paired_chords + if event["chord_accuracy"] is not None] + # Missing chords were never matched, treat as 0 accuracy for the purpose of computing median chord accuracy + paired_chord_accuracies = paired_chord_accuracies + [0.0] * stats["total_chords_missing"] + if paired_chord_accuracies: + median_chord_accuracy = float(np.median(paired_chord_accuracies)) + else: + median_chord_accuracy = None + + # summary qualitative feedback messages based on the accuracy metrics + # ------------------------------------------------------------------- + current_performance_messages = [] + + if note_pitch_accuracy is not None: + if note_pitch_accuracy >= 0.90: + current_performance_messages.append( + "Great! Most notes were played correctly, " \ + "you've got a good grasp of the melody.") + elif note_pitch_accuracy >= 0.70: + current_performance_messages.append( + "Many notes were correct, although a few passages " \ + "still need more careful practice. Try slowing down in " \ + "these sections and checking each note before gradually " \ + "returning to the intended tempo." + ) + else: + current_performance_messages.append( + "Note accuracy needs more practice. " + "Practice each short passage at a slower tempo, " + "check each note carefully, mind the fingering during practice. " \ + "Then move on to the next passage when you feel confident with the current one." + ) + + if note_timing_accuracy is not None: + if note_timing_accuracy >= 0.90: + current_performance_messages.append( + "Great timing consistency between notes, you've got a " \ + "good sense of onset time and rhythm!" + ) + elif note_timing_accuracy >= 0.70: + current_performance_messages.append( + "The spacing between notes was mostly consistent, although " \ + "a few passages were less steady. Practicing these sections " \ + "with a slower, regular beat may help you play each note at the right time " \ + "and hence make the rhythm more steady." + ) + else: + current_performance_messages.append( + "Timing consistency needs more practice. You can slow down in your " \ + "next practice session and listen carefully " \ + "for notes that arrive too early or too late. " \ + "A metronome can help you play each note at the right time " \ + "and hence make the rhythm more steady." + ) + # do not comment on duration for now, as it may be due to transcription errors + + if total_reference_chords > 0: + if median_chord_accuracy is None or median_chord_accuracy < 0.70: + current_performance_messages.append( + "Simultaneous notes are often hard to play correctly at the beginning. " \ + "Pay attention to the fingering and hand position when playing these chords. " \ + "You may find it helpful to practice each chord separately first and make sure " \ + "all required notes sound together. Then you can reconnect the chords to " \ + "their surrounding sections and practice at a slower tempo carefully. " + ) + elif median_chord_accuracy >= 0.90: + current_performance_messages.append( + "Nice! The chords were played accurately overall." + ) + elif median_chord_accuracy >= 0.70: + current_performance_messages.append( + "Most chord notes were played correctly, although some chords contain " \ + "missing or additional notes. It's a good idea to practice each difficult chord " \ + "separately and make sure that all required notes sound together." + ) + + # overall tempo feedback based on timing and duration scale factors + # ------------------------------------------------------------------- + timing_scale = stats["timing_scale"] + duration_scale = stats["duration_scale"] + if timing_scale > global_slow_threshold: + tempo_message = ( + "Your overall tempo was slower than the reference. This is not necessarily " \ + "a problem, and it is a good idea to play slowly while learning. " \ + "Whatever tempo you choose, aim to keep the rhythm steady throughout the performance." + ) + elif timing_scale < global_fast_threshold: + tempo_message = ( + "Your overall tempo was faster than the reference. This is not necessarily " \ + "a problem. Althogh you are confident in this piece, remember to play each " \ + "note clearly and make surethe rhythm remains steady." + ) + else: + tempo_message = ( + "Well done! Your overall tempo was close to the reference. Keep up the good work! " \ + "Don't forget to keep the rhythm steady throughout the performance." + ) + + # missing and extra + # ------------------------------------------------------------------ + total_missing_events = (stats["total_notes_missing"] + stats["total_chords_missing"]) + total_extra_events = (stats["total_notes_extra"] + stats["total_chords_extra"]) + total_completeness_errors = (total_missing_events + total_extra_events) + if total_reference_events > 0: + completeness_error_rate = total_completeness_errors / total_reference_events + else: + completeness_error_rate = 0.0 + + if total_completeness_errors == 0: + completeness_messages = ( + "You completed the performance without missing or adding any " \ + "notes or chords. Well done!" + ) + elif completeness_error_rate <= 0.10: + completeness_messages = ( + "The performance was mostly complete, with only a few missing " \ + "or additional notes or chords. Review the affected passages " \ + "slowly and check your fingering before playing them again." + ) + else: + completeness_messages = ( + "No worries! It is common to miss or play extra notes when learning a new piece, " \ + "especially difficult passages. You can slow down in your next practice and pay " \ + "more attention to your fingering and hand position. ") + + # -------------- suggest a measurable goal and a focus area -------------- + scores = {} + if note_pitch_accuracy is not None: + scores["pitch"] = note_pitch_accuracy + if note_timing_accuracy is not None: + scores["timing"] = note_timing_accuracy + # if note_duration_accuracy is not None: + # scores["duration"] = note_duration_accuracy + if median_chord_accuracy is not None: + scores["chords"] = median_chord_accuracy + + if scores: + main_focus = min(scores, key=scores.get) + main_focus_score = scores[main_focus] + else: + main_focus = None + main_focus_score = None + + if main_focus_score is not None and main_focus_score >= 0.90: + focus_message = ( + "Excellent work! You already have a good understanding of the melody and the rhythm. " \ + "For your next attempt, choose one short challenging section and " \ + "aim to play it confidently three times in a row.") + elif main_focus == "pitch": + overall_message = "You've got a good understanding of the rhythm. " if main_focus_score >= 0.70 else "Good progress! " + focus_message = ( + overall_message + "Let's focus on note accuracy next. Choose one short challenging " \ + "passage and practice it slowly. Aim to play this phrase correctly " \ + "three times in a row before increasing the tempo and moving on." + ) + elif main_focus == "timing": + overall_message = "You've got a good understanding of the melody. " if main_focus_score >= 0.70 else "Good progress! " + focus_message = ( + overall_message + "Let's focus on timing next. Practice with a slower, steady beat, " \ + "preferably using a metronome. Aim to keep the spacing between the " \ + "notes even three times in a row, then gradually increase the tempo." + ) + elif main_focus == "chords": + overall_message = "You've got a good understanding of the melody and the rhythm. " if main_focus_score >= 0.70 else "Good progress! " + focus_message = ( + overall_message + "Let's focus on chord accuracy next. Choose one difficult chord " \ + "and adjust your hand position. Aim to make all required notes " \ + "sound together correctly three times in a row." + ) + else: + # scores was empty: no reference notes/chords to evaluate at all. + focus_message = "No reference notes or chords were found to evaluate." + + all_messages = [ + "Practice Summary", + "\n".join(current_performance_messages), + "", + "Tempo", + tempo_message, + "", + "Performance Completeness", + completeness_messages, + "", + "Main Practice Focus", + focus_message, + "", + "Keep up the good work and enjoy your music journey!", + ] + + return "\n".join(all_messages) + + # FeedbackResult class # ------------------------------------------------------------------------------ class FeedbackResult: @@ -1173,7 +1427,7 @@ def compare_performance_ED(responseMIDI, refMIDI, ) # Step 5: Generate human-readable feedback - feedback_message = generate_feedback_message( + feedback_message = polished_feedback_message( event_details, response_events, ref_events, stats, global_slow_threshold=global_slow_threshold, global_fast_threshold=global_fast_threshold, diff --git a/evaluation_function/evaluation.py b/evaluation_function/evaluation.py index 6344161..a8485d9 100755 --- a/evaluation_function/evaluation.py +++ b/evaluation_function/evaluation.py @@ -19,6 +19,14 @@ GLOBAL_FAST_THRESHOLD, DEFAULT_CHORD_ONSET_WINDOW ) +from .audio_processing import ( + is_audio_input, + load_basic_pitch_model, + transcription_pipeline, +) +# Load the Basic Pitch model once, when this file is first imported. +BASIC_PITCH_MODEL = load_basic_pitch_model() + def parse_json_input(data: Any) -> Any: """ @@ -29,6 +37,26 @@ def parse_json_input(data: Any) -> Any: return data +def prepare_input(raw_input: Any) -> Any: + """ + Turn one raw input (either response or answer) into the + format that compare_performance_ED expects. + + There are two possible cases: + - raw_input is an audio file path + -> run it through the AMT (audio-to-MIDI) transcription pipeline + - raw_input is already MIDI (a dict, or a JSON string of a dict) + -> just parse it as JSON, no transcription needed + """ + if is_audio_input(raw_input): + compare_midi_input, predicted_notes, runtime_seconds = transcription_pipeline( + raw_input, BASIC_PITCH_MODEL + ) + return compare_midi_input + + return parse_json_input(raw_input) + + def evaluation_function( response: Any, answer: Any, @@ -61,8 +89,8 @@ def evaluation_function( # The Lambda Feedback app sends response/answer as JSON strings, # convert them into Python object first - response = parse_json_input(response) - answer = parse_json_input(answer) + response = prepare_input(response) + answer = prepare_input(answer) result = compare_performance_ED( response, diff --git a/evaluation_function/evaluation_test.py b/evaluation_function/evaluation_test.py index ac23a8e..9aca78e 100755 --- a/evaluation_function/evaluation_test.py +++ b/evaluation_function/evaluation_test.py @@ -12,12 +12,13 @@ 1. Tests for helper functions get_pitch_class_set, identify_chord_name, compute_chord_accuracy 2. Tests for normalize_start_times 3. Tests for group_notes_into_events -4. Tests for compute_note_cost and compute_event_cost +4. Tests for build_cost_matrix 5. Tests for event_alignment_ED (covers note-only, chord-only cases and mixed cases) 6. Tests for estimate_global_timing and estimate_global_duration_scale -7. Tests for event_level_feedback and compute_stats (covers note-only and chord-only cases) +7. Tests for compare_performance_ED (full pipeline: alignment → event-level feedback → stats) 8. Tests for evaluation_function (Lambda Feedback integration) 9. Tests for parameter overrides +10. Bulk tests using longer MIDI sequences """ @@ -458,7 +459,7 @@ def test_fewer_than_3_matched_returns_defaults(self): assert dur_scale == 1.0 -# 7. Tests for event_level_feedback and compute_stats +# 7. Tests for compare_performance_ED (full pipeline: alignment → event-level feedback → stats) # ------------------------------------------------------------------------------ class TestComparePerformanceED(unittest.TestCase): diff --git a/notebooks/Demonstration.ipynb b/notebooks/Demonstration.ipynb new file mode 100644 index 0000000..fe19be8 --- /dev/null +++ b/notebooks/Demonstration.ipynb @@ -0,0 +1,388 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a025b041", + "metadata": {}, + "source": [ + "# Overview\n", + "\n", + "The objective of this project is to design an automated feedback system which provides music students with formative, elaborated feedback for music practice. \n", + "\n", + "This notebook shows how the full compareMusic pipeline works on a real practice recording:\n", + "1. load the reference audio and the response audio files recorded during practice\n", + "2. transcribe the audio files into MIDI format using the transcription and post-processing pipeline developed in Phase2 \n", + "3. pass the reference MIDI and response MIDI into the MIDI comparison pipeline developed in Phase1 to get the feedback messages\n", + "- additionally provides visualisation plots to show the alignment result between the reference and the performance(response)\n", + "\n", + "Evaluation and analysis of the pipeline's performance are in the other summary notebooks." + ] + }, + { + "cell_type": "markdown", + "id": "ef8ddb5b", + "metadata": {}, + "source": [ + "## 1. Setup and Load the audio" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "f77def2e", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "scikit-learn version 1.9.0 is not supported. Minimum required version: 0.17. Maximum required version: 1.5.1. Disabling scikit-learn conversion API.\n", + "WARNING:root:tflite-runtime is not installed. If you plan to use a TFLite Model, reinstall basic-pitch with `pip install 'basic-pitch tflite-runtime'` or `pip install 'basic-pitch[tf]'\n", + "WARNING:root:onnxruntime is not installed. If you plan to use an ONNX Model, reinstall basic-pitch with `pip install 'basic-pitch[onnx]'`\n", + "WARNING:root:Tensorflow is not installed. If you plan to use a TF Saved Model, reinstall basic-pitch with `pip install 'basic-pitch[tf]'`\n", + "/Users/jz7125/compareMusic/.venv/lib/python3.11/site-packages/resampy/filters.py:50: UserWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html. The pkg_resources package is slated for removal as early as 2025-11-30. Refrain from using this package or pin to Setuptools<81.\n", + " import pkg_resources\n" + ] + } + ], + "source": [ + "from pathlib import Path\n", + "\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from evaluation_function.audio_processing import (\n", + " load_basic_pitch_model,\n", + " transcription_pipeline,\n", + ")\n", + "from evaluation_function.compare_MIDI import (\n", + " compare_performance_ED,\n", + " normalize_start_times,\n", + " group_notes_into_events,\n", + " DEFAULT_CHORD_ONSET_WINDOW,\n", + ")\n", + "\n", + "from notebooks.utils.nasap_alignment_evaluation import plot_alignment" + ] + }, + { + "cell_type": "markdown", + "id": "8d9d98d4", + "metadata": {}, + "source": [ + "Load the data:\n", + "\n", + "- Response: 2 audio files of the same song recorded by my supervisor during daily practice.\n", + "- Reference: using a tool called 'soundslice' to generate audio file from the music score provided by my supervisor." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "11838aa7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Practice1 file: /Users/jz7125/compareMusic/data/real_recordings/practice_01.m4a\n", + "Practice2 file: /Users/jz7125/compareMusic/data/real_recordings/practice_02.m4a\n", + "Reference score: /Users/jz7125/compareMusic/data/real_recordings/reference_score.m4a\n" + ] + } + ], + "source": [ + "# Find the project root directory by looking for the pyproject.toml file\n", + "path = Path.cwd().resolve()\n", + "while not (path / \"pyproject.toml\").exists():\n", + " path = path.parent\n", + "PROJECT_ROOT = path\n", + "DATA_ROOT = PROJECT_ROOT / \"data\" / \"real_recordings\"\n", + "\n", + "# path to the audio files and reference MIDI file\n", + "PRACTICE01_PATH = DATA_ROOT / \"practice_01.m4a\"\n", + "PRACTICE02_PATH = DATA_ROOT / \"practice_02.m4a\"\n", + "REFERENCE_AUDIO_PATH = DATA_ROOT / \"reference_score.m4a\"\n", + "\n", + "assert PRACTICE01_PATH.exists(), f\"Audio file not found: {PRACTICE01_PATH}\"\n", + "assert PRACTICE02_PATH.exists(), f\"Audio file not found: {PRACTICE02_PATH}\"\n", + "assert REFERENCE_AUDIO_PATH.exists(), f\"Reference MIDI not found: {REFERENCE_AUDIO_PATH}\"\n", + "\n", + "print(\"Practice1 file:\", PRACTICE01_PATH)\n", + "print(\"Practice2 file:\", PRACTICE02_PATH)\n", + "print(\"Reference score:\", REFERENCE_AUDIO_PATH)" + ] + }, + { + "cell_type": "markdown", + "id": "a872e18c", + "metadata": {}, + "source": [ + "## 2. Audio-to-MIDI Transcription" + ] + }, + { + "cell_type": "markdown", + "id": "d37d0534", + "metadata": {}, + "source": [ + "Both the practice recording and the reference audio are transcribed using the same audio-to-MIDI pipeline, therefore transcrition error may occur in either side. A manually-inspected reference MIDI generated directly from the music score would be preferable." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c96f63b5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Transcribed practice recording 01: 97 notes in 2.6s\n", + "Transcribed practice recording 02: 87 notes in 0.6s\n", + "Transcribed reference recording: 163 notes in 0.4s\n" + ] + } + ], + "source": [ + "# Load the Basic Pitch model once, reuse it for both files\n", + "basic_pitch_model = load_basic_pitch_model()\n", + "\n", + "# Transcribe the practice recording 01\n", + "response1, predicted_notes1, response_runtime_seconds1 = transcription_pipeline(\n", + " PRACTICE01_PATH,\n", + " basic_pitch_model,\n", + " apply_postprocessing=True,\n", + ")\n", + "\n", + "# Transcribe the practice recording 02\n", + "response2, predicted_notes2, response_runtime_seconds2 = transcription_pipeline(\n", + " PRACTICE02_PATH,\n", + " basic_pitch_model,\n", + " apply_postprocessing=True,\n", + ")\n", + "\n", + "# Transcribe the reference recording\n", + "reference, reference_notes, reference_runtime_seconds = transcription_pipeline(\n", + " REFERENCE_AUDIO_PATH,\n", + " basic_pitch_model,\n", + " apply_postprocessing=True,\n", + ")\n", + "\n", + "print(f\"Transcribed practice recording 01: {len(predicted_notes1)} notes \"\n", + " f\"in {response_runtime_seconds1:.1f}s\")\n", + "print(f\"Transcribed practice recording 02: {len(predicted_notes2)} notes \"\n", + " f\"in {response_runtime_seconds2:.1f}s\")\n", + "print(f\"Transcribed reference recording: {len(reference_notes)} notes \"\n", + " f\"in {reference_runtime_seconds:.1f}s\")" + ] + }, + { + "cell_type": "markdown", + "id": "a296a402", + "metadata": {}, + "source": [ + "Visualise the transcribed MIDI using Piano Roll" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "bd6898ce", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def plot_piano_roll_comparison(predicted_notes, reference_notes, title=\"Piano roll comparison\"):\n", + " fig, ax = plt.subplots(figsize=(14, 6))\n", + "\n", + " for note in reference_notes:\n", + " offset = note[\"start\"] + note[\"duration\"]\n", + " ax.plot(\n", + " [note[\"start\"], offset],\n", + " [note[\"pitch\"], note[\"pitch\"]],\n", + " linewidth=4,\n", + " alpha=0.6,\n", + " color=\"lightgray\",\n", + " label=\"Reference\",\n", + " )\n", + "\n", + " for note in predicted_notes:\n", + " offset = note[\"onset\"] + note[\"duration\"]\n", + " ax.plot(\n", + " [note[\"onset\"], offset],\n", + " [note[\"pitch\"], note[\"pitch\"]],\n", + " linewidth=2,\n", + " alpha=0.9,\n", + " color=\"tab:blue\",\n", + " label=\"Practice\",\n", + " )\n", + "\n", + " handles, labels = ax.get_legend_handles_labels()\n", + " unique = dict(zip(labels, handles))\n", + " ax.legend(unique.values(), unique.keys(), loc=\"upper right\")\n", + "\n", + " ax.set_xlabel(\"Time (s)\")\n", + " ax.set_ylabel(\"MIDI pitch\")\n", + " ax.set_title(title)\n", + " ax.grid(alpha=0.15)\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "plot_piano_roll_comparison(predicted_notes1, reference[\"notes\"], title=\"practice 01 vs. reference\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "19b1447b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_piano_roll_comparison(predicted_notes2, reference[\"notes\"], title=\"practice 02 vs. reference\")" + ] + }, + { + "cell_type": "markdown", + "id": "edf24a31", + "metadata": {}, + "source": [ + "## 3. Compare reference and response to generate feedback messages" + ] + }, + { + "cell_type": "markdown", + "id": "c748d0de", + "metadata": {}, + "source": [ + "The two practice recordings were recorded on the same day, the level of performance is the same (similar patterns observed from the piano roll), therefore here just generate the feedback for practice 01 for presentation." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "2afb8b23", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Practice Summary\n", + "Note accuracy needs more practice. Practice each short passage at a slower tempo, check each note carefully, mind the fingering during practice. Then move on to the next passage when you feel confident with the current one.\n", + "Timing consistency needs more practice. You can slow down in your next practice session and listen carefully for notes that arrive too early or too late. A metronome can help you play each note at the right time and hence make the rhythm more steady.\n", + "Simultaneous notes are often hard to play correctly at the beginning. Pay attention to the fingering and hand position when playing these chords. You may find it helpful to practice each chord separately first and make sure all required notes sound together. Then you can reconnect the chords to their surrounding sections and practice at a slower tempo carefully. \n", + "\n", + "Tempo\n", + "Your overall tempo was slower than the reference. This is not necessarily a problem, and it is a good idea to play slowly while learning. Whatever tempo you choose, aim to keep the rhythm steady throughout the performance.\n", + "\n", + "Performance Completeness\n", + "No worries! It is common to miss or play extra notes when learning a new piece, especially difficult passages. You can slow down in your next practice and pay more attention to your fingering and hand position. \n", + "\n", + "Main Practice Focus\n", + "Good progress! Let's focus on timing next. Practice with a slower, steady beat, preferably using a metronome. Aim to keep the spacing between the notes even three times in a row, then gradually increase the tempo.\n", + "\n", + "Keep up the good work and enjoy your music journey!\n" + ] + } + ], + "source": [ + "result1 = compare_performance_ED(response1, reference)\n", + "print(result1.feedback_message)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "28e44b6b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Selected operations: 114\n", + "Note connectors: 97\n", + "Missing note markers: 25\n", + "Extra note markers: 0\n" + ] + } + ], + "source": [ + "# Regenerate the grouped events compare_performance_ED used internally --\n", + "# same two calls as its own Step 0, with the same default chord_onset_window\n", + "# (change this if you passed a custom chord_onset_window to compare_performance_ED above)\n", + "response_events = group_notes_into_events(\n", + " normalize_start_times(response1[\"notes\"]), DEFAULT_CHORD_ONSET_WINDOW\n", + ")\n", + "ref_events = group_notes_into_events(\n", + " normalize_start_times(reference[\"notes\"]), DEFAULT_CHORD_ONSET_WINDOW\n", + ")\n", + "\n", + "# Zoom into the whole piece: 0 to the last reference note's end time\n", + "ref_end = max(\n", + " note[\"start\"] + note[\"duration\"]\n", + " for event in ref_events\n", + " for note in event[\"notes\"]\n", + ")\n", + "\n", + "# Usage\n", + "plot_alignment(ref_events, response_events, result1.event_details, ref_start=0.0, ref_end=ref_end)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "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.11.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/Phase1-1.5_summary.ipynb b/notebooks/Phase1-1.5_summary.ipynb index 1b7b587..e760cb6 100644 --- a/notebooks/Phase1-1.5_summary.ipynb +++ b/notebooks/Phase1-1.5_summary.ipynb @@ -21,8 +21,7 @@ "- Step 2: estimate the overall timing and duration difference between reference and response, using linear regression.\n", "- Step 3: compute metrics to provide event-level feedback (note/chord-level feedback)\n", "- Step 4: compute the summary statistics to provide overview feedback\n", - "- Step 5: generate human-readable feedback message from step 3 and step 4\n", - "- Step 6: provide an additional overall pass/fail judgement based on step 3 and step 4" + "- Step 5: generate human-readable feedback message from step 3 and step 4" ] }, { @@ -35,23 +34,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "c3152f6b", "metadata": {}, "outputs": [], "source": [ - "# Import\n", "from evaluation_function.compare_MIDI import (\n", " normalize_start_times,\n", " group_notes_into_events,\n", " event_alignment_ED,\n", " estimate_global_timing,\n", " estimate_global_duration_scale,\n", + " event_level_feedback, \n", + " compute_stats, \n", + " generate_feedback_message,\n", + " polished_feedback_message,\n", " compare_performance_ED,\n", ")\n", + "\n", "from notebooks.utils.alignment_visualisation import (\n", " plot_edit_distance_alignment,\n", - " )" + ")" ] }, { @@ -327,7 +330,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -367,15 +370,7 @@ "execution_count": 6, "id": "5c08f1c6", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "asap-dataset already exists, skipping download.\n" - ] - } - ], + "outputs": [], "source": [ "import pandas as pd\n", "\n", @@ -386,17 +381,49 @@ " load_typical_midi_test_case,\n", " plot_typical_alignment_cases,\n", " print_alignment_case_summary\n", - ")\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "531d8ed9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "asap-dataset already exists, skipping download.\n", + "ASAP_PATH = /Users/jz7125/compareMusic/data/asap-dataset\n" + ] + } + ], + "source": [ + "from pathlib import Path\n", + "import subprocess\n", + "\n", + "# find the project root directory by looking for the pyproject.toml file\n", + "path = Path.cwd().resolve()\n", + "while not (path / \"pyproject.toml\").exists():\n", + " path = path.parent\n", + "PROJECT_ROOT = path\n", + "\n", + "DATA_DIR = PROJECT_ROOT / \"data\"\n", + "ASAP_PATH = DATA_DIR / \"asap-dataset\"\n", "\n", - "import os\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", + "# the note_alignments TSV files needed for ground truth comparison.\n", + "if not ASAP_PATH.exists():\n", + " DATA_DIR.mkdir(parents=True, exist_ok=True)\n", + " subprocess.run(\n", + " [\"git\", \"clone\", \"https://github.com/CPJKU/asap-dataset.git\", str(ASAP_PATH)],\n", + " check=True,\n", + " )\n", "else:\n", " print(\"asap-dataset already exists, skipping download.\")\n", "\n", - "ASAP_PATH = \"asap-dataset\"" + "print(f\"ASAP_PATH = {ASAP_PATH}\")" ] }, { @@ -469,7 +496,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "3c7e5ffb", "metadata": {}, "outputs": [ @@ -539,7 +566,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "63075a46", "metadata": {}, "outputs": [ @@ -602,7 +629,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "id": "8aafbdfb", "metadata": {}, "outputs": [ @@ -661,7 +688,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "id": "3999499b", "metadata": {}, "outputs": [ @@ -678,7 +705,7 @@ ], "source": [ "twinkle_data = load_typical_midi_test_case(\n", - " json_path=\"../data/longMIDIsequence.json\",\n", + " json_path=str(DATA_DIR / \"longMIDIsequence.json\"),\n", " case_name=\"twinkle_scattered_errors\",\n", ")\n", "\n", @@ -719,7 +746,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "id": "3f97b847", "metadata": {}, "outputs": [ @@ -753,7 +780,7 @@ "id": "06deb2d0", "metadata": {}, "source": [ - "### 3-6. Evaluation and feedback generation" + "### 3-5. Evaluation and feedback generation" ] }, { @@ -771,15 +798,85 @@ " - Duration: The expected duration is predicted from the global duration scale, then the relative difference in duration is calculated by ∣response_duration − predicted_duration∣ / ref_duration, a note is considered correct if this relative difference is within a threshold." ] }, + { + "cell_type": "code", + "execution_count": 13, + "id": "9ac8519b", + "metadata": {}, + "outputs": [], + "source": [ + "# Step 3: Evaluate each aligned event pair\n", + "event_details = event_level_feedback(\n", + " operations, response_events, ref_events,\n", + " timing_scale=timing_scale,\n", + " timing_offset=timing_offset,\n", + " duration_scale=duration_scale,\n", + ")" + ] + }, { "cell_type": "markdown", - "id": "f6f8ed5d", + "id": "e0d9e7c0", "metadata": {}, "source": [ "Step 4: summary\n", - "- Compute the summary statistics to provide overview feedback, including total notes/chords missing, extra, wrong pitch, wrong timing, and wrong duration, as well as boolean flags indicating whether all paired notes are correct on each dimension. The global trend parameters (timing_scale, timing_offset, duration_scale) are also included. \n", - "\n", + "- Compute the summary statistics to provide overview feedback, including total notes/chords missing, extra, wrong pitch, wrong timing, and wrong duration, as well as boolean flags indicating whether all paired notes are correct on each dimension. The global trend parameters (timing_scale, timing_offset, duration_scale) are also included. " + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "af66298b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'pitch_all_aligned_correct': False,\n", + " 'timing_all_correct': False,\n", + " 'duration_all_correct': True,\n", + " 'total_notes_in_reference': 5,\n", + " 'total_notes_missing': 0,\n", + " 'total_notes_extra': 0,\n", + " 'total_notes_wrong_pitch': 1,\n", + " 'total_notes_wrong_timing': 1,\n", + " 'total_notes_wrong_duration': 0,\n", + " 'total_notes_correct': 3,\n", + " 'timing_scale': 1.1962552426602757,\n", + " 'timing_offset': -0.10813361294188076,\n", + " 'duration_scale': 1.1999999999999997,\n", + " 'total_chords_in_reference': 2,\n", + " 'total_chords_missing': 0,\n", + " 'total_chords_extra': 0,\n", + " 'total_chords_correct': 1,\n", + " 'total_chords_imperfect': 1,\n", + " 'total_chords_wrong': 0}" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Step 4: Compute summary statistics\n", + "stats = compute_stats(\n", + " event_details, ref_events,\n", + " timing_scale=timing_scale,\n", + " timing_offset=timing_offset,\n", + " duration_scale=duration_scale,\n", + ")\n", + "stats" + ] + }, + { + "cell_type": "markdown", + "id": "1a84cacc", + "metadata": {}, + "source": [ "Step 5: generate human-readable feedback message from step 3 and step 4\n", + "\n", + "Old version:\n", "- Overview provides a summary of the student's overall performance:\n", " - Tempo judgement based on timing_scale: explicitly states whether the overall tempo is acceptable, too slow, or too fast, along with the duration_scale as supplementary context\n", " - Total count of pitch errors, missing notes, and extra notes\n", @@ -787,23 +884,13 @@ " - Missing/extra notes: identifies the specific note and pitch\n", " - Pitch errors: states the expected and played pitch, and the semitone difference\n", " - Local timing anomalies: reports the absolute and relative deviation after the global trend has been removed\n", - " - Local duration anomalies: reports the deviation direction and magnitude after the global duration scale has been removed\n", - "\n", - "Step 6: provide an additional overall pass/fail judgement based on step 3 and step 4" - ] - }, - { - "cell_type": "markdown", - "id": "720a022a", - "metadata": {}, - "source": [ - "### Example feedback message:" + " - Local duration anomalies: reports the deviation direction and magnitude after the global duration scale has been removed" ] }, { "cell_type": "code", - "execution_count": 12, - "id": "7bcb2de3", + "execution_count": 15, + "id": "8015d6b2", "metadata": {}, "outputs": [ { @@ -827,9 +914,62 @@ } ], "source": [ - "# Calling compare_performance_ED() runs all steps in one call.\n", - "result = compare_performance_ED(responseMIDI, referenceMIDI)\n", - "print(result.feedback_message)" + "# Step 5: Generate feedback messages\n", + "# Old version: lists every error individually\n", + "old_feedback_message = generate_feedback_message(\n", + " event_details, response_events, ref_events, stats,\n", + ")\n", + "print(old_feedback_message)" + ] + }, + { + "cell_type": "markdown", + "id": "286ba90a", + "metadata": {}, + "source": [ + "New version:\n", + "- Practice Summary: summarise current performance level qualitatively, covers pitch accuracy, timing, chords, and provide some practice suggestions for improvement.\n", + "- Tempo: general overview of tempo\n", + "- Performance Completeness: general overview of extra or missing notes or chords\n", + "- Main Practice Focus: suggest a measurable goal for the next attempt with a main focus area\n", + "\n", + "Individual note and chord errors remain available in event_details but will not list each of them in the message." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "6fe717a0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Practice Summary\n", + "Many notes were correct, although a few passages still need more careful practice. Try slowing down in these sections and checking each note before gradually returning to the intended tempo.\n", + "The spacing between notes was mostly consistent, although a few passages were less steady. Practicing these sections with a slower, regular beat may help you play each note at the right time and hence make the rhythm more steady.\n", + "Most chord notes were played correctly, although some chords contain missing or additional notes. It's a good idea to practice each difficult chord separately and make sure that all required notes sound together.\n", + "\n", + "Tempo\n", + "Your overall tempo was slower than the reference. This is not necessarily a problem, and it is a good idea to play slowly while learning. Whatever tempo you choose, aim to keep the rhythm steady throughout the performance.\n", + "\n", + "Performance Completeness\n", + "You completed the performance without missing or adding any notes or chords. Well done!\n", + "\n", + "Main Practice Focus\n", + "You've got a good understanding of the rhythm. Let's focus on note accuracy next. Choose one short challenging passage and practice it slowly. Aim to play this phrase correctly three times in a row before increasing the tempo and moving on.\n", + "\n", + "Keep up the good work and enjoy your music journey!\n" + ] + } + ], + "source": [ + "# New version: with integrated, practice-oriented summary (current default)\n", + "new_feedback_message = polished_feedback_message(\n", + " event_details, response_events, ref_events, stats,\n", + ")\n", + "print(new_feedback_message)" ] }, { @@ -845,9 +985,10 @@ "id": "71a6e28f", "metadata": {}, "source": [ - "visualise the feedback, maybe try the visualisation tool such as LilyPond, music21, or simply use matplotlib to plot PianoRoll.\n", - "\n", - "Improve the feedback generation parts, maybe do not need to list all the mistakes, learners' always make lots of mistakes during practice, all they need to do is practice more, consider giving integrated feedback, e.g. current performance level, what should it be in the next practice (8/10 notes within tolerance, 9/10 notes correct pitch, keep practicing and compare with last time), some comments/information to motivate learners to try again\n" + "- Visualise the feedback: Can try to display the mistakes by annotating or coloring the corresponding notes on the music score, maybe try the visualisation tool such as LilyPond, music21, or simply use matplotlib to plot PianoRoll.\n", + "- Progress tracking across practice sessions: The current system evaluates each performance independently. A future extension could compare a student's current attempt with previous attempts on the same piece to identify improvements or recurring difficulties over time. This would help provide more personalised feedback, su that students can monitor their progress more effectively.\n", + "- Improve feedback quality: Interviewing more music teachers and students, ask their opions about what makes a feedback useful, clear and motivated. Can also introduce more feedback componets, such as dynamics, phrasing, expression.\n", + "- Improve feedback accuracy by reducing the effect of transcription error: May introduce a `confidence level` metrics, estimating the reliability of the automatic transcription, do not provide the feedback if the confidence level is low." ] } ], diff --git a/notebooks/Phase2_summary.ipynb b/notebooks/Phase2_summary.ipynb index 483e4ab..681c617 100644 --- a/notebooks/Phase2_summary.ipynb +++ b/notebooks/Phase2_summary.ipynb @@ -7,14 +7,14 @@ "source": [ "## Phase 2: Audio to MIDI transcription\n", "\n", - "Aim: Design a polyphonic, single-instrument, note-level AMT pipeline for converting audio recording into the MIDI dict format which can be passed into compare_performance_ED() in compare_MIDI.py.\n", - "\n", - "General sturcture of AMT pipeline:\n", + "General sturcture of typical AMT pipeline:\n", "- Step 1: read in the audio file\n", "- Step 2: preprocessing, prepare audio for the model, e.g. Time-frequency representation (Spectrogram), Pitch/Note/Onset estimation \n", - "- Step 3: AMT model (CNN/LSTM/Transformer)\n", + "- Step 3: AMT model, e.g. CNN, LSTM, Transformer\n", "- Step 4: postprocessing, convert the model output format \n", "\n", + "Aim: Design a polyphonic, single-instrument, note-level AMT pipeline for converting audio recording into the MIDI dict format which can be passed into compare_performance_ED() in compare_MIDI.py.\n", + "\n", "This notebook records the complete Phase 2 workflow: applying Basic Pitch to PianoVAM, calibrating its decoder, analysing transcription errors, designing targeted post-processing, and integrating audio input with the existing feedback pipeline." ] }, @@ -28,13 +28,26 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 1, "id": "ed89d516", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "scikit-learn version 1.9.0 is not supported. Minimum required version: 0.17. Maximum required version: 1.5.1. Disabling scikit-learn conversion API.\n", + "WARNING:root:tflite-runtime is not installed. If you plan to use a TFLite Model, reinstall basic-pitch with `pip install 'basic-pitch tflite-runtime'` or `pip install 'basic-pitch[tf]'\n", + "WARNING:root:onnxruntime is not installed. If you plan to use an ONNX Model, reinstall basic-pitch with `pip install 'basic-pitch[onnx]'`\n", + "WARNING:root:Tensorflow is not installed. If you plan to use a TF Saved Model, reinstall basic-pitch with `pip install 'basic-pitch[tf]'`\n", + "/Users/jz7125/compareMusic/.venv/lib/python3.11/site-packages/resampy/filters.py:50: UserWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html. The pkg_resources package is slated for removal as early as 2025-11-30. Refrain from using this package or pin to Setuptools<81.\n", + " import pkg_resources\n", + "/Users/jz7125/compareMusic/.venv/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], "source": [ - "from pathlib import Path\n", - "\n", "import pandas as pd\n", "from sklearn.model_selection import ParameterSampler\n", "\n", @@ -74,20 +87,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "4a46f481", "metadata": {}, "outputs": [], "source": [ + "from pathlib import Path\n", + "\n", + "# Find the project root directory by looking for the pyproject.toml file\n", + "path = Path.cwd().resolve()\n", + "while not (path / \"pyproject.toml\").exists():\n", + " path = path.parent\n", + "PROJECT_ROOT = path\n", + "\n", "# PianoVAM paths\n", - "DATA_ROOT = Path(\"data/PianoVAM_v1\")\n", + "DATA_ROOT = PROJECT_ROOT / \"data\" / \"PianoVAM_v1\"\n", "AUDIO_DIR = DATA_ROOT / \"Audio\"\n", "MIDI_DIR = DATA_ROOT / \"MIDI\"\n", "TSV_DIR = DATA_ROOT / \"TSV\"\n", "METADATA_PATH = DATA_ROOT / \"metadata.json\"\n", "\n", "# Output paths used for cached predictions and search progress\n", - "OUTPUT_DIR = Path(\"outputs/phase2_baseline\")\n", + "OUTPUT_DIR = PROJECT_ROOT / \"outputs\" / \"phase2_baseline\"\n", "OUTPUT_DIR.mkdir(parents=True, exist_ok=True)\n", "RAW_PREDICTIONS_DIR = OUTPUT_DIR / \"raw_predictions\"\n", "RAW_PREDICTIONS_DIR.mkdir(parents=True, exist_ok=True)\n", @@ -259,7 +280,7 @@ ], "source": [ "# The dataset has proper official `train`, `valid`, `test`, \n", - "# `ext-train`, and `special-purpose` splits. \n", + "# The `ext-train`, and `special-purpose` splits are not used in this notebook. \n", "train_samples = metadata_df[\n", " (metadata_df[\"split\"] == \"train\")\n", " & (metadata_df[\"performance_method\"] == \"Solo\")\n", @@ -360,10 +381,11 @@ "id": "8ce14db6", "metadata": {}, "source": [ - "Followed Rachel, 2022, using `mir_eval` to compute the following metrics: \n", + "Using `mir_eval` to compute the following metrics: \n", + "- precision\n", + "- recall\n", "- note-level F-measure (F): notes are considered correct if the pitch is within a quarter tone, the onset is within 50 ms, and the offset is within 20% of the note’s duration\n", "- the note-level F-measure-no-offset (Fno): same criterion as F-measure, but ignoring offsets \n", - "- frame-level note accuracy (Acc): computed for frames with a hop size of 10 ms. \n", "- overlap ratio (OR): given a reference and corresponding estimated note, their OR is defined as the ratio between the duration of the time segment in which the two notes overlap and the time segment spanned by the two notes combined\n", "\n", "The main measure of overall note estimation accuracy is the note F1 without offset (`note_f1_no_offset`) since the definition of offsets is less objective than onsets due to pedal usage and reverberation. Also, as the TSV annotations additionally provide the frame offset information, which represents the end of the audible note (a note will still be hearable after note-off action if sustain pedal is used), the duration in the ground truth will be calculated using this frame-offset info instead of note-off info.\n", @@ -379,7 +401,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "a438732d", "metadata": {}, "outputs": [ @@ -752,7 +774,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "236795e1", "metadata": {}, "outputs": [ @@ -2225,19 +2247,19 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 9, "id": "c9cbad6f", "metadata": {}, "outputs": [], "source": [ "# Case study: the lowest-F1 and highest-F1 samples \n", "lowest_f1_sample_id = \"19\"\n", - "highest_f1_sample_id = \"32\"\n" + "highest_f1_sample_id = \"32\"" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 10, "id": "aeeaf819", "metadata": {}, "outputs": [ @@ -2277,7 +2299,7 @@ "dtype: object" ] }, - "execution_count": 13, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -2296,7 +2318,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 11, "id": "ff896e42", "metadata": {}, "outputs": [ @@ -2336,7 +2358,7 @@ "dtype: object" ] }, - "execution_count": 14, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -2397,7 +2419,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 12, "id": "f9d3d883", "metadata": {}, "outputs": [], @@ -2417,7 +2439,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 13, "id": "2b584385", "metadata": {}, "outputs": [ @@ -2425,7 +2447,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Random search: 100%|██████████| 53/53 [54:02<00:00, 61.18s/it] \n" + "Random search: 100%|██████████| 53/53 [1:49:48<00:00, 124.31s/it] \n" ] }, { @@ -3114,7 +3136,7 @@ "39 0.632116 0.232620 9777.169811 " ] }, - "execution_count": 16, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -3141,7 +3163,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 14, "id": "8502b6c1", "metadata": {}, "outputs": [ @@ -3149,7 +3171,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Evaluating configuration: 100%|██████████| 53/53 [11:43<00:00, 13.27s/it]\n" + "Evaluating configuration: 100%|██████████| 53/53 [11:41<00:00, 13.23s/it]\n" ] }, { @@ -3161,7 +3183,7 @@ " 'melodia_trick': False}" ] }, - "execution_count": 17, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -3184,7 +3206,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 15, "id": "e3a000b2", "metadata": {}, "outputs": [ @@ -3277,7 +3299,7 @@ "1 26.169811 433.679245 " ] }, - "execution_count": 18, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -3293,7 +3315,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 16, "id": "41e143e1", "metadata": {}, "outputs": [ @@ -3693,7 +3715,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 17, "id": "dc3d1fb7", "metadata": {}, "outputs": [ @@ -3701,7 +3723,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "FP/FN summary: 100%|██████████| 53/53 [02:42<00:00, 3.06s/it]\n" + "FP/FN summary: 100%|██████████| 53/53 [02:41<00:00, 3.04s/it]\n" ] }, { @@ -5500,7 +5522,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 18, "id": "8cb7dddc", "metadata": {}, "outputs": [ @@ -5508,7 +5530,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Post-processing evaluation: 100%|██████████| 53/53 [08:14<00:00, 9.32s/it]\n" + "Post-processing evaluation: 100%|██████████| 53/53 [08:14<00:00, 9.34s/it]\n" ] }, { @@ -5600,7 +5622,7 @@ "1 25.452830 441.830189 " ] }, - "execution_count": 21, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -5636,7 +5658,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 19, "id": "99efb174", "metadata": {}, "outputs": [ @@ -5674,7 +5696,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "id": "7d57783a", "metadata": {}, "outputs": [ @@ -5682,8 +5704,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "Evaluating configuration: 100%|██████████| 9/9 [01:04<00:00, 7.22s/it]\n", - "Post-processing evaluation: 100%|██████████| 9/9 [00:39<00:00, 4.39s/it]\n" + "Evaluating configuration: 100%|██████████| 9/9 [01:07<00:00, 7.47s/it]\n", + "Post-processing evaluation: 100%|██████████| 9/9 [00:38<00:00, 4.33s/it]\n" ] }, { @@ -5723,6 +5745,20 @@ " \n", " \n", " 0\n", + " Default Basic Pitch\n", + " 0.699004\n", + " 0.661520\n", + " 0.775779\n", + " 0.751523\n", + " 0.725641\n", + " 0.740562\n", + " 0.238708\n", + " 4793.222222\n", + " 229.222222\n", + " 158.888889\n", + " \n", + " \n", + " 1\n", " Tuned Basic Pitch\n", " 0.813910\n", " 0.823995\n", @@ -5736,7 +5772,7 @@ " 156.444444\n", " \n", " \n", - " 1\n", + " 2\n", " Tuned + targeted post-processing\n", " 0.816607\n", " 0.824828\n", @@ -5755,33 +5791,46 @@ ], "text/plain": [ " configuration mean_note_precision_no_offset \\\n", - "0 Tuned Basic Pitch 0.813910 \n", - "1 Tuned + targeted post-processing 0.816607 \n", + "0 Default Basic Pitch 0.699004 \n", + "1 Tuned Basic Pitch 0.813910 \n", + "2 Tuned + targeted post-processing 0.816607 \n", "\n", " median_note_precision_no_offset mean_note_recall_no_offset \\\n", - "0 0.823995 0.832767 \n", - "1 0.824828 0.829040 \n", + "0 0.661520 0.775779 \n", + "1 0.823995 0.832767 \n", + "2 0.824828 0.829040 \n", "\n", " median_note_recall_no_offset mean_note_f1_no_offset \\\n", - "0 0.886282 0.817995 \n", - "1 0.871698 0.817358 \n", + "0 0.751523 0.725641 \n", + "1 0.886282 0.817995 \n", + "2 0.871698 0.817358 \n", "\n", " median_note_f1_no_offset mean_note_f1_with_offset mean_predicted_notes \\\n", - "0 0.815534 0.274124 4581.555556 \n", - "1 0.815204 0.271278 4546.555556 \n", + "0 0.740562 0.238708 4793.222222 \n", + "1 0.815534 0.274124 4581.555556 \n", + "2 0.815204 0.271278 4546.555556 \n", "\n", " mean_extra_notes mean_missing_notes \n", - "0 29.444444 156.444444 \n", - "1 28.111111 171.333333 " + "0 229.222222 158.888889 \n", + "1 29.444444 156.444444 \n", + "2 28.111111 171.333333 " ] }, - "execution_count": 23, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Run this after the decoder configuration and post-processing rules are fixed.\n", + "test_baseline_df = evaluate_on_pianovam(\n", + " \"test\", metadata_df,\n", + " AUDIO_DIR, \n", + " MIDI_DIR, \n", + " TSV_DIR, \n", + " RAW_PREDICTIONS_DIR,\n", + " basic_pitch_model,\n", + ")\n", "\n", "test_tuned_df, test_tuned_predictions = evaluate_new_configuration_on_pianovam(\n", " TUNED_CONFIG,\n", @@ -5802,11 +5851,9 @@ ")\n", "\n", "test_comparison = pd.DataFrame([\n", + " comparison_row(\"Default Basic Pitch\", test_baseline_df), \n", " comparison_row(\"Tuned Basic Pitch\", test_tuned_df),\n", - " comparison_row(\n", - " \"Tuned + targeted post-processing\",\n", - " test_postprocessed_df,\n", - " ),\n", + " comparison_row(\"Tuned + targeted post-processing\", test_postprocessed_df),\n", "])\n", "\n", "test_comparison" @@ -5830,7 +5877,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "id": "edb228ba", "metadata": {}, "outputs": [ @@ -5850,7 +5897,7 @@ "{'matched': 35, 'missing': 7, 'extra': 16}" ] }, - "execution_count": 35, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } diff --git a/notebooks/README.md b/notebooks/README.md new file mode 100644 index 0000000..5ae0b37 --- /dev/null +++ b/notebooks/README.md @@ -0,0 +1,11 @@ +# notebooks/ + +This folder holds only the organised summary notebooks for each phase, and `notebooks/utils/` contains the large chunks of helper functions used inside these notebooks (plotting, file +loaders, etc.). All code for deployment is under the `/evaluation_function` directory, and all the notebooks produced during development remains on each branch respectively. + + +- **`phase1-1.5_summary.ipynb`** -- Development and evaluation of the MIDI evaluator and feedback generation module (evaluation_function/compare_MIDI.py). + +- **`phase2_summary.ipynb`** -- Development and evaluation of the Audio-to-MIDI transcription module (evaluation_function/audio_processing.py). + +- **`Demostration.ipynb`** -- End-to-end demonstration of how the complete audio -> feedback process works on a real self-recorded practice audio. diff --git a/notebooks/utils/alignment_visualisation.py b/notebooks/utils/alignment_visualisation.py index 3d43efd..d69b8e4 100644 --- a/notebooks/utils/alignment_visualisation.py +++ b/notebooks/utils/alignment_visualisation.py @@ -9,15 +9,15 @@ def format_event_pitch(event): """ Convert an event into a short pitch label for the alignment diagram. - A note event is shown as a single MIDI pitch, e.g.: 60 + A note event is shown as a single MIDI pitch, e.g. 60 A chord event is shown as a set of MIDI pitches, e.g.: {60, 64, 67} """ - pitches = [note["pitch"] for note in event["notes"]] + pitches = [note["pitch"] for note in event["notes"]] # list of MIDI pitches in the event if len(pitches) == 1: - return str(pitches[0]) + return str(pitches[0]) # single note - return "{" + ", ".join(str(pitch) for pitch in pitches) + "}" + return "{" + ", ".join(str(pitch) for pitch in pitches) + "}" # chord def plot_edit_distance_alignment(operations, D, response_events, ref_events): """ @@ -53,12 +53,12 @@ def plot_edit_distance_alignment(operations, D, response_events, ref_events): for operation in reversed(operations): operation_type = operation["type"] - if operation_type in ("match", "replacement"): + if operation_type in ("match", "replacement"): # both indices decrease n -= 1 m -= 1 - elif operation_type == "extra": + elif operation_type == "extra": # only the response index decreases n -= 1 - elif operation_type == "missing": + elif operation_type == "missing": # only the reference index decreases m -= 1 path_rows.append(n) path_cols.append(m) @@ -136,7 +136,7 @@ def plot_edit_distance_alignment(operations, D, response_events, ref_events): pitch_label = format_event_pitch(event) ax.add_patch( plt.Rectangle( - (xpos - box_width / 2, reference_y), + (xpos - box_width / 2, response_y), box_width, box_height, fill=False, edgecolor="black", linewidth=1.5) ) @@ -187,6 +187,4 @@ def plot_edit_distance_alignment(operations, D, response_events, ref_events): ax.set_ylim(0, 4) ax.set_title("Alignment Diagram") plt.tight_layout() - plt.show() - - + plt.show() \ No newline at end of file diff --git a/notebooks/utils/error_analysis.py b/notebooks/utils/error_analysis.py index 8ccff23..c6e848b 100644 --- a/notebooks/utils/error_analysis.py +++ b/notebooks/utils/error_analysis.py @@ -68,6 +68,7 @@ def get_note_match_info(sample_id, metadata_df, audio_dir, midi_dir, predicted_notes, offset_key="offset" ) + # Use mir_eval to match predicted notes to reference notes, allowing a small onset tolerance. matching = mir_eval.transcription.match_notes( reference_intervals, reference_pitches, @@ -77,6 +78,7 @@ def get_note_match_info(sample_id, metadata_df, audio_dir, midi_dir, offset_ratio=None, ) + # The matching is a list of (reference_index, predicted_index) pairs. matched_reference_indices = set(pair[0] for pair in matching) matched_predicted_indices = set(pair[1] for pair in matching) @@ -119,7 +121,9 @@ def summarise_fp_fn_over_train_set(train_samples, metadata_df, audio_dir, matched_reference_indices = match_info["matched_reference_indices"] matched_predicted_indices = match_info["matched_predicted_indices"] + # Sort predicted notes by onset time sorted_predicted_notes = sorted(predicted_notes, key=lambda note: note["onset"]) + # Create a list of matched predicted notes for easier pattern analysis. matched_predicted_notes = [predicted_notes[i] for i in matched_predicted_indices] if len(reference_notes) > 0: @@ -147,12 +151,16 @@ def summarise_fp_fn_over_train_set(train_samples, metadata_df, audio_dir, same_pitch = (other_note["pitch"] == note["pitch"]) is_before = (other_note["offset"] <= note["onset"]) gap = note["onset"] - other_note["offset"] + # Check if there is a nearby predicted note with the same pitch that ends + # before this note starts, and is within max_gap_seconds. if same_pitch and is_before and (0 <= gap <= max_gap_seconds): has_fragment_pattern = True has_harmonic_interval_pattern = False for matched_note in matched_predicted_notes: pitch_gap = abs(note["pitch"] - matched_note["pitch"]) + # Check if the pitch gap is a common harmonic interval (perfect fifth, octave, + # or compound intervals) and if the notes overlap in time within the onset window. if pitch_gap in interval_sizes and notes_overlap(note, matched_note, tolerance=onset_window_seconds): has_harmonic_interval_pattern = True @@ -166,12 +174,13 @@ def summarise_fp_fn_over_train_set(train_samples, metadata_df, audio_dir, neither_pattern = neither_pattern + 1 duration = note["offset"] - note["onset"] + # Check if the extra note is short if duration < short_note_seconds: short_extra = short_extra + 1 - + # Check if the extra note starts before the first reference note. if note["onset"] < first_reference_onset: extra_at_beginning = extra_at_beginning + 1 - + # Check if there are multiple reference notes starting near this extra note's onset. nearby_reference_count = count_nearby_reference_notes( reference_notes, note["onset"], onset_window_seconds ) @@ -190,11 +199,15 @@ def summarise_fp_fn_over_train_set(train_samples, metadata_df, audio_dir, total_missing = total_missing + 1 duration = note["frame_offset"] - note["onset"] + # Check if the missing note is short. if duration < short_note_seconds: short_missing = short_missing + 1 has_nearby_same_pitch_reference = False for other_index, other_note in enumerate(reference_notes): + # Check if there is another reference note with the same pitch + # that starts within max_gap_seconds of this missing note's onset, + # mark this missing note as having a repeated pitch nearby. if other_index != reference_index: same_pitch = other_note["pitch"] == note["pitch"] onset_gap = abs(other_note["onset"] - note["onset"]) @@ -203,9 +216,13 @@ def summarise_fp_fn_over_train_set(train_samples, metadata_df, audio_dir, if has_nearby_same_pitch_reference: repeated_pitch_missing = repeated_pitch_missing + 1 + # Check if there are multiple reference notes starting near this missing note's onset, + # which may indicate it's part of a chord or dense region. nearby_reference_count = count_nearby_reference_notes( reference_notes, note["onset"], onset_window_seconds ) + # If there are two or more reference notes starting near this missing note's onset, + # mark it as chord-related missing. if nearby_reference_count >= 2: chord_related_missing = chord_related_missing + 1 diff --git a/notebooks/utils/nasap_alignment_evaluation.py b/notebooks/utils/nasap_alignment_evaluation.py index 49ae501..f4ddccb 100644 --- a/notebooks/utils/nasap_alignment_evaluation.py +++ b/notebooks/utils/nasap_alignment_evaluation.py @@ -2,7 +2,7 @@ nasap_alignment_evaluation.py ============================= Helper functions for evaluating the Phase 1 event-level MIDI alignment -pipeline on the CPJKU nASAP dataset. +pipeline on the (n)ASAP dataset. """ import csv @@ -31,7 +31,7 @@ def load_ground_truth(tsv_path): """ - Read a note_alignment.tsv file from the CPJKU nASAP dataset. + Read a note_alignment.tsv file from the (n)ASAP dataset. Returns one dictionary per TSV row. XML and MIDI identifiers are retained so that individual alignment errors can be traced later. Keys: @@ -184,7 +184,7 @@ def build_sample(xml_path, response_path, composer, title, metadata_row): def load_samples(asap_path, composer): """ Read metadata.csv and return MusicXML-score / MIDI-performance samples - for one composer. + for specified composer. """ metadata_path = os.path.join(asap_path, "metadata.csv") samples = [] @@ -193,13 +193,16 @@ def load_samples(asap_path, composer): reader = csv.DictReader(csv_file) for row in reader: + # Only load samples for the specified composer. if row.get("composer", "").strip() != composer: continue xml_path = os.path.join(asap_path, row.get("xml_score", "").strip()) response_path = os.path.join(asap_path, row.get("midi_performance", "").strip()) tsv_path = os.path.join(asap_path, row.get("note_alignments", "").strip()) - + + # Only load samples that have all three required files: + # MusicXML score, performance MIDI, and ground-truth TSV. if os.path.isfile(xml_path) and os.path.isfile(response_path) and os.path.isfile(tsv_path): sample = build_sample( xml_path, @@ -285,12 +288,12 @@ def convert_pipeline_output(event_details, response_events, ref_events): response_event = None reference_event = None + # Find the corresponding response and reference events, if they exist. if event.get("response_index") is not None: response_index = event["response_index"] - 1 if (response_index < 0) or (response_index >= len(response_events)): raise IndexError("response_index is outside response_events") response_event = response_events[response_index] - if event.get("reference_index") is not None: reference_index = event["reference_index"] - 1 if (reference_index < 0) or (reference_index >= len(ref_events)): @@ -408,6 +411,8 @@ def compute_metrics(ground_truth, predictions, onset_offset=0.0): gt_insertions = {} predicted_insertions = {} + # Group insertions by pitch so onset-matching only happens within the same pitch + # (count_onset_matches only compares onset times, not pitch). for row in ground_truth: if ( row["label"] == "insertion" @@ -418,7 +423,6 @@ def compute_metrics(ground_truth, predictions, onset_offset=0.0): if pitch not in gt_insertions: gt_insertions[pitch] = [] gt_insertions[pitch].append(float(row["onset"])) - for row in predictions: if ( row["label"] == "insertion" @@ -431,7 +435,8 @@ def compute_metrics(ground_truth, predictions, onset_offset=0.0): predicted_insertions[pitch].append( float(row["onset"]) + onset_offset ) - + # Match onsets separately within each pitch, so an insertion can only be + # matched against a ground-truth insertion of the same pitch. for pitch in set(gt_insertions) | set(predicted_insertions): gt_onsets = gt_insertions.get(pitch, []) predicted_onsets = predicted_insertions.get(pitch, []) @@ -482,6 +487,7 @@ def compute_metrics(ground_truth, predictions, onset_offset=0.0): def get_note_centre(note): + """Find the centre of a note for plotting a connector line.""" return ( note["start"] + note["duration"] / 2, note["pitch"], @@ -489,6 +495,7 @@ def get_note_centre(note): def event_overlaps_range(event, start, end): + """Check if any note in an event overlaps a given time range.""" for note in event["notes"]: note_start = note["start"] note_end = note["start"] + note["duration"] @@ -525,7 +532,7 @@ def pair_event_notes(ref_event, response_event): # First pair notes with identical pitches. for response_index, response_note in enumerate(response_notes): matching_ref_index = None - + # Search for a matching reference note with the same pitch that hasn't been used yet. for ref_index, ref_note in enumerate(ref_notes): ref_is_available = ref_index not in used_ref_indices pitches_match = ref_note["pitch"] == response_note["pitch"] @@ -575,31 +582,29 @@ def pair_event_notes(ref_event, response_event): def plot_alignment(ref_events, response_events, event_details, ref_start, ref_end): + """Plot a piano-roll visualisation of the event-level alignment.""" reference_positions = [] - + # Find the first and last positions in event_details that contain reference events for position, detail in enumerate(event_details): reference_index = detail.get("reference_index") - if reference_index is not None: ref_event = ref_events[reference_index - 1] - if event_overlaps_range( ref_event, ref_start, ref_end, ): reference_positions.append(position) - if not reference_positions: raise ValueError( "No reference events were found in this range." ) - first_position = min(reference_positions) last_position = max(reference_positions) + # Select all event_details between the first and last positions, + # including any extra events that may not have a reference event. selected_details = [] - for position in range(first_position, last_position + 1): detail = event_details[position] operation = detail["operation_type"] @@ -616,9 +621,10 @@ def plot_alignment(ref_events, response_events, event_details, ref_start, ref_en if include_detail: selected_details.append(detail) + # Find the earliest start and latest end times of the response events that + # correspond to the selected details. response_starts = [] response_ends = [] - for detail in selected_details: response_index = detail.get("response_index") @@ -636,6 +642,8 @@ def plot_alignment(ref_events, response_events, event_details, ref_start, ref_en response_start = ref_start response_end = ref_end + # Filter the response and reference events to only include + # those that overlap the specified time ranges. visible_response_events = [] for event in response_events: if event_overlaps_range(event, response_start, response_end): @@ -771,7 +779,7 @@ def plot_alignment(ref_events, response_events, event_details, ref_start, ref_en for detail in selected_details: operation = detail["operation_type"] - + # Draw missing note markers. if operation == "missing": reference_index = detail.get("reference_index") @@ -793,7 +801,7 @@ def plot_alignment(ref_events, response_events, event_details, ref_start, ref_en ) missing_count += 1 - + # Draw extra note markers. elif operation == "extra": response_index = detail.get("response_index") @@ -848,8 +856,12 @@ def plot_alignment(ref_events, response_events, event_details, ref_start, ref_en def plot_case(ax_response, ax_ref, fig, ref_events, response_events, event_details, ref_start, ref_end, title): + """ + Plot a piano-roll visualisation of the event-level alignment for a single case. + This function is similar to plot_alignment but allows for more control over the axes and figure. + """ selected_details = [] - + # Select all event_details that have a reference event overlapping the specified range for detail in event_details: reference_index = detail.get("reference_index") @@ -860,7 +872,7 @@ def plot_case(ax_response, ax_ref, fig, ref_events, response_events, event_detai selected_details.append(detail) selected_positions = [] - + # Find the first and last positions in event_details that contain reference events for position, detail in enumerate(event_details): if detail in selected_details: selected_positions.append(position) @@ -877,7 +889,8 @@ def plot_case(ax_response, ax_ref, fig, ref_events, response_events, event_detai response_starts = [] response_ends = [] - + # Find the earliest start and latest end times of the response events that + # correspond to the selected details. for detail in selected_details: response_index = detail.get("response_index") @@ -898,7 +911,8 @@ def plot_case(ax_response, ax_ref, fig, ref_events, response_events, event_detai visible_ref_events = [] visible_response_events = [] visible_pitches = [] - + # Filter the response and reference events to only include those + # that overlap the specified time ranges. for event in ref_events: if event_overlaps_range(event, ref_start, ref_end): visible_ref_events.append(event) @@ -932,12 +946,14 @@ def plot_case(ax_response, ax_ref, fig, ref_events, response_events, event_detai ax_response.set_xlim(response_start, response_end) ax_ref.set_xlim(ref_start, ref_end) + # Set the y-axis limits based on the visible pitches, with a margin of 1 pitch above and below. if visible_pitches: pitch_min = min(visible_pitches) - 1 pitch_max = max(visible_pitches) + 1 ax_response.set_ylim(pitch_min, pitch_max) ax_ref.set_ylim(pitch_min, pitch_max) + # Draw connectors and markers for each selected detail. for detail in selected_details: operation = detail["operation_type"] reference_index = detail.get("reference_index") @@ -997,10 +1013,7 @@ def plot_case(ax_response, ax_ref, fig, ref_events, response_events, event_detai ax_ref.set_xlabel("Time (s)") -def evaluate_alignment_dataset( - asap_path, - composer="Bach", -): +def evaluate_alignment_dataset(asap_path, composer="Bach"): """ Load one composer's nASAP samples, run the Phase 1 pipeline and evaluate the predicted note-level alignment labels against the nASAP ground truth. @@ -1031,14 +1044,16 @@ def evaluate_alignment_dataset( print("TSV not found:", tsv_path) continue + # Load the nASAP ground-truth alignment for this sample. ground_truth = load_ground_truth(tsv_path) - + # Convert the pipeline output into note-level labels predictions = convert_pipeline_output( result["event_details"], result["response_events_normalized"], result["ref_events_normalized"], ) - + # compute_metrics uses the normalised response event times, + # restore the original MIDI onset times before comparing with nASAP. metrics = compute_metrics( ground_truth, predictions, @@ -1146,48 +1161,21 @@ def prepare_alignment_case_study(samples, all_results, sample_index, asap_path=N metrics = compute_metrics(ground_truth, predictions) ground_truth_counts = Counter(note["label"] for note in ground_truth) - prediction_counts = Counter(note["label"] for note in predictions) - ground_truth_response_note_count = ( - ground_truth_counts["paired"] - + ground_truth_counts["insertion"] - ) + ground_truth_response_note_count = ground_truth_counts["paired"] + ground_truth_counts["insertion"] + ground_truth_reference_note_count = ground_truth_counts["paired"] + ground_truth_counts["deletion"] - ground_truth_reference_note_count = ( - ground_truth_counts["paired"] - + ground_truth_counts["deletion"] - ) + prediction_response_note_count = prediction_counts["paired"] + prediction_counts["insertion"] + prediction_reference_note_count = prediction_counts["paired"] + prediction_counts["deletion"] - prediction_response_note_count = ( - prediction_counts["paired"] - + prediction_counts["insertion"] - ) + actual_response_note_count = sum(len(event["notes"]) for event in response_events) + actual_reference_note_count = sum(len(event["notes"]) for event in ref_events) - prediction_reference_note_count = ( - prediction_counts["paired"] - + prediction_counts["deletion"] - ) - - actual_response_note_count = sum( - len(event["notes"]) - for event in response_events - ) - - actual_reference_note_count = sum( - len(event["notes"]) - for event in ref_events - ) - - response_notes_conserved = ( - prediction_response_note_count - == actual_response_note_count - ) - - reference_notes_conserved = ( - prediction_reference_note_count - == actual_reference_note_count - ) + # Check whether every response and reference note is represented exactly + # once in the converted pipeline output. + response_notes_conserved = (prediction_response_note_count == actual_response_note_count) + reference_notes_conserved = (prediction_reference_note_count == actual_reference_note_count) case_study.update({ "paths": paths, @@ -1208,6 +1196,7 @@ def prepare_alignment_case_study(samples, all_results, sample_index, asap_path=N return case_study + def print_alignment_case_summary(case_study): """ Print the label counts and conservation checks for one case study. @@ -1349,4 +1338,4 @@ def plot_typical_alignment_cases( fig.legend(handles=legend_items, loc="lower center", ncol=5) fig.suptitle(title, fontsize=15) plt.tight_layout(rect=[0, 0.1, 1, 0.93]) - plt.show() + plt.show() \ No newline at end of file diff --git a/notebooks/utils/pianovam_loading.py b/notebooks/utils/pianovam_loading.py index 0322bc8..a93974a 100644 --- a/notebooks/utils/pianovam_loading.py +++ b/notebooks/utils/pianovam_loading.py @@ -1,8 +1,8 @@ """ pianovam_loading.py =================== -downloading the dataset, loading metadata and ground truth, -computing mir_eval-based transcription metrics, +downloading the dataset, loading metadata and ground truth, +converting notes into mir_eval-compatible arrays """ @@ -57,6 +57,7 @@ def load_pianovam_metadata(metadata_path): metadata_df = pd.DataFrame.from_dict(metadata, orient="index").reset_index(names="sample_id") metadata_df["sample_id"] = metadata_df["sample_id"].astype(str) + # Convert duration to seconds metadata_df["duration_seconds"] = pd.to_timedelta(metadata_df["duration"]).dt.total_seconds() return metadata_df diff --git a/notebooks/utils/postprocessing_evaluation.py b/notebooks/utils/postprocessing_evaluation.py index 43e8fa4..02204a3 100644 --- a/notebooks/utils/postprocessing_evaluation.py +++ b/notebooks/utils/postprocessing_evaluation.py @@ -28,30 +28,32 @@ def evaluate_postprocessing(postprocess_function, train_samples, rows = [] postprocessed_predictions = {} + # Loop through each sample in the training set and evaluate the post-processed predictions for row_index, sample in tqdm( train_samples.iterrows(), total=len(train_samples), desc="Post-processing evaluation", ): - sample_id = str(sample["sample_id"]) - paths = get_sample_paths(sample, audio_dir, midi_dir, tsv_dir) + sample_id = str(sample["sample_id"]) # convert sample_id to string for consistent dictionary key usage + paths = get_sample_paths(sample, audio_dir, midi_dir, tsv_dir) # get the paths for the sample's audio, MIDI, and TSV files - reference_notes = load_ground_truth_notes(paths["tsv"]) - predicted_notes = tuned_predictions[sample_id] - postprocessed_notes = postprocess_function(predicted_notes) + reference_notes = load_ground_truth_notes(paths["tsv"]) # load the ground truth notes from the TSV file + predicted_notes = tuned_predictions[sample_id] # retrieve the tuned predictions for the current sample + postprocessed_notes = postprocess_function(predicted_notes) # apply the post-processing function to the predicted notes - metrics = evaluate_note_transcription(reference_notes, postprocessed_notes) - transcription_output = analyse_transcription_output(reference_notes, postprocessed_notes) + metrics = evaluate_note_transcription(reference_notes, postprocessed_notes) # evaluate the post-processed notes against the ground truth notes + transcription_output = analyse_transcription_output(reference_notes, postprocessed_notes) # analyze the transcription output for additional metrics + # create a row dictionary to store the evaluation results for the current sample row = { "sample_id": sample_id, "composer": sample["composer"], "piece": sample["piece"], - } - row.update(metrics) - row.update(transcription_output) - rows.append(row) + } + row.update(metrics) # add the evaluation metrics to the row dictionary + row.update(transcription_output) # add the transcription output analysis to the row dictionary + rows.append(row) # append the row dictionary to the list of rows for the final results DataFrame - postprocessed_predictions[sample_id] = postprocessed_notes + postprocessed_predictions[sample_id] = postprocessed_notes # store the post-processed notes in the dictionary for later use return pd.DataFrame(rows), postprocessed_predictions diff --git a/notebooks/utils/random_search.py b/notebooks/utils/random_search.py index 7e0371d..e375553 100644 --- a/notebooks/utils/random_search.py +++ b/notebooks/utils/random_search.py @@ -55,11 +55,14 @@ def run_random_search(train_samples, parameter_sets, basic_pitch_model, Returns basic_pitch_model, since it may be replaced with a fresh model object partway through the search. """ + # Load the sample_ids that have already been processed, so we can skip them. completed_sample_ids = load_completed_sample_ids(progress_path) remaining_samples = train_samples[ ~train_samples["sample_id"].astype(str).isin(completed_sample_ids) ] + # Loop over every sample in the train split, and evaluate every + # parameter configuration against it. for sample_index, (row_index, sample) in enumerate( tqdm(remaining_samples.iterrows(), total=len(remaining_samples), desc="Random search") ): @@ -69,9 +72,9 @@ def run_random_search(train_samples, parameter_sets, basic_pitch_model, sample_rows = [] for config_id, config in enumerate(parameter_sets): - predicted_notes = decode_model_output(model_output, config) - metrics = evaluate_note_transcription(reference_notes, predicted_notes) - + predicted_notes = decode_model_output(model_output, config) # decode the raw model output into note events using the current parameter configuration + metrics = evaluate_note_transcription(reference_notes, predicted_notes) # evaluate the predicted notes against the ground truth notes + # create a row dictionary to store the evaluation results for the current sample and configuration row = {"config_id": config_id, "sample_id": sample["sample_id"]} row.update(config) row.update(metrics) @@ -85,7 +88,7 @@ def run_random_search(train_samples, parameter_sets, basic_pitch_model, # Release this sample's raw model output before moving on. del model_output - gc.collect() + gc.collect() # Force garbage collection to free memory used by the raw model output, which can be large and is no longer needed after evaluation. # Periodically recreate the Basic Pitch model object. # TensorFlow keeps caching a new computation graph every time @@ -106,8 +109,10 @@ def summarise_random_search_results(progress_path): Load the full per-sample search log and aggregate it into one row per configuration, sorted best-first by note_f1_no_offset. """ - search_details = pd.read_csv(progress_path) + search_details = pd.read_csv(progress_path) # load the full per-sample search log from the CSV file at progress_path + # Group by configuration parameters and compute the mean of the + # evaluation metrics for each configuration across all samples random_search_results = ( search_details .groupby([ diff --git a/notebooks/utils/transcription_evaluation.py b/notebooks/utils/transcription_evaluation.py index c0b79af..ab8f897 100644 --- a/notebooks/utils/transcription_evaluation.py +++ b/notebooks/utils/transcription_evaluation.py @@ -66,8 +66,7 @@ def transcribe_audio_cached(cache_dir, sample_id, audio_path, model, **config): """ Return cached predicted notes for a sample if available, otherwise run Basic Pitch once (optionally with non-default decoding - parameters passed via config, e.g. onset_threshold=0.7) and cache - the result. + parameters passed via config) and cache the result. Returns (predicted_notes, runtime_seconds). runtime_seconds is None when the result came from the cache, since no transcription @@ -122,7 +121,7 @@ def decode_model_output(model_output, config): """ min_note_len = int(round( config["minimum_note_length"] / 1000 * AUDIO_SAMPLE_RATE / FFT_HOP - )) + )) # Convert milliseconds to frames, since model_output_to_notes expects a frame count. # model_output_to_notes does not modify the raw "note"/"onset"/ # "contour" arrays in place as long as min_freq/max_freq are left @@ -252,6 +251,8 @@ def evaluate_on_pianovam(split_name, metadata_df, audio_dir, midi_dir, rows = [] + # Run Basic Pitch on every sample in the split, using the raw-prediction + # cache to avoid re-running the model on samples already processed. for row_index, sample in split_samples.iterrows(): paths = get_sample_paths(sample, audio_dir, midi_dir, tsv_dir) reference_notes = load_ground_truth_notes(paths["tsv"]) @@ -260,6 +261,8 @@ def evaluate_on_pianovam(split_name, metadata_df, audio_dir, midi_dir, **BASIC_PITCH_DEFAULT_CONFIG ) + # Evaluate the predicted notes against the ground truth using both mir_eval metrics + # and compareMusic alignment stats. transcription_metrics = evaluate_note_transcription(reference_notes, predicted_notes) transcription_output = analyse_transcription_output(reference_notes, predicted_notes) @@ -291,7 +294,9 @@ def evaluate_new_configuration_on_pianovam(config, samples_df, audio_dir, """ rows = [] predictions_by_sample_id = {} - + + # Run Basic Pitch on every sample in the split, using the specified configuration + # and without caching, since the cache only stores default-configuration predictions. for row_index, sample in tqdm(samples_df.iterrows(), total=len(samples_df), desc="Evaluating configuration"): paths = get_sample_paths(sample, audio_dir, midi_dir, tsv_dir) reference_notes = load_ground_truth_notes(paths["tsv"]) @@ -563,7 +568,8 @@ def match_notes_for_plotting(reference_notes, predicted_notes, onset_tolerance=onset_tolerance, offset_ratio=offset_ratio, ) - + + # mir_eval returns a list of (reference_index, predicted_index) pairs for matched notes. matched_reference_indices = {pair[0] for pair in matching} matched_predicted_indices = {pair[1] for pair in matching}