import os import numpy as np import matplotlib # 关键修复：防止界面环境下 Matplotlib 尝试开启 GUI 导致卡死 matplotlib.use('Agg') import matplotlib.pyplot as plt import pretty_midi from scipy.spatial.distance import cdist class MIDIPitchEvaluator: def __init__(self, original_midi_path, cover_midi_path, time_threshold=0.2, tolerance=0, unmatched_penalty_weight=0.05, time_deviation_weight=0.01, output_dir='results'): """初始化MIDI音准评价器 (Hugging Face 兼容版)""" self.original_midi_path = original_midi_path self.cover_midi_path = cover_midi_path self.time_threshold = time_threshold self.tolerance = tolerance self.minor_deviation_upper = 1 self.severe_deviation_lower = 2 self.unmatched_penalty_weight = unmatched_penalty_weight self.time_deviation_weight = time_deviation_weight # 确保输出目录存在 self.output_dir = output_dir os.makedirs(self.output_dir, exist_ok=True) # 存储分析结果 self.original_notes = None self.cover_notes = None self.note_mapping = None self.pitch_deviations = None self.start_time_deviations = None self.end_time_deviations = None self.total_time_deviations = None self.statistics = None self.matched_pairs = [] self.unmatched_cover_notes = 0 self.unmatched_original_notes = 0 def load_midi_files(self): try: self.original_midi = pretty_midi.PrettyMIDI(self.original_midi_path) self.original_notes = self._find_singing_voice_notes(self.original_midi) self.cover_midi = pretty_midi.PrettyMIDI(self.cover_midi_path) self.cover_notes = self._find_singing_voice_notes(self.cover_midi) if self.original_notes is None: if len(self.original_midi.instruments) > 0: self.original_notes = self.original_midi.instruments[0].notes else: return False if self.cover_notes is None: if len(self.cover_midi.instruments) > 0: self.cover_notes = self.cover_midi.instruments[0].notes else: return False return True except Exception as e: print(f"加载MIDI文件出错: {e}") return False def _find_singing_voice_notes(self, midi_obj): for instrument in midi_obj.instruments: if instrument.name.lower() == "singing voice": return instrument.notes return None def align_notes(self): if not self.original_notes or not self.cover_notes: return False self.note_mapping = {} self.start_time_deviations = [] self.end_time_deviations = [] self.total_time_deviations = [] self.matched_pairs = [] cover_starts = np.array([note.start for note in self.cover_notes]) cover_ends = np.array([note.end for note in self.cover_notes]) original_starts = np.array([note.start for note in self.original_notes]) original_ends = np.array([note.end for note in self.original_notes]) cover_pitches = np.array([note.pitch for note in self.cover_notes]) original_pitches = np.array([note.pitch for note in self.original_notes]) cover_time_features = np.column_stack((cover_starts, cover_ends)) original_time_features = np.column_stack((original_starts, original_ends)) time_dist_matrix = cdist(cover_time_features, original_time_features, metric='euclidean') pitch_dist_matrix = cdist(cover_pitches.reshape(-1, 1), original_pitches.reshape(-1, 1), metric='euclidean') for i in range(len(self.cover_notes)): candidates = np.where(time_dist_matrix[i] < self.time_threshold * np.sqrt(2))[0] if len(candidates) == 0: self.note_mapping[i] = None continue best_j = candidates[np.argmin(pitch_dist_matrix[i, candidates])] start_time_dev = self.cover_notes[i].start - self.original_notes[best_j].start end_time_dev = self.cover_notes[i].end - self.original_notes[best_j].end self.start_time_deviations.append(start_time_dev) self.end_time_deviations.append(end_time_dev) self.total_time_deviations.append(abs(start_time_dev) + abs(end_time_dev)) self.matched_pairs.append([i, best_j, 0, start_time_dev, end_time_dev]) self.note_mapping[i] = best_j self.matched_count = len(self.matched_pairs) self.total_cover_notes = len(self.cover_notes) self.unmatched_cover_notes = self.total_cover_notes - self.matched_count return True def calculate_pitch_deviations(self): if self.note_mapping is None: return False self.pitch_deviations = [] for i in range(len(self.matched_pairs)): cover_idx, original_idx = self.matched_pairs[i][0], self.matched_pairs[i][1] pitch_dev = self.cover_notes[cover_idx].pitch - self.original_notes[original_idx].pitch self.pitch_deviations.append(pitch_dev) self.matched_pairs[i][2] = pitch_dev return True def calculate_statistics(self): if not self.pitch_deviations: return False pitch_devs = np.array(self.pitch_deviations) total_matched = len(pitch_devs) minor_count = np.sum((np.abs(pitch_devs) > self.tolerance) & (np.abs(pitch_devs) <= self.minor_deviation_upper)) severe_count = np.sum(np.abs(pitch_devs) >= self.severe_deviation_lower) minor_ratio = minor_count / total_matched * 100 severe_ratio = severe_count / total_matched * 100 cover_unmatched_ratio = (self.unmatched_cover_notes / self.total_cover_notes * 100) total_time_total = np.sum(self.total_time_deviations) normalized_time_dev = total_time_total / (self.time_threshold * 2) if self.time_threshold > 0 else 0 time_penalty = min(normalized_time_dev * self.time_deviation_weight, 15) base_score = 100 - severe_ratio * 0.1 - minor_ratio * 0.2 unmatched_penalty = cover_unmatched_ratio * self.unmatched_penalty_weight total_penalty = unmatched_penalty + time_penalty overall_score = max(60, base_score - total_penalty) self.statistics = { 'total_matched_notes': total_matched, 'total_cover_notes': self.total_cover_notes, 'mean_abs_pitch_dev': np.mean(np.abs(pitch_devs)), 'accurate_pitch_percentage': np.sum(np.abs(pitch_devs) <= self.tolerance) / total_matched * 100, 'minor_off_percentage': minor_ratio, 'severe_off_percentage': severe_ratio, 'cover_unmatched_percentage': cover_unmatched_ratio, 'total_time_total': total_time_total, 'base_score': base_score, 'unmatched_penalty': unmatched_penalty, 'time_penalty': time_penalty, 'total_penalty': total_penalty, 'overall_score': overall_score } return True def _convert_time_to_srt_format(self, seconds): hours, rem = divmod(seconds, 3600) minutes, seconds = divmod(rem, 60) return f"{int(hours):02d}:{int(minutes):02d}:{int(seconds):02d},{int((seconds%1)*1000):03d}" def generate_srt_subtitle(self): if not self.matched_pairs: return False sorted_pairs = sorted(self.matched_pairs, key=lambda x: self.cover_notes[x[0]].start) srt_content = [] for i, (c_idx, o_idx, p_dev, s_dev, e_dev) in enumerate(sorted_pairs, 1): cn, on = self.cover_notes[c_idx], self.original_notes[o_idx] p_label = "准确" if abs(p_dev) <= self.tolerance else ("轻微走音" if abs(p_dev) <= self.minor_deviation_upper else "严重走音") text = (f"原唱: {pretty_midi.note_number_to_name(on.pitch)} | 翻唱: {pretty_midi.note_number_to_name(cn.pitch)} | " f"音高偏差: {p_dev:+}半音 ({p_label}) | 起始: {s_dev:+.3f}s | 结束: {e_dev:+.3f}s") srt_content.append(f"{i}\n{self._convert_time_to_srt_format(cn.start)} --> {self._convert_time_to_srt_format(cn.end)}\n{text}\n") out_file = os.path.join(self.output_dir, '音高与节奏对比字幕.srt') with open(out_file, 'w', encoding='utf-8') as f: f.write('\n'.join(srt_content)) return out_file def visualize_results(self): if self.statistics is None: return False try: plt.figure(figsize=(12, 6)) time_pts = [self.cover_notes[p[0]].start for p in self.matched_pairs] p_devs = [p[2] for p in self.matched_pairs] colors = ['green' if abs(d) <= self.tolerance else ('orange' if abs(d) <= self.minor_deviation_upper else 'red') for d in p_devs] plt.scatter(time_pts, p_devs, s=15, alpha=0.7, c=colors) plt.axhline(y=0, color='blue', linestyle='-', alpha=0.3) plt.title('Pitch Deviation Timeline') img_path = os.path.join(self.output_dir, '音高偏差时间序列图.png') plt.savefig(img_path) plt.close('all') return img_path except Exception as e: print(f"可视化失败: {e}") return None def evaluate(self, run_visuals=True): if not self.load_midi_files(): return False if not self.align_notes(): return False if not self.calculate_pitch_deviations(): return False if not self.calculate_statistics(): return False srt_file = self.generate_srt_subtitle() img_file = None if run_visuals: img_file = self.visualize_results() return { "statistics": self.statistics, "srt_file": srt_file, "plot_img": img_file } if __name__ == "__main__": # 本地测试代码保持不变，但 evaluate 返回字典 evaluator = MIDIPitchEvaluator( "midi_input/学不会-林俊杰-align_Vocals_basic_pitch.mid", "midi_input/学不会-zzc-align_Vocals_basic_pitch.mid" ) result = evaluator.evaluate(run_visuals=True) if result: print(f"最终得分: {result['statistics']['overall_score']:.1f}")