audio.py
2.85 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
import librosa
import numpy as np
import torch
from typing import List, Optional, Tuple
class AudioProcessor:
def __init__(self, sr: int = 16000, n_mels: int = 128, n_fft: int = 512, hop_length: int = 160):
self.sr = sr
self.n_mels = n_mels
self.n_fft = n_fft
self.hop_length = hop_length
def load(self, path: str, sr: Optional[int] = None, duration: Optional[float] = None) -> np.ndarray:
y, _ = librosa.load(path, sr=sr or self.sr, mono=True, duration=duration)
return y
def to_mel(self, y: np.ndarray) -> np.ndarray:
mel = librosa.feature.melspectrogram(
y=y, sr=self.sr, n_mels=self.n_mels, n_fft=self.n_fft, hop_length=self.hop_length
)
return librosa.power_to_db(mel, ref=np.max)
def to_mel_tensor(self, y: np.ndarray) -> torch.Tensor:
mel = self.to_mel(y)
return torch.FloatTensor(mel).unsqueeze(0)
def sliding_windows(self, y: np.ndarray, window_sec: float = 5.0, stride_sec: float = 2.5) -> List[np.ndarray]:
win_len = int(window_sec * self.sr)
stride = int(stride_sec * self.sr)
if len(y) < win_len:
pad = win_len - len(y)
y = np.pad(y, (0, pad))
windows = []
for start in range(0, len(y) - win_len + 1, stride):
windows.append(y[start : start + win_len])
if not windows:
windows.append(y[:win_len])
return windows
def mel_from_path(self, path: str) -> Tuple[torch.Tensor, float]:
y = self.load(path)
duration = len(y) / self.sr
return self.to_mel_tensor(y), duration
def extract_chroma(self, y: np.ndarray) -> np.ndarray:
return librosa.feature.chroma_cqt(y=y, sr=self.sr)
def extract_f0(self, y: np.ndarray, fmin=65, fmax=2093) -> np.ndarray:
f0, _, _ = librosa.pyin(y, sr=self.sr, fmin=fmin, fmax=fmax)
return np.nan_to_num(f0, nan=0.0)
def melody_signature(self, y: np.ndarray) -> np.ndarray:
f0 = self.extract_f0(y)
if f0.size == 0:
return np.zeros(32, dtype=np.float32)
nonzero = f0[f0 > 0]
if nonzero.size == 0:
return np.zeros(32, dtype=np.float32)
contour = np.diff(np.log2(nonzero + 1e-6), prepend=np.log2(nonzero[0] + 1e-6))
contour = np.clip(contour, -0.5, 0.5)
if contour.size < 32:
contour = np.pad(contour, (0, 32 - contour.size))
else:
idx = np.linspace(0, contour.size - 1, 32).astype(int)
contour = contour[idx]
return contour.astype(np.float32)
def melody_similarity(self, y1: np.ndarray, y2: np.ndarray) -> float:
s1 = self.melody_signature(y1)
s2 = self.melody_signature(y2)
denom = float(np.linalg.norm(s1) * np.linalg.norm(s2) + 1e-12)
if denom <= 1e-12:
return 0.0
return float(np.dot(s1, s2) / denom)