Skip to content

M
models

PaddlePaddle / models
大约 1 年 前同步成功

通知 222
Star 6828
Fork 2962
M
models
未验证 提交 9cab6c61 编写于 作者: R ranchlai 提交者： GitHub
浏览文件
操作

Update PaddleAudio transforms and functionals (#5334) 

* added reverb/noisify/AudioReader/RandomChoice/RandomApply

* bug fixed

* transform name changes

* work around for bug in paddle's groupnorm

* upgraded to use float64 inside for high numerical acc

* fixed docstring, add nn.Layer as super for Noisify

* fixed docstring

* added mfcc func/trans and dct function

* updated unit test

* add dtype to control datatype in win function

* add dtype control in transforms

* add dtype control in functionals

* updated test

* added dtype control, updated test
上级 14214566
显示空白变更内容
内联 并排
Showing with 1273 addition and 297 deletion
PaddleAudio/paddleaudio/core/windowing.py
浏览文件 @ 9cab6c61
......@@ -30,7 +30,6 @@ __all__ = [
'tukey',
'taylor',
]
math.pi = 3.141592653589793
def _cat(a: List[Tensor], data_type: str) -> Tensor:
......@@ -68,30 +67,42 @@ def _truncate(w: Tensor, needed: bool) -> Tensor:
return w
def general_gaussian(M: int, p, sig, sym: bool = True) -> Tensor:
def general_gaussian(M: int,
p,
sig,
sym: bool = True,
dtype: str = 'float64') -> Tensor:
"""Compute a window with a generalized Gaussian shape.
This function is consistent with scipy.signal.windows.general_gaussian().
"""
if _len_guards(M):
return paddle.ones((M, ), dtype='float32')
return paddle.ones((M, ), dtype=dtype)
M, needs_trunc = _extend(M, sym)
n = paddle.arange(0, M) - (M - 1.0) / 2.0
n = paddle.arange(0, M, dtype=dtype) - (M - 1.0) / 2.0
w = paddle.exp(-0.5 * paddle.abs(n / sig)**(2 * p))
return _truncate(w, needs_trunc)
def general_hamming(M: int, alpha: float, sym: bool = True) -> Tensor:
def general_hamming(M: int,
alpha: float,
sym: bool = True,
dtype: str = 'float64') -> Tensor:
"""Compute a generalized Hamming window.
This function is consistent with scipy.signal.windows.general_hamming()
"""
return general_cosine(M, [alpha, 1. - alpha], sym)
return general_cosine(M, [alpha, 1. - alpha], sym, dtype=dtype)
def taylor(M: int, nbar=4, sll=30, norm=True, sym: bool = True) -> Tensor:
def taylor(M: int,
nbar=4,
sll=30,
norm=True,
sym: bool = True,
dtype: str = 'float64') -> Tensor:
"""Compute a Taylor window.
The Taylor window taper function approximates the Dolph-Chebyshev window's
constant sidelobe level for a parameterized number of near-in sidelobes.
......@@ -100,13 +111,14 @@ def taylor(M: int, nbar=4, sll=30, norm=True, sym: bool = True) -> Tensor:
nbar, sil, norm: the window-specific parameter.
sym(bool)：whether to return symmetric window.
The default value is True
dtype(str): the datatype of returned tensor.
Returns:
Tensor: the window tensor
Notes:
This function is consistent with scipy.signal.windows.taylor().
"""
if _len_guards(M):
return paddle.ones((M, ), dtype='float32')
return paddle.ones((M, ), dtype=dtype)
M, needs_trunc = _extend(M, sym)
# Original text uses a negative sidelobe level parameter and then negates
# it in the calculation of B. To keep consistent with other methods we
......@@ -114,9 +126,9 @@ def taylor(M: int, nbar=4, sll=30, norm=True, sym: bool = True) -> Tensor:
B = 10**(sll / 20)
A = _acosh(B) / math.pi
s2 = nbar**2 / (A**2 + (nbar - 0.5)**2)
ma = paddle.arange(1, nbar, dtype='float32')
ma = paddle.arange(1, nbar, dtype=dtype)
Fm = paddle.empty((nbar - 1, ), dtype='float32')
Fm = paddle.empty((nbar - 1, ), dtype=dtype)
signs = paddle.empty_like(ma)
signs[::2] = 1
signs[1::2] = -1
......@@ -139,7 +151,7 @@ def taylor(M: int, nbar=4, sll=30, norm=True, sym: bool = True) -> Tensor:
Fm.unsqueeze(0),
paddle.cos(2 * math.pi * ma.unsqueeze(1) * (n - M / 2. + 0.5) / M))
w = W(paddle.arange(0, M, dtype='float32'))
w = W(paddle.arange(0, M, dtype=dtype))
# normalize (Note that this is not described in the original text [1])
if norm:
......@@ -149,22 +161,25 @@ def taylor(M: int, nbar=4, sll=30, norm=True, sym: bool = True) -> Tensor:
return _truncate(w, needs_trunc)
def general_cosine(M: int, a: float, sym: bool = True) -> Tensor:
def general_cosine(M: int,
a: float,
sym: bool = True,
dtype: str = 'float64') -> Tensor:
"""Compute a generic weighted sum of cosine terms window.
This function is consistent with scipy.signal.windows.general_cosine().
"""
if _len_guards(M):
return paddle.ones((M, ), dtype='float32')
return paddle.ones((M, ), dtype=dtype)
M, needs_trunc = _extend(M, sym)
fac = paddle.linspace(-math.pi, math.pi, M)
w = paddle.zeros((M, ), dtype='float32')
fac = paddle.linspace(-math.pi, math.pi, M, dtype=dtype)
w = paddle.zeros((M, ), dtype=dtype)
for k in range(len(a)):
w += a[k] * paddle.cos(k * fac)
return _truncate(w, needs_trunc)
def hamming(M: int, sym: bool = True) -> Tensor:
def hamming(M: int, sym: bool = True, dtype: str = 'float64') -> Tensor:
"""Compute a Hamming window.
The Hamming window is a taper formed by using a raised cosine with
non-zero endpoints, optimized to minimize the nearest side lobe.
......@@ -172,15 +187,16 @@ def hamming(M: int, sym: bool = True) -> Tensor:
M(int): window size
sym(bool)：whether to return symmetric window.
The default value is True
dtype(str): the datatype of returned tensor.
Returns:
Tensor: the window tensor
Notes:
This function is consistent with scipy.signal.windows.hamming().
"""
return general_hamming(M, 0.54, sym)
return general_hamming(M, 0.54, sym, dtype=dtype)
def hann(M: int, sym: bool = True) -> Tensor:
def hann(M: int, sym: bool = True, dtype: str = 'float64') -> Tensor:
"""Compute a Hann window.
The Hann window is a taper formed by using a raised cosine or sine-squared
with ends that touch zero.
......@@ -188,44 +204,49 @@ def hann(M: int, sym: bool = True) -> Tensor:
M(int): window size
sym(bool)：whether to return symmetric window.
The default value is True
dtype(str): the datatype of returned tensor.
Returns:
Tensor: the window tensor
Notes:
This function is consistent with scipy.signal.windows.hann().
"""
return general_hamming(M, 0.5, sym)
return general_hamming(M, 0.5, sym, dtype=dtype)
def tukey(M: int, alpha=0.5, sym: bool = True) -> Tensor:
def tukey(M: int,
alpha=0.5,
sym: bool = True,
dtype: str = 'float64') -> Tensor:
"""Compute a Tukey window.
The Tukey window is also known as a tapered cosine window.
Parameters:
M(int): window size
sym(bool)：whether to return symmetric window.
The default value is True
dtype(str): the datatype of returned tensor.
Returns:
Tensor: the window tensor
Notes:
This function is consistent with scipy.signal.windows.tukey().
"""
if _len_guards(M):
return paddle.ones((M, ), dtype='float32')
return paddle.ones((M, ), dtype=dtype)
if alpha <= 0:
return paddle.ones((M, ), dtype='float32')
return paddle.ones((M, ), dtype=dtype)
elif alpha >= 1.0:
return hann(M, sym=sym)
M, needs_trunc = _extend(M, sym)
n = paddle.arange(0, M)
n = paddle.arange(0, M, dtype=dtype)
width = int(alpha * (M - 1) / 2.0)
n1 = n[0:width + 1]
n2 = n[width + 1:M - width - 1]
n3 = n[M - width - 1:]
w1 = 0.5 * (1 + paddle.cos(math.pi * (-1 + 2.0 * n1 / alpha / (M - 1))))
w2 = paddle.ones(n2.shape, dtype='float32')
w2 = paddle.ones(n2.shape, dtype=dtype)
w3 = 0.5 * (1 + paddle.cos(math.pi * (-2.0 / alpha + 1 + 2.0 * n3 / alpha /
(M - 1))))
w = paddle.concat([w1, w2, w3])
......@@ -233,7 +254,10 @@ def tukey(M: int, alpha=0.5, sym: bool = True) -> Tensor:
return _truncate(w, needs_trunc)
def kaiser(M: int, beta: float, sym: bool = True) -> Tensor:
def kaiser(M: int,
beta: float,
sym: bool = True,
dtype: str = 'float64') -> Tensor:
"""Compute a Kaiser window.
The Kaiser window is a taper formed by using a Bessel function.
Parameters:
......@@ -251,7 +275,10 @@ def kaiser(M: int, beta: float, sym: bool = True) -> Tensor:
raise NotImplementedError()
def gaussian(M: int, std: float, sym: bool = True) -> Tensor:
def gaussian(M: int,
std: float,
sym: bool = True,
dtype: str = 'float64') -> Tensor:
"""Compute a Gaussian window.
The Gaussian widows has a Gaussian shape defined by the standard deviation(std).
......@@ -260,29 +287,35 @@ def gaussian(M: int, std: float, sym: bool = True) -> Tensor:
std(float): the window-specific parameter.
sym(bool)：whether to return symmetric window.
The default value is True
dtype(str): the datatype of returned tensor.
Returns:
Tensor: the window tensor
Notes:
This function is consistent with scipy.signal.windows.gaussian().
"""
if _len_guards(M):
return paddle.ones((M, ), dtype='float32')
return paddle.ones((M, ), dtype=dtype)
M, needs_trunc = _extend(M, sym)
n = paddle.arange(0, M) - (M - 1.0) / 2.0
n = paddle.arange(0, M, dtype=dtype) - (M - 1.0) / 2.0
sig2 = 2 * std * std
w = paddle.exp(-n**2 / sig2)
return _truncate(w, needs_trunc)
def exponential(M: int, center=None, tau=1., sym: bool = True) -> Tensor:
def exponential(M: int,
center=None,
tau=1.,
sym: bool = True,
dtype: str = 'float64') -> Tensor:
"""Compute an exponential (or Poisson) window.
Parameters:
M(int): window size.
tau(float): the window-specific parameter.
sym(bool)：whether to return symmetric window.
The default value is True
dtype(str): the datatype of returned tensor.
Returns:
Tensor: the window tensor
Notes:
......@@ -291,34 +324,35 @@ def exponential(M: int, center=None, tau=1., sym: bool = True) -> Tensor:
if sym and center is not None:
raise ValueError("If sym==True, center must be None.")
if _len_guards(M):
return paddle.ones((M, ), dtype='float32')
return paddle.ones((M, ), dtype=dtype)
M, needs_trunc = _extend(M, sym)
if center is None:
center = (M - 1) / 2
n = paddle.arange(0, M)
n = paddle.arange(0, M, dtype=dtype)
w = paddle.exp(-paddle.abs(n - center) / tau)
return _truncate(w, needs_trunc)
def triang(M: int, sym: bool = True) -> Tensor:
def triang(M: int, sym: bool = True, dtype: str = 'float64') -> Tensor:
"""Compute a triangular window.
Parameters:
M(int): window size.
sym(bool)：whether to return symmetric window.
The default value is True
dtype(str): the datatype of returned tensor.
Returns:
Tensor: the window tensor
Notes:
This function is consistent with scipy.signal.windows.triang().
"""
if _len_guards(M):
return paddle.ones((M, ), dtype='float32')
return paddle.ones((M, ), dtype=dtype)
M, needs_trunc = _extend(M, sym)
n = paddle.arange(1, (M + 1) // 2 + 1)
n = paddle.arange(1, (M + 1) // 2 + 1, dtype=dtype)
if M % 2 == 0:
w = (2 * n - 1.0) / M
w = paddle.concat([w, w[::-1]])
......@@ -329,31 +363,32 @@ def triang(M: int, sym: bool = True) -> Tensor:
return _truncate(w, needs_trunc)
def bohman(M: int, sym: bool = True) -> Tensor:
def bohman(M: int, sym: bool = True, dtype: str = 'float64') -> Tensor:
"""Compute a Bohman window.
The Bohman window is the autocorrelation of a cosine window.
Parameters:
M(int): window size.
sym(bool)：whether to return symmetric window.
The default value is True
dtype(str): the datatype of returned tensor.
Returns:
Tensor: the window tensor
Notes:
This function is consistent with scipy.signal.windows.bohman().
"""
if _len_guards(M):
return paddle.ones((M, ), dtype='float32')
return paddle.ones((M, ), dtype=dtype)
M, needs_trunc = _extend(M, sym)
fac = paddle.abs(paddle.linspace(-1, 1, M)[1:-1])
fac = paddle.abs(paddle.linspace(-1, 1, M, dtype=dtype)[1:-1])
w = (1 - fac) * paddle.cos(math.pi * fac) + 1.0 / math.pi * paddle.sin(
math.pi * fac)
w = _cat([0, w, 0], 'float32')
w = _cat([0, w, 0], dtype)
return _truncate(w, needs_trunc)
def blackman(M: int, sym: bool = True) -> Tensor:
def blackman(M: int, sym: bool = True, dtype: str = 'float64') -> Tensor:
"""Compute a Blackman window.
The Blackman window is a taper formed by using the first three terms of
a summation of cosines. It was designed to have close to the minimal
......@@ -364,28 +399,30 @@ def blackman(M: int, sym: bool = True) -> Tensor:
M(int): window size.
sym(bool)：whether to return symmetric window.
The default value is True
dtype(str): the datatype of returned tensor.
Returns:
Tensor: the window tensor
Notes:
This function is consistent with scipy.signal.windows.blackman().
"""
return general_cosine(M, [0.42, 0.50, 0.08], sym)
return general_cosine(M, [0.42, 0.50, 0.08], sym, dtype=dtype)
def cosine(M: int, sym: bool = True) -> Tensor:
def cosine(M: int, sym: bool = True, dtype: str = 'float64') -> Tensor:
"""Compute a window with a simple cosine shape.
Parameters:
M(int): window size.
sym(bool)：whether to return symmetric window.
The default value is True
dtype(str): the datatype of returned tensor.
Returns:
Tensor: the window tensor
Notes:
This function is consistent with scipy.signal.windows.cosine().
"""
if _len_guards(M):
return paddle.ones((M, ), dtype='float32')
return paddle.ones((M, ), dtype=dtype)
M, needs_trunc = _extend(M, sym)
w = paddle.sin(math.pi / M * (paddle.arange(0, M) + .5))
w = paddle.sin(math.pi / M * (paddle.arange(0, M, dtype=dtype) + .5))
return _truncate(w, needs_trunc)
PaddleAudio/paddleaudio/functional.py
浏览文件 @ 9cab6c61
......@@ -46,6 +46,8 @@ __all_ = [
'random_masking',
'random_cropping',
'center_padding',
'dct_matrx',
'mfcc',
]
......@@ -210,7 +212,7 @@ def mel_to_hz(mel: Union[float, Tensor],
logstep = math.log(6.4) / 27.0 # step size for log region
if isinstance(mel, Tensor):
target = min_log_hz * paddle.exp(logstep * (mel - min_log_mel))
mask = (mel > min_log_mel).astype('float32')
mask = (mel > min_log_mel).astype(mel.dtype)
freqs = target * mask + freqs * (
1 - mask) # will replace by masked_fill OP in future
else:
......@@ -223,14 +225,17 @@ def mel_to_hz(mel: Union[float, Tensor],
def mel_frequencies(n_mels: int = 128,
f_min: float = 0.0,
f_max: float = 11025.0,
htk: bool = False) -> Tensor:
htk: bool = False,
dtype: str = 'float64') -> Tensor:
"""Compute mel frequencies.
Parameters:
n_mels(int): number of Mel bins.
f_min(float): the lower cut-off frequency, below which the filter response is zero.
f_max(float): the upper cut-off frequency, above which the filter response is zero.
htk: whether to use htk formula.
htk(bool): whether to use htk formula.
dtype(str): the datatype of the return frequencies.
Returns:
The frequencies represented in Mel-scale
......@@ -252,17 +257,18 @@ def mel_frequencies(n_mels: int = 128,
# 'Center freqs' of mel bands - uniformly spaced between limits
min_mel = hz_to_mel(f_min, htk=htk)
max_mel = hz_to_mel(f_max, htk=htk)
mels = paddle.linspace(min_mel, max_mel, n_mels)
mels = paddle.linspace(min_mel, max_mel, n_mels, dtype=dtype)
freqs = mel_to_hz(mels, htk=htk)
return freqs
def fft_frequencies(sr: int, n_fft: int) -> Tensor:
def fft_frequencies(sr: int, n_fft: int, dtype: str = 'float64') -> Tensor:
"""Compute fourier frequencies.
Parameters:
sr(int): the audio sample rate.
n_fft(float): he number of fft bins.
n_fft(float): the number of fft bins.
dtype(str): the datatype of the return frequencies.
Returns:
The frequencies represented in hz.
Notes:
......@@ -278,7 +284,7 @@ def fft_frequencies(sr: int, n_fft: int) -> Tensor:
[0., 31.25000000, 62.50000000, ...]
"""
return paddle.linspace(0, float(sr) / 2, int(1 + n_fft // 2))
return paddle.linspace(0, float(sr) / 2, int(1 + n_fft // 2), dtype=dtype)
def compute_fbank_matrix(sr: int,
......@@ -286,7 +292,9 @@ def compute_fbank_matrix(sr: int,
n_mels: int = 128,
f_min: float = 0.0,
f_max: Optional[float] = None,
htk: bool = False) -> Tensor:
htk: bool = False,
norm: Union[str, float] = 'slaney',
dtype: str = 'float64') -> Tensor:
"""Compute fbank matrix.
Parameters:
......@@ -299,6 +307,8 @@ def compute_fbank_matrix(sr: int,
return_complex(bool): whether to return complex matrix. If True, the matrix will
be complex type. Otherwise, the real and image part will be stored in the last
axis of returned tensor.
dtype(str): the datatype of the returned fbank matrix.
Returns:
The fbank matrix of shape (n_mels, int(1+n_fft//2)).
Shape:
......@@ -322,13 +332,17 @@ def compute_fbank_matrix(sr: int,
f_max = float(sr) / 2
# Initialize the weights
weights = paddle.zeros((n_mels, int(1 + n_fft // 2)), dtype='float32')
weights = paddle.zeros((n_mels, int(1 + n_fft // 2)), dtype=dtype)
# Center freqs of each FFT bin
fftfreqs = fft_frequencies(sr=sr, n_fft=n_fft)
fftfreqs = fft_frequencies(sr=sr, n_fft=n_fft, dtype=dtype)
# 'Center freqs' of mel bands - uniformly spaced between limits
mel_f = mel_frequencies(n_mels + 2, f_min=f_min, f_max=f_max, htk=htk)
mel_f = mel_frequencies(n_mels + 2,
f_min=f_min,
f_max=f_max,
htk=htk,
dtype=dtype)
fdiff = mel_f[1:] - mel_f[:-1] #np.diff(mel_f)
ramps = mel_f.unsqueeze(1) - fftfreqs.unsqueeze(0)
......@@ -344,13 +358,18 @@ def compute_fbank_matrix(sr: int,
paddle.minimum(lower, upper))
# Slaney-style mel is scaled to be approx constant energy per channel
if norm == 'slaney':
enorm = 2.0 / (mel_f[2:n_mels + 2] - mel_f[:n_mels])
weights *= enorm.unsqueeze(1)
elif isinstance(norm, int) or isinstance(norm, float):
weights = paddle.nn.functional.normalize(weights, p=norm, axis=-1)
return weights
def dft_matrix(n: int, return_complex: bool = False) -> Tensor:
def dft_matrix(n: int,
return_complex: bool = False,
dtype: str = 'float64') -> Tensor:
"""Compute discrete Fourier transform matrix.
Parameters:
......@@ -358,6 +377,8 @@ def dft_matrix(n: int, return_complex: bool = False) -> Tensor:
return_complex(bool): whether to return complex matrix. If True, the matrix will
be complex type. Otherwise, the real and image part will be stored in the last
axis of returned tensor.
dtype(str): the datatype of the returned dft matrix.
Shape:
output: [n, n] or [n,n,2]
......@@ -378,10 +399,16 @@ def dft_matrix(n: int, return_complex: bool = False) -> Tensor:
>> [512, 512]
"""
# This is due to a bug in paddle in lacking support for complex128, as of paddle 2.1.0
if return_complex and dtype == 'float64':
raise ValueError('not implemented')
x, y = paddle.meshgrid(paddle.arange(0, n), paddle.arange(0, n))
z = x * y * (-2 * math.pi / n)
z = x.astype(dtype) * y.astype(dtype) * paddle.to_tensor(
(-2 * math.pi / n), dtype)
cos = paddle.cos(z)
sin = paddle.sin(z)
if return_complex:
return cos + paddle.to_tensor([1j]) * sin
cos = cos.unsqueeze(-1)
......@@ -389,7 +416,9 @@ def dft_matrix(n: int, return_complex: bool = False) -> Tensor:
return paddle.concat([cos, sin], -1)
def idft_matrix(n: int, return_complex: bool = False) -> Tensor:
def idft_matrix(n: int,
return_complex: bool = False,
dtype: str = 'float64') -> Tensor:
"""Compute inverse discrete Fourier transform matrix
Parameters:
......@@ -397,6 +426,7 @@ def idft_matrix(n: int, return_complex: bool = False) -> Tensor:
return_complex(bool): whether to return complex matrix. If True, the matrix will
be complex type. Otherwise, the real and image part will be stored in the last
axis of returned tensor.
dtype(str): the data type of returned idft matrix.
Returns:
Complex tensor of shape (n,n) if return_complex=True, and of shape (n,n,2) otherwise.
Examples:
......@@ -414,8 +444,13 @@ def idft_matrix(n: int, return_complex: bool = False) -> Tensor:
"""
x, y = paddle.meshgrid(paddle.arange(0, n), paddle.arange(0, n))
z = x * y * (2 * math.pi / n)
if return_complex and dtype == 'float64': # there is a bug in paddle for complex128 datatype
raise ValueError('not implemented')
x, y = paddle.meshgrid(paddle.arange(0, n, dtype=dtype),
paddle.arange(0, n, dtype=dtype))
z = x.astype(dtype) * y.astype(dtype) * paddle.to_tensor(
(2 * math.pi / n), dtype)
cos = paddle.cos(z)
sin = paddle.sin(z)
if return_complex:
......@@ -425,9 +460,54 @@ def idft_matrix(n: int, return_complex: bool = False) -> Tensor:
return paddle.concat([cos, sin], -1)
def dct_matrix(n_mfcc: int,
n_mels: int,
dct_norm: Optional[str] = 'ortho',
dtype: str = 'float64') -> Tensor:
"""Compute discrete cosine transform (DCT) matrix used in MFCC computation.
Parameters:
n_mfcc(int): the number of coefficients in MFCC.
n_mels(int): the number of mel bins in the melspectrogram tranform preceding MFCC.
dct_norm(None|str): the normalization of the dct transform. If 'ortho', use the orthogonal normalization.
If None, not normalization is applied. Default: 'ortho'.
dtype(str): the data type of returned dct matrix.
Shape:
output: [n_mels,n_mfcc]
Returns:
The dct matrix of shape [n_mels,n_mfcc]
Examples:
.. code-block:: python
import paddle
import paddleaudio.functional as F
m = F.dct_matrix(n_mfcc=20,n_mels=64)
print(m.shape)
>> [64, 20]
"""
# http://en.wikipedia.org/wiki/Discrete_cosine_transform#DCT-II
n = paddle.arange(float(n_mels), dtype=dtype)
k = paddle.arange(float(n_mfcc), dtype=dtype).unsqueeze(1)
dct = paddle.cos(math.pi / float(n_mels) * (n + 0.5) *
k) # size (n_mfcc, n_mels)
if dct_norm is None:
dct *= 2.0
else:
assert dct_norm == "ortho"
dct[0] *= 1.0 / math.sqrt(2.0)
dct *= math.sqrt(2.0 / float(n_mels))
return dct.t()
def get_window(window: Union[str, Tuple[str, float]],
win_length: int,
fftbins: bool = True) -> Tensor:
fftbins: bool = True,
dtype: str = 'float64') -> Tensor:
"""Return a window of a given length and type.
Parameters:
window(str|(str,float)): the type of window to create.
......@@ -473,7 +553,7 @@ def get_window(window: Union[str, Tuple[str, float]],
params = (win_length, ) + args
kwargs = {'sym': sym}
return winfunc(*params, **kwargs)
return winfunc(*params, dtype=dtype, **kwargs)
def power_to_db(magnitude: Tensor,
......@@ -857,7 +937,8 @@ def stft(x: Tensor,
window: str = 'hann',
center: bool = True,
pad_mode: str = 'reflect',
one_sided: bool = True):
one_sided: bool = True,
dtype: str = 'float64'):
"""Compute short-time Fourier transformation(STFT) of a given signal,
typically an audio waveform.
The STFT is implemented with strided 1d convolution. The convluational weights are
......@@ -882,6 +963,8 @@ def stft(x: Tensor,
one_sided(bool): If True, the output spectrum will have n_fft//2+1 frequency components.
Otherwise, it will return the full spectrum that have n_fft+1 frequency values.
The default value is True.
dtype(str): the datatype used internally for computing fft transform coefficients. 'float64' is
recommended for higher numerical accuracy.
Shape:
- x: 1-D tensor with shape: (signal_length,) or 2-D tensor with shape (N, signal_length).
- output: 2-D tensor with shape (N, freq_dim, frame_number,2),
......@@ -917,9 +1000,9 @@ def stft(x: Tensor,
# Set the default hop, if it's not already specified.
if hop_length is None:
hop_length = int(win_length // 4)
fft_window = get_window(window, win_length, fftbins=True)
fft_window = get_window(window, win_length, fftbins=True, dtype=dtype)
fft_window = center_padding(fft_window, n_fft)
dft_mat = dft_matrix(n_fft)
dft_mat = dft_matrix(n_fft, dtype=dtype)
if one_sided:
out_channels = n_fft // 2 + 1
else:
......@@ -933,7 +1016,9 @@ def stft(x: Tensor,
pad=[n_fft // 2, n_fft // 2],
mode=pad_mode,
data_format="NCL")
signal = paddle.nn.functional.conv1d(x, weight, stride=hop_length)
signal = paddle.nn.functional.conv1d(x,
weight.astype('float32'),
stride=hop_length)
signal = signal.transpose([0, 2, 1])
signal = signal.reshape(
......@@ -949,7 +1034,8 @@ def istft(x: Tensor,
window: str = 'hann',
center: bool = True,
pad_mode: str = 'reflect',
signal_length: Optional[int] = None) -> Tensor:
signal_length: Optional[int] = None,
dtype: str = 'float64') -> Tensor:
"""Compute inverse short-time Fourier transform(ISTFT) of a given spectrum signal x.
To accurately recover the input signal, the exact value of parameters should match
those used in stft.
......@@ -960,6 +1046,8 @@ def istft(x: Tensor,
with original signal. If set to None, the length is solely determined by hop_length
and win_length.
The default value is None.
dtype(str): the datatype used internally for computing fft transform coefficients. 'float64' is
recommended for higher numerical accuracy.
Shape:
- x: 1-D tensor with shape: (signal_length,) or 2-D tensor with shape (N, signal_length).
- output: the signal represented as a 2-D tensor with shape (N, single_length)
......@@ -1016,11 +1104,11 @@ def istft(x: Tensor,
f'hop_length must be smaller than win_length, ' +
f'but {hop_length}>={win_length}')
fft_window = get_window(window, win_length)
fft_window = get_window(window, win_length, dtype=dtype)
fft_window = 1.0 / fft_window
fft_window = center_padding(fft_window, n_fft)
fft_window = fft_window.unsqueeze((1, 2))
idft_mat = fft_window * idft_matrix(n_fft) / n_fft
idft_mat = fft_window * idft_matrix(n_fft, dtype=dtype) / n_fft
idft_mat = idft_mat.unsqueeze((0, 1))
#let's do the inverse transformation
......@@ -1046,7 +1134,8 @@ def spectrogram(x,
window: str = 'hann',
center: bool = True,
pad_mode: str = 'reflect',
power: float = 2.0) -> Tensor:
power: float = 2.0,
dtype: str = 'float64') -> Tensor:
"""Compute spectrogram of a given signal, typically an audio waveform.
The spectorgram is defined as the complex norm of the short-time
Fourier transformation.
......@@ -1070,6 +1159,8 @@ def spectrogram(x,
The default value is 'reflect'.
power(float): The power of the complex norm.
The default value is 2.0
dtype(str): the datatype used internally for computing fft transform coefficients. 'float64' is
recommended for higher numerical accuracy.
Shape:
- x: 1-D tensor with shape: (signal_length,) or 2-D tensor with shape (N, signal_length).
- output: 2-D tensor with shape (N, n_fft//2+1, frame_number),
......@@ -1093,7 +1184,8 @@ def spectrogram(x,
window=window,
center=center,
pad_mode=pad_mode,
one_sided=True)
one_sided=True,
dtype=dtype)
spectrogram = paddle.square(fft_signal).sum(-1)
if power == 2.0:
pass
......@@ -1114,6 +1206,9 @@ def melspectrogram(x: Tensor,
n_mels: int = 128,
f_min: float = 0.0,
f_max: Optional[float] = None,
htk: bool = True,
norm: Union[str, float] = 'slaney',
dtype: str = 'float64',
to_db: bool = False,
**kwargs) -> Tensor:
"""Compute the melspectrogram of a given signal, typically an audio waveform.
......@@ -1145,12 +1240,15 @@ def melspectrogram(x: Tensor,
f_min(float): the lower cut-off frequency, below which the filter response is zero. Tips:
set f_min to slightly higher than 0.
The default value is 0.
f_max(float): the upper cut-off frequency, above which the filter response is zero.
If None, it is set to half of the sample rate, i.e., sr//2. Tips: set it a slightly
smaller than half of sample rate.
The default value is None.
htk(bool): whether to use HTK formula in computing fbank matrix.
norm(str|float): the normalization type in computing fbank matrix. Slaney-style is used by default.
You can specify norm=1.0/2.0 to use customized p-norm normalization.
dtype(str): the datatype of fbank matrix used in the transform. Use float64(default) to increase numerical
accuracy. Note that the final transform will be conducted in float32 regardless of dtype of fbank matrix.
to_db(bool): whether to convert the magnitude to db scale.
The default value is False.
kwargs: the key-word arguments that are passed to F.power_to_db if to_db is True
......@@ -1176,18 +1274,96 @@ def melspectrogram(x: Tensor,
"""
x = spectrogram(x, n_fft, hop_length, win_length, window, center, pad_mode,
power)
x = spectrogram(x,
n_fft=n_fft,
hop_length=hop_length,
win_length=win_length,
window=window,
center=center,
pad_mode=pad_mode,
power=power,
dtype=dtype)
if f_max is None:
f_max = sr // 2
fbank_matrix = compute_fbank_matrix(sr=sr,
n_fft=n_fft,
n_mels=n_mels,
f_min=f_min,
f_max=f_max)
f_max=f_max,
htk=htk,
norm=norm,
dtype=dtype)
fbank_matrix = fbank_matrix.unsqueeze(0)
mel_feature = paddle.matmul(fbank_matrix, x)
mel_feature = paddle.matmul(fbank_matrix, x.astype(fbank_matrix.dtype))
if to_db:
mel_feature = power_to_db(mel_feature, **kwargs)
return mel_feature
def mfcc(x,
sr: int = 22050,
spect: Optional[Tensor] = None,
n_mfcc: int = 20,
dct_norm: str = 'ortho',
lifter: int = 0,
dtype: str = 'float64',
**kwargs) -> Tensor:
"""Compute Mel-frequency cepstral coefficients (MFCCs) give an input waveform.
Parameters:
sr(int): the audio sample rate.
The default value is 22050.
spect(None|Tensor): the melspectrogram tranform result(in db scale). If None, the melspectrogram will be
computed using `MelSpectrogram` functional and further converted to db scale using `F.power_to_db`
The default value is None.
n_mfcc(int): the number of coefficients.
The default value is 20.
dct_norm: the normalization type of dct matrix. See `dct_matrix` for more details.
The default value is 'ortho'.
lifter(int): if lifter > 0, apply liftering(cepstral filtering) to the MFCCs.
If lifter = 0, no liftering is applied.
Setting lifter >= 2 * n_mfcc emphasizes the higher-order coefficients.
As lifter increases, the coefficient weighting becomes approximately linear.
The default value is 0.
dtype(str): the datatype used internally in computing MFCC.
Examples:
.. code-block:: python
import paddle
import paddleaudio.functional as F
x = paddle.randn((8, 16000)) # the waveform
y = F.mfcc(x,
sr=16000,
n_mfcc=20,
n_mels=64,
n_fft=512,
win_length=512,
hop_length=160)
print(y.shape)
>> [8, 20, 101]
"""
if spect is None:
spect = melspectrogram(x, sr=sr, dtype=dtype,
**kwargs) #[batch,n_mels,frames]
spect = power_to_db(spect) # default top_db is 80
n_mels = spect.shape[1]
if n_mfcc > n_mels:
raise ValueError('Value of n_mfcc cannot be larger than n_mels')
M = dct_matrix(n_mfcc, n_mels, dct_norm=dct_norm, dtype=dtype)
out = M.transpose([1, 0]).unsqueeze_(0) @ spect
if lifter > 0:
factor = paddle.sin(math.pi *
paddle.arange(1, 1 + n_mfcc, dtype=dtype) / lifter)
return out @ factor.unsqueeze([0, 2])
elif lifter == 0:
return out
else:
raise ValueError(f"MFCC lifter={lifter} must be a non-negative number")
PaddleAudio/paddleaudio/models/wav2vec2/modeling.py
浏览文件 @ 9cab6c61
......@@ -278,13 +278,14 @@ class Wav2Vec2GroupNormConvLayer(nn.Layer):
bias_attr=config.conv_bias,
)
self.activation = ACT2FN[config.feat_extract_activation]
# , affine=True ??
self.layer_norm = nn.GroupNorm(num_groups=self.out_conv_dim,
num_channels=self.out_conv_dim)
def forward(self, hidden_states):
hidden_states = self.conv(hidden_states)
hidden_states = self.layer_norm(hidden_states)
# paddle's groupnorm only supports 4D tensor as of 2.1.1. We need to unsqueeze and squeeze.
hidden_states = self.layer_norm(hidden_states.unsqueeze([-1]))
hidden_states = hidden_states[:, :, :, 0]
hidden_states = self.activation(hidden_states)
return hidden_states
......
PaddleAudio/paddleaudio/transforms.py
浏览文件 @ 9cab6c61
......@@ -12,10 +12,15 @@
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import Any, List, Optional
import glob
import math
import os
import random
from typing import Any, List, Optional, Union
import paddle
import paddle.nn as nn
import paddleaudio
import paddleaudio.functional as F
from paddle import Tensor
......@@ -26,12 +31,17 @@ __all__ = [
'MelSpectrogram',
'LogMelSpectrogram',
'Compose',
'RandomChoice',
'RandomApply',
'RandomMasking',
'CenterPadding',
'RandomCropping',
'RandomMuLawCodec',
'MuLawEncoding',
'MuLawDecoding',
'Noisify',
'Reverberate',
'MFCC',
]
......@@ -62,6 +72,8 @@ class STFT(nn.Layer):
one_sided(bool): If True, the output spectrum will have n_fft//2+1 frequency components.
Otherwise, it will return the full spectrum that have n_fft+1 frequency values.
The default value is True.
dtype(str): the datatype of used internally in computing STFT transform.
Shape:
- x: 1-D tensor with shape: (signal_length,) or 2-D tensor with shape (batch, signal_length).
- output: 2-D tensor with shape [batch_size, freq_dim, frame_number,2],
......@@ -90,7 +102,8 @@ class STFT(nn.Layer):
window: str = 'hann',
center: bool = True,
pad_mode: str = 'reflect',
one_sided: bool = True):
one_sided: bool = True,
dtype: str = 'float64'):
super(STFT, self).__init__()
......@@ -111,10 +124,13 @@ class STFT(nn.Layer):
# Set the default hop, if it's not already specified.
if self.hop_length is None:
self.hop_length = int(self.win_length // 4)
fft_window = F.get_window(window, self.win_length, fftbins=True)
fft_window = F.get_window(window,
self.win_length,
fftbins=True,
dtype=dtype)
fft_window = F.center_padding(fft_window, n_fft)
# DFT & IDFT matrix.
dft_mat = F.dft_matrix(n_fft)
dft_mat = F.dft_matrix(n_fft, dtype=dtype)
if one_sided:
out_channels = n_fft // 2 + 1
else:
......@@ -127,7 +143,7 @@ class STFT(nn.Layer):
weight = fft_window.unsqueeze([1, 2]) * dft_mat[:, 0:out_channels, :]
weight = weight.transpose([1, 2, 0])
weight = weight.reshape([-1, weight.shape[-1]])
self.conv.load_dict({'weight': weight.unsqueeze(1)})
self.conv.load_dict({'weight': weight.unsqueeze(1).astype('float32')})
# by default, the STFT is not learnable
for param in self.parameters():
param.stop_gradient = True
......@@ -170,7 +186,8 @@ class Spectrogram(nn.Layer):
window: str = 'hann',
center: bool = True,
pad_mode: str = 'reflect',
power: float = 2.0):
power: float = 2.0,
dtype: str = 'float64'):
"""Compute spectrogram of a given signal, typically an audio waveform.
The spectorgram is defined as the complex norm of the short-time
Fourier transformation.
......@@ -194,6 +211,8 @@ class Spectrogram(nn.Layer):
The default value is 'reflect'.
power(float): The power of the complex norm.
The default value is 2.0
dtype(str): the datatype of used internally in computing ISTFT transform.'float64' is
recommended for higher numerical accuracy.
Notes:
The Spectrogram transform relies on STFT transform to compute the spectrogram.
......@@ -217,8 +236,13 @@ class Spectrogram(nn.Layer):
super(Spectrogram, self).__init__()
self.power = power
self._stft = STFT(n_fft, hop_length, win_length, window, center,
pad_mode)
self._stft = STFT(n_fft=n_fft,
hop_length=hop_length,
win_length=win_length,
window=window,
center=center,
pad_mode=pad_mode,
dtype=dtype)
def __repr__(self, ):
p_repr = str(self._stft).split('(')[-1].split(')')[0]
......@@ -230,6 +254,8 @@ class Spectrogram(nn.Layer):
spectrogram = paddle.square(fft_signal).sum(-1)
if self.power == 2.0:
pass
elif self.power == 1.0:
spectrogram = paddle.sqrt(spectrogram)
else:
spectrogram = spectrogram**(self.power / 2.0)
return spectrogram
......@@ -247,7 +273,10 @@ class MelSpectrogram(nn.Layer):
power: float = 2.0,
n_mels: int = 128,
f_min: float = 0.0,
f_max: Optional[float] = None):
f_max: Optional[float] = None,
htk: bool = False,
norm: Union[str, float] = 'slaney',
dtype: str = 'float64'):
"""Compute the melspectrogram of a given signal, typically an audio waveform.
The melspectrogram is also known as filterbank or fbank feature in audio community.
It is computed by multiplying spectrogram with Mel filter bank matrix.
......@@ -271,13 +300,16 @@ class MelSpectrogram(nn.Layer):
pad_mode(str): the mode to pad the signal if necessary. The supported modes are 'reflect'
and 'constant'.
The default value is 'reflect'.
power(float): The power of the complex norm.
power(float): the power of the complex norm.
The default value is 2.0
n_mels(int): the mel bins.
f_min(float): the lower cut-off frequency, below which the filter response is zero.
f_max(float): the upper cut-off frequency, above which the filter response is zeros.
htk(bool): whether to use HTK formula in computing fbank matrix.
norm(str|float): the normalization type in computing fbank matrix. Slaney-style is used by default.
You can specify norm=1.0/2.0 to use customized p-norm normalization.
dtype(str): the datatype of fbank matrix used in the transform. Use float64(default) to increase numerical
accuracy. Note that the final transform will be conducted in float32 regardless of dtype of fbank matrix.
Notes:
The melspectrogram transform relies on Spectrogram transform and F.compute_fbank_matrix.
By default, the Fourier coefficients are not learnable. To fine-tune the Fourier coefficients,
......@@ -298,20 +330,31 @@ class MelSpectrogram(nn.Layer):
"""
super(MelSpectrogram, self).__init__()
self._spectrogram = Spectrogram(n_fft, hop_length, win_length, window,
center, pad_mode, power)
self._spectrogram = Spectrogram(n_fft=n_fft,
hop_length=hop_length,
win_length=win_length,
window=window,
center=center,
pad_mode=pad_mode,
power=power,
dtype=dtype)
self.n_mels = n_mels
self.f_min = f_min
self.f_max = f_max
self.htk = htk
self.norm = norm
if f_max is None:
f_max = sr // 2
self.fbank_matrix = F.compute_fbank_matrix(sr=sr,
self.fbank_matrix = F.compute_fbank_matrix(
sr=sr,
n_fft=n_fft,
n_mels=n_mels,
f_min=f_min,
f_max=f_max)
self.fbank_matrix = self.fbank_matrix.unsqueeze(0)
f_max=f_max,
htk=htk,
norm=norm,
dtype=dtype) # float64 for better numerical results
self.fbank_matrix = self.fbank_matrix.unsqueeze(0).astype('float32')
self.register_buffer('fbank_matrix', self.fbank_matrix)
def forward(self, x: Tensor) -> Tensor:
......@@ -322,7 +365,9 @@ class MelSpectrogram(nn.Layer):
def __repr__(self):
p_repr = str(self._spectrogram).split('(')[-1].split(')')[0]
l_repr = f'n_mels={self.n_mels}, f_min={self.f_min}, f_max={self.f_max}'
l_repr = (
f'n_mels={self.n_mels}, f_min={self.f_min}, f_max={self.f_max}' +
f', htk={self.htk}, norm={self.norm}')
return (self.__class__.__name__ + '(' + l_repr + ', ' + p_repr + ')')
......@@ -339,9 +384,12 @@ class LogMelSpectrogram(nn.Layer):
n_mels: int = 64,
f_min: float = 0.0,
f_max: Optional[float] = None,
htk: bool = False,
norm: Union[str, float] = 'slaney',
ref_value: float = 1.0,
amin: float = 1e-10,
top_db: Optional[float] = 80.0):
top_db: Optional[float] = 80.0,
dtype: str = 'float64'):
"""Compute log-mel-spectrogram(also known as LogFBank) feature of a given signal,
typically an audio waveform.
......@@ -370,13 +418,17 @@ class LogMelSpectrogram(nn.Layer):
f_min(float): the lower cut-off frequency, below which the filter response is zero.
f_max(float): the upper cut-off frequency, above which the filter response is zeros.
ref_value(float): the reference value. If smaller than 1.0, the db level
of the signal will be pulled up accordingly. Otherwise, the db level is pushed down.
amin(float): the minimum value of input magnitude, below which the input
htk(bool): whether to use HTK formula in computing fbank matrix.
norm(str|float): the normalization type in computing fbank matrix. Slaney-style is used by default.
You can specify norm=1.0/2.0 to use customized p-norm normalization.
dtype(str): the datatype of fbank matrix used in the transform. Use float64 to increase numerical
accuracy. Note that the final transform will be conducted in float32 regardless of dtype of fbank matrix.
amin(float): the minimum value of input magnitude, below which the input of the signal will be pulled up accordingly.
Otherwise, the db level is pushed down.
magnitude is clipped(to amin). For numerical stability, set amin to a larger value,
e.g., 1e-3.
top_db(float): the maximum db value of resulting spectrum, above which the
spectrum is clipped(to top_db).
Notes:
The LogMelSpectrogram transform relies on MelSpectrogram transform to compute
spectrogram in mel-scale, and then use paddleaudio.functional.power_to_db to
......@@ -409,7 +461,10 @@ class LogMelSpectrogram(nn.Layer):
power=power,
n_mels=n_mels,
f_min=f_min,
f_max=f_max)
f_max=f_max,
htk=htk,
norm=norm,
dtype=dtype)
self.ref_value = ref_value
self.amin = amin
......@@ -451,7 +506,8 @@ class ISTFT(nn.Layer):
pad_mode(str): the mode to pad the signal if necessary. The supported modes are 'reflect'
and 'constant'.
The default value is 'reflect'.
dtype(str): the datatype of used internally in computing ISTFT transform.'float64' is
recommended for higher numerical accuracy.
signal_length(int): the origin signal length for exactly aligning recovered signal
with original signal. If set to None, the length is solely determined by hop_length
and win_length.
......@@ -479,7 +535,8 @@ class ISTFT(nn.Layer):
win_length: Optional[int] = None,
window: str = 'hann',
center: bool = True,
pad_mode: str = 'reflect'):
pad_mode: str = 'reflect',
dtype: str = 'float64'):
super(ISTFT, self).__init__()
assert pad_mode in [
......@@ -840,3 +897,297 @@ class RandomMuLawCodec(nn.Layer):
def __repr__(self, ):
return (self.__class__.__name__ +
f'(min_mu={self.min_mu}, max_mu={self.max_mu})')
class Reverberate(nn.Layer):
"""Apply reverberation to input audio tensor.
Parameters:
rir_source: a callable object that reads impulse response from rir dataset.
Shapes:
- x: 2-D tensor with shape [batch_size, frames]
- output: 2-D tensor with shape [batch_size, frames]
Examples:
.. code-block:: python
import paddle
import paddleaudio.transforms as T
x = paddle.randn((2, 48000))
# Define RIR source object that read rir weight from folder.
# See the speaker example for how to define RIR source object.
reader = RIRSource(<rir_folder>)
transform = T.Reverberate(reader)
y = transform(x)
print(y.shape)
>> [2, 48000]
"""
def __init__(self, rir_source: Any):
super(Reverberate, self).__init__()
self.rir_source = rir_source
def forward(self, x: Tensor) -> Tensor:
assert x.ndim == 2, (f'the input tensor must be 2d tensor, ' +
f'but received x.ndim={x.ndim}')
weight = self.rir_source() #get next weight
pad_len = [
weight.shape[-1] // 2 - 1, weight.shape[-1] - weight.shape[-1] // 2
]
out = paddle.nn.functional.conv1d(x.unsqueeze(1),
weight,
padding=pad_len)
return out[:, 0, :]
def __repr__(self):
return (self.__class__.__name__ + f'(rir_source={self.rir_source})')
class RandomApply():
"""Compose a list of transforms and apply them to the input tensor Randomly.
Parameters:
transforms: a list of transforms.
p(float): the probability that each transform will be chosen independently.
Default: 0.5
Examples:
.. code-block:: python
import paddle
import paddleaudio.transforms as T
x = paddle.randn((2, 48000))
transform1 = T.Reverberate(<rir_reader>)
transform2 = T.Noisify(<noise_reader>)
# Apply Reverberation and/or Noisify independently.
transform = T.RandomApply([
transform1,
transform2,
],p=0.3)
y = transform(x)
print(y.shape)
>> [2, 48000]
"""
def __init__(self, transforms: List[Any], p: float = 0.5):
self.transforms = transforms
self.p = p
def __call__(self, x: Tensor) -> Tensor:
for t in self.transforms:
if random.choices([True, False], weights=[self.p, 1 - self.p])[0]:
x = t(x)
return x
def __repr__(self):
format_string = self.__class__.__name__ + '('
for t in self.transforms:
format_string += '\n'
format_string += ' {0}'.format(t)
format_string += f'\n), p={self.p}'
return format_string
class RandomChoice():
"""Compose a list of transforms and choice one randomly according to some weights(if proviced)
Parameters:
transforms: a list of transforms.
Examples:
.. code-block:: python
import paddle
import paddleaudio.transforms as T
x = paddle.randn((2, 48000))
transform1 = T.RandomCropping(target_size=16000)
transform2 = T.RandomMuLawCodec()
transform = T.RandomChoice([
transform1,
transform2,
],weights=[0.3,0.7])
y = transform(x)
print(y.shape)
>> [2, 16000]
"""
def __init__(self,
transforms: List[Any],
weights: Optional[List[float]] = None):
self.transforms = transforms
self.weights = weights
def __call__(self, x: Tensor) -> Tensor:
t = random.choices(self.transforms, weights=self.weights)[0]
return t(x)
def __repr__(self):
format_string = self.__class__.__name__ + '('
for t in self.transforms:
format_string += '\n'
format_string += ' {0}'.format(t)
format_string += f'\n)'
return format_string
class Noisify(nn.Layer):
"""Transform the input audio tensor by adding noise.
Parameters:
noise_reader: a NoiseSource object that reads audio as noise source. It should
be a callable object that return a noise tensor after being called.
snr_high(float): the upper bound of signal-to-noise ratio in db
after applying the transform. Default: 10.0 db.
snr_low(None|float): the lower bound of signal-to-noise ratio in db
after applying the transform. If None, it is set to snr_high*0.5.
Default: None
random(bool): whether to sample snr randomly in range [snr_low,snr_high]. If False,
the snr_high is used as constant snr value for all transforms. Default: False.
Shapes:
- x: 2-D tensor with shape [batch_size, frames]
- output: 2-D tensor with shape [batch_size, frames]
Examples:
.. code-block:: python
import paddle
import paddleaudio.transforms as T
x = paddle.randn((2, 48000))
# A noise reader should be provided, see speaker example for how to define a noise reader
transform = Noisify(<noise_reader>, 20, 15, True)
y = transform(x)
print(y.shape)
>> [2,48000]
"""
def __init__(self,
noise_reader: Any,
snr_high: float = 10.0,
snr_low: Optional[float] = None,
random: bool = False):
super(Noisify, self).__init__()
self.noise_reader = noise_reader
self.random = random
self.snr_high = snr_high
self.snr_low = snr_low
if self.random:
if self.snr_low is None:
self.snr_low = snr_high - 3.0
assert self.snr_high >= self.snr_low, (
f'snr_high should be >= snr_low, ' +
f'but received snr_high={self.snr_high}, ' +
f'snr_low={self.snr_low}')
def forward(self, x: Tensor) -> Tensor:
assert x.ndim == 2, (f'the input tensor must be 2d tensor, ' +
f'but received x.ndim={x.ndim}')
noise = self.noise_reader()
if self.random:
snr = random.uniform(self.snr_low, self.snr_high)
else:
snr = self.snr_high
signal_mag = paddle.sum(paddle.square(x), -1)
noise_mag = paddle.sum(paddle.square(noise), -1)
alpha = 10**(snr / 10) * noise_mag / (signal_mag + 1e-10)
beta = 1.0
factor = alpha + beta
alpha = alpha / factor
beta = beta / factor
x = alpha.unsqueeze((1, )) * x + beta.unsqueeze((1, )) * noise
return x
def __repr__(self):
return (
self.__class__.__name__ +
f'(random={self.random}, snr_high={self.snr_high}, snr_low={self.snr_low})'
)
class MFCC(nn.Layer):
def __init__(self,
sr: int = 22050,
n_mfcc: int = 20,
dct_norm: str = "ortho",
lifter: int = 0,
dtype: str = 'float64',
**kwargs):
""""Compute Mel-frequency cepstral coefficients (MFCCs) give an input waveform.
Parameters:
sr(int): the audio sample rate.
The default value is 22050.
n_mfcc(int): the number of coefficients.
The default value is 20.
dct_norm: the normalization type of dct matrix. See `dct_matrix` for more details.
The default value is 'ortho'.
lifter(int): if lifter > 0, apply liftering(cepstral filtering) to the MFCCs.
If lifter = 0, no liftering is applied.
Setting lifter >= 2 * n_mfcc emphasizes the higher-order coefficients.
As lifter increases, the coefficient weighting becomes approximately linear.
The default value is 0.
dtype(str): the datatype of used internally in computing MFCC.
kwargs: additional keyword arguments that will be passed to MelSpectrogram. See ```MelSpectrogram```
for more details. If not provided, the default values are used.
Examples:
.. code-block:: python
import paddle
import paddleaudio.transforms as T
mfcc = paddleaudio.transforms.MFCC(sr=16000,
n_mfcc=20,
n_mels=64,
n_fft=512,
win_length=512,
hop_length=160)
x = paddle.randn((8, 16000)) # the waveform
y = mfcc(x)
print(y.shape)
>> [8, 20, 101]
"""
super(MFCC, self).__init__()
self.sr = sr
self.n_mfcc = n_mfcc
self.dct_norm = dct_norm
self.lifter = lifter
self.dtype = dtype
self._melspectrogram = MelSpectrogram(sr=sr, dtype=dtype, **kwargs)
def forward(self, x: Tensor) -> Tensor:
spect = self._melspectrogram(x) #[batch,n_mels,frames]
spect = F.power_to_db(spect)
n_mels = spect.shape[1]
#import pdb;pdb.set_trace()
M = F.dct_matrix(self.n_mfcc,
n_mels,
dct_norm=self.dct_norm,
dtype=self.dtype)
mfcc = M.transpose([1, 0]).unsqueeze_(0) @ spect
if self.lifter > 0:
factor = paddle.sin(
math.pi * paddle.arange(1, 1 + self.n_mfcc, dtype=self.dtype) /
self.lifter)
return mfcc @ factor.unsqueeze([0, 2])
elif self.lifter == 0:
return mfcc
else:
raise ValueError(
f"MFCC lifter={self.lifter} must be a non-negative number")
return mfcc
def __repr__(self):
p_repr = str(self._melspectrogram).split('(')[-1].split(')')[0]
return (self.__class__.__name__ + f'(sr={self.sr}, ' +
f'n_mfcc={self.n_mfcc}, dct_norm={self.dct_norm}, ' +
f'dtype={self.dtype}, ' + f'lifter={self.lifter}, ' + p_repr +
')')
PaddleAudio/test/unit_test/test_dct_matrix.py 0 → 100644
浏览文件 @ 9cab6c61
# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import numpy as np
import paddle
import paddleaudio
import scipy
import utils
def test_dct_compat_with_scipy1():
paddle.set_device('cpu')
expected = scipy.fft.dct(np.eye(64), norm='ortho')[:, :8]
paddle_dct = paddleaudio.functional.dct_matrix(8, 64, dct_norm='ortho')
err = np.mean(np.abs(paddle_dct.numpy() - expected))
assert err < 5e-8
def test_dct_compat_with_scipy2():
paddle.set_device('cpu')
expected = scipy.fft.dct(np.eye(64), norm=None)[:, :8]
paddle_dct = paddleaudio.functional.dct_matrix(8, 64, dct_norm=None)
err = np.mean(np.abs(paddle_dct.numpy() - expected))
assert err < 5e-7
def test_dct_compat_with_scipy3():
paddle.set_device('gpu')
expected = scipy.fft.dct(np.eye(64), norm='ortho')[:, :8]
paddle_dct = paddleaudio.functional.dct_matrix(8, 64, dct_norm='ortho')
err = np.mean(np.abs(paddle_dct.numpy() - expected))
assert err < 5e-7
def test_dct_compat_with_scipy4():
paddle.set_device('gpu')
expected = scipy.fft.dct(np.eye(64), norm=None)[:, :8]
paddle_dct = paddleaudio.functional.dct_matrix(8, 64, dct_norm=None)
err = np.mean(np.abs(paddle_dct.numpy() - expected))
assert err < 5e-7
PaddleAudio/test/unit_test/test_functional.py
浏览文件 @ 9cab6c61
......@@ -24,47 +24,43 @@ import utils
EPS = 1e-8
def test_hz_mel_convert():
hz = np.linspace(0, 32000, 100).astype('float32')
mel0 = paddleaudio.utils._librosa.hz_to_mel(hz)
mel1 = F.hz_to_mel(paddle.to_tensor(hz)).numpy()
hz0 = paddleaudio.utils._librosa.mel_to_hz(mel0)
hz1 = F.mel_to_hz(paddle.to_tensor(mel0)).numpy()
assert np.allclose(hz0, hz1)
assert np.allclose(mel0, mel1)
assert np.allclose(hz, hz0)
def generate_window_test_data():
names = [
('hamming', ),
('hann', ),
(
'taylor',
4,
30,
True,
),
#'kaiser',
('gaussian', 100),
('exponential', None, 1.0),
('triang', ),
('bohman', ),
('blackman', ),
('cosine', ),
]
win_length = [512, 400, 1024, 2048]
fftbins = [True, False]
return itertools.product(names, win_length, fftbins)
@pytest.mark.parametrize('name,win_length,fftbins', generate_window_test_data())
def test_get_window(name, win_length, fftbins):
src = F.get_window(name, win_length, fftbins=fftbins)
target = scipy.signal.get_window(name, win_length, fftbins=fftbins)
assert np.allclose(src.numpy(), target, atol=1e-5)
# def test_hz_mel_convert():
# hz = np.linspace(0, 32000, 100).astype('float32')
# mel0 = paddleaudio.utils._librosa.hz_to_mel(hz)
# mel1 = F.hz_to_mel(paddle.to_tensor(hz)).numpy()
# hz0 = paddleaudio.utils._librosa.mel_to_hz(mel0)
# hz1 = F.mel_to_hz(paddle.to_tensor(mel0)).numpy()
# assert np.allclose(hz0, hz1)
# assert np.allclose(mel0, mel1)
# assert np.allclose(hz, hz0)
# def generate_window_test_data():
# names = [
# ('hamming', ),
# ('hann', ),
# (
# 'taylor',
# 4,
# 30,
# True,
# ),
# #'kaiser',
# ('gaussian', 100),
# ('exponential', None, 1.0),
# ('triang', ),
# ('bohman', ),
# ('blackman', ),
# ('cosine', ),
# ]
# win_length = [512, 400, 1024, 2048]
# fftbins = [True, False]
# return itertools.product(names, win_length, fftbins)
# @pytest.mark.parametrize('name,win_length,fftbins', generate_window_test_data())
# def test_get_window(name, win_length, fftbins):
# src = F.get_window(name, win_length, fftbins=fftbins)
# target = scipy.signal.get_window(name, win_length, fftbins=fftbins)
# assert np.allclose(src.numpy(), target, atol=1e-5)
p2db_test_data = [
(1.0, 1e-10, 80),
......@@ -84,17 +80,40 @@ def test_power_to_db(ref_value, amin, top_db):
assert np.allclose(src.numpy(), target, atol=1e-5)
def test_mu_codec():
x, _ = utils.load_example_audio1()
x = paddle.to_tensor(x)
code = F.mu_law_encode(x)
xr = F.mu_law_decode(code)
assert np.allclose(xr.numpy(), x.numpy(), atol=1e-1)
# def test_mu_codec():
# x, _ = utils.load_example_audio1()
# x = paddle.to_tensor(x)
# code = F.mu_law_encode(x)
# xr = F.mu_law_decode(code)
# assert np.allclose(xr.numpy(), x.numpy(), atol=1e-1)
# code = F.mu_law_encode(x, mu=1024)
# xr = F.mu_law_decode(code, mu=1024)
# assert np.allclose(xr.numpy(), x.numpy(), atol=1e-2)
# code = F.mu_law_encode(x, mu=65536)
# xr = F.mu_law_decode(code, mu=65536)
# assert np.allclose(xr.numpy(), x.numpy(), atol=1e-4)
def test_mel_frequencies():
src = F.mel_frequencies(n_mels=128, f_min=0.0, f_max=11025.0, htk=False)
target = paddleaudio.utils._librosa.mel_frequencies(n_mels=128,
fmin=0.0,
fmax=11025.0,
htk=False)
assert np.allclose(src.numpy(), target)
def test_fft_frequencies():
src = F.fft_frequencies(16000, 512)
target = paddleaudio.utils._librosa.fft_frequencies(16000, 512)
np.allclose(src.numpy(), target)
code = F.mu_law_encode(x, mu=1024)
xr = F.mu_law_decode(code, mu=1024)
assert np.allclose(xr.numpy(), x.numpy(), atol=1e-2)
code = F.mu_law_encode(x, mu=65536)
xr = F.mu_law_decode(code, mu=65536)
assert np.allclose(xr.numpy(), x.numpy(), atol=1e-4)
def test_fbank_matrix():
src = F.compute_fbank_matrix(sr=16000, n_fft=512, n_mels=128)
target = paddleaudio.utils._librosa.compute_fbank_matrix(sr=16000,
n_fft=512,
n_mels=128)
assert np.allclose(src.numpy(), target, atol=1e-7) # cannot reach 1e-8
PaddleAudio/test/unit_test/test_melspect_librosa_compat.py 0 → 100644
浏览文件 @ 9cab6c61
# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import itertools
import librosa
import numpy as np
import paddle
import paddleaudio
import pytest
def generate_mel_test():
sr = [16000]
n_fft = [512, 1024]
hop_length = [160, 400]
win_length = [512]
window = ['hann', 'hamming', ('gaussian', 50)]
center = [True, False]
pad_mode = ['reflect', 'constant']
power = [1.0, 2.0]
n_mels = [80, 64, 32]
fmin = [0, 10]
fmax = [8000, None]
dtype = ['float32', 'float64']
device = ['gpu', 'cpu']
args = [
sr, n_fft, hop_length, win_length, window, center, pad_mode, power,
n_mels, fmin, fmax, dtype, device
]
return itertools.product(*args)
@pytest.mark.parametrize(
'sr,n_fft,hop_length,win_length,window,center,pad_mode,power,n_mels,f_min,f_max,dtype,device',
generate_mel_test())
def test_case(sr, n_fft, hop_length, win_length, window, center, pad_mode,
power, n_mels, f_min, f_max, dtype, device):
paddle.set_device(device)
signal, sr = paddleaudio.load('./test/unit_test/test_audio.wav')
signal_tensor = paddle.to_tensor(signal)
paddle_cpu_feat = paddleaudio.functional.melspectrogram(
signal_tensor,
sr=16000,
n_fft=n_fft,
hop_length=hop_length,
win_length=win_length,
window=window,
center=center,
n_mels=n_mels,
pad_mode=pad_mode,
f_min=f_min,
f_max=f_max,
htk=True,
norm='slaney',
dtype=dtype)
librosa_feat = librosa.feature.melspectrogram(signal,
sr=16000,
n_fft=n_fft,
hop_length=hop_length,
win_length=win_length,
window=window,
center=center,
n_mels=n_mels,
pad_mode=pad_mode,
power=2.0,
norm='slaney',
htk=True,
fmin=f_min,
fmax=f_max)
err = np.mean(np.abs(librosa_feat - paddle_cpu_feat.numpy()))
if dtype == 'float64':
assert err < 1.0e-07
else:
assert err < 5.0e-07
PaddleAudio/test/unit_test/test_mfcc_librosa_compat.py 0 → 100644
浏览文件 @ 9cab6c61
# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import itertools
import librosa
import numpy as np
import paddle
import paddleaudio
import pytest
from utils import load_example_audio1
eps_float32 = 1e-3
eps_float64 = 2.2e-5
# Pre-loading to speed up the test
signal, _ = load_example_audio1()
signal_tensor = paddle.to_tensor(signal)
def generate_mfcc_test():
sr = [16000]
n_fft = [512] #, 1024]
hop_length = [160] #, 400]
win_length = [512]
window = ['hann'] # 'hamming', ('gaussian', 50)]
center = [True] #, False]
pad_mode = ['reflect', 'constant']
power = [2.0]
n_mels = [64] #32]
fmin = [0, 10]
fmax = [8000, None]
dtype = ['float32', 'float64']
device = ['gpu', 'cpu']
n_mfcc = [40, 20]
htk = [True]
args = [
sr, n_fft, hop_length, win_length, window, center, pad_mode, power,
n_mels, fmin, fmax, dtype, device, n_mfcc, htk
]
return itertools.product(*args)
@pytest.mark.parametrize(
'sr, n_fft, hop_length, win_length, window, center, pad_mode, power,\
n_mels, fmin, fmax,dtype,device,n_mfcc,htk', generate_mfcc_test())
def test_mfcc_case(sr, n_fft, hop_length, win_length, window, center, pad_mode, power,\
n_mels, fmin, fmax,dtype,device,n_mfcc,htk):
# paddle.set_device(device)
# hop_length = 160
# win_length = 512
# window = 'hann'
# pad_mode = 'constant'
# power = 2.0
# sample_rate = 16000
# center = True
# f_min = 0.0
# for librosa, the norm is default to 'slaney'
expected = librosa.feature.mfcc(signal,
sr=sr,
n_mfcc=n_mfcc,
n_fft=win_length,
hop_length=hop_length,
win_length=win_length,
window=window,
center=center,
n_mels=n_mels,
pad_mode=pad_mode,
fmin=fmin,
fmax=fmax,
htk=htk,
power=2.0)
paddle_mfcc = paddleaudio.functional.mfcc(signal_tensor,
sr=sr,
n_mfcc=n_mfcc,
n_fft=win_length,
hop_length=hop_length,
win_length=win_length,
window=window,
center=center,
n_mels=n_mels,
pad_mode=pad_mode,
f_min=fmin,
f_max=fmax,
htk=htk,
norm='slaney',
dtype=dtype)
paddle_librosa_diff = np.mean(np.abs(expected - paddle_mfcc.numpy()))
if dtype == 'float64':
assert paddle_librosa_diff < eps_float64
else:
assert paddle_librosa_diff < eps_float32
try: # if we have torchaudio installed
import torch
import torchaudio
kwargs = {
'n_fft': win_length,
'hop_length': hop_length,
'win_length': win_length,
# 'window':window,
'center': center,
'n_mels': n_mels,
'pad_mode': pad_mode,
'f_min': fmin,
'f_max': fmax,
'mel_scale': 'htk',
'norm': 'slaney',
'power': 2.0
}
torch_mfcc_transform = torchaudio.transforms.MFCC(n_mfcc=20,
log_mels=False,
melkwargs=kwargs)
torch_mfcc = torch_mfcc_transform(torch.tensor(signal))
paddle_torch_mfcc_diff = np.mean(
np.abs(paddle_mfcc.numpy() - torch_mfcc.numpy()))
assert paddle_torch_mfcc_diff < 5e-5
torch_librosa_mfcc_diff = np.mean(np.abs(torch_mfcc.numpy() - expected))
assert torch_librosa_mfcc_diff < 5e-5
except:
pass
#test_mfcc_case(512, 40, 20, True, 8000, 'cpu','float64',eps_float64)
PaddleAudio/test/unit_test/test_stft_librosa_compat.py 0 → 100644
浏览文件 @ 9cab6c61
# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import itertools
import librosa
import numpy as np
import paddle
import paddleaudio
import pytest
from utils import load_example_audio1
def generate_test():
sr = [16000]
n_fft = [512, 1024]
hop_length = [160, 400]
win_length = [512]
window = ['hann', 'hamming', ('gaussian', 50)]
center = [True, False]
pad_mode = ['reflect', 'constant']
dtype = ['float32', 'float64']
device = ['gpu', 'cpu']
args = [
sr, n_fft, hop_length, win_length, window, center, pad_mode, dtype,
device
]
return itertools.product(*args)
@pytest.mark.parametrize(
'sr,n_fft,hop_length,win_length,window,center,pad_mode,dtype,device',
generate_test())
def test_case(sr, n_fft, hop_length, win_length, window, center, pad_mode,
dtype, device):
if dtype == 'float32':
if n_fft < 1024:
max_err = 5e-6
else:
max_err = 7e-6
min_err = 1e-8
else: #float64
max_err = 6.0e-08
min_err = 1e-10
paddle.set_device(device)
signal, _ = load_example_audio1()
signal_tensor = paddle.to_tensor(signal) #.to(device)
stft = paddleaudio.transforms.STFT(n_fft=n_fft,
hop_length=hop_length,
win_length=win_length,
window=window,
center=center,
pad_mode=pad_mode,
dtype=dtype)
paddle_feat = stft(signal_tensor.unsqueeze(0))[0]
target = paddleaudio.utils._librosa.stft(signal,
n_fft=n_fft,
win_length=win_length,
hop_length=hop_length,
window=window,
center=center,
pad_mode=pad_mode)
librosa_feat = np.concatenate(
[target.real[..., None], target.imag[..., None]], -1)
err = np.mean(np.abs(librosa_feat - paddle_feat.numpy()))
assert err <= max_err
assert err >= min_err
PaddleAudio/test/unit_test/test_transform.py
浏览文件 @ 9cab6c61
......@@ -19,49 +19,56 @@ import pytest
from paddleaudio.transforms import ISTFT, STFT, MelSpectrogram
from paddleaudio.utils._librosa import melspectrogram
paddle.set_device('cpu')
EPS = 1e-8
import itertools
from utils import load_example_audio1
# test case for stft
def generate_stft_test():
n_fft = [512, 1024]
hop_length = [160, 320]
window = ['hann', 'hamming', ('gaussian', 100), ('tukey', 0.5),
'blackman'] #'bohman'
win_length = [512, 400]
window = [
'hann',
'hamming',
('gaussian', 100), #, ('tukey', 0.5),
'blackman'
] #'bohman'
win_length = [500, 400]
pad_mode = ['reflect', 'constant']
args = [n_fft, hop_length, window, win_length, pad_mode]
return itertools.product(*args)
@pytest.mark.parametrize('n_fft,hop_length,window,win_length,pad_mode',
generate_stft_test())
def test_istft(n_fft, hop_length, window, win_length, pad_mode):
sample_rate = 16000
signal_length = sample_rate * 5
center = True
signal = np.random.uniform(-1, 1, signal_length).astype('float32')
signal_tensor = paddle.to_tensor(signal) #.to(device)
# @pytest.mark.parametrize('n_fft,hop_length,window,win_length,pad_mode',
# generate_stft_test())
# def test_istft(n_fft, hop_length, window, win_length, pad_mode):
# sample_rate = 16000
# signal_length = sample_rate * 5
# center = True
# signal = np.random.uniform(-1, 1, signal_length).astype('float32')
# signal_tensor = paddle.to_tensor(signal) #.to(device)
stft = STFT(n_fft=n_fft,
hop_length=hop_length,
win_length=win_length,
window=window,
center=center,
pad_mode=pad_mode)
# stft = STFT(n_fft=n_fft,
# hop_length=hop_length,
# win_length=win_length,
# window=window,
# center=center,
# pad_mode=pad_mode)
spectrum = stft(signal_tensor.unsqueeze(0))
# spectrum = stft(signal_tensor.unsqueeze(0))
istft = ISTFT(n_fft=n_fft,
hop_length=hop_length,
win_length=win_length,
window=window,
center=center,
pad_mode=pad_mode)
# istft = ISTFT(n_fft=n_fft,
# hop_length=hop_length,
# win_length=win_length,
# window=window,
# center=center,
# pad_mode=pad_mode)
reconstructed = istft(spectrum, signal_length)
assert np.allclose(signal, reconstructed[0].numpy(), rtol=1e-5, atol=1e-3)
# reconstructed = istft(spectrum, signal_length)
# assert np.allclose(signal, reconstructed[0].numpy(), rtol=1e-5, atol=1e-3)
@pytest.mark.parametrize('n_fft,hop_length,window,win_length,pad_mode',
......@@ -70,6 +77,8 @@ def test_stft(n_fft, hop_length, window, win_length, pad_mode):
sample_rate = 16000
signal_length = sample_rate * 5
center = True
#signal = paddleaudio.load('./test_audio.wav')
signal, _ = load_example_audio1()
signal = np.random.uniform(-1, 1, signal_length).astype('float32')
signal_tensor = paddle.to_tensor(signal) #.to(device)
......@@ -90,54 +99,54 @@ def test_stft(n_fft, hop_length, window, win_length, pad_mode):
center=center,
pad_mode=pad_mode)
assert np.allclose(target.real, src[:, :, 0], rtol=1e-5, atol=1e-2)
assert np.allclose(target.imag, src[:, :, 1], rtol=1e-5, atol=1e-2)
def generate_mel_test():
sr = [16000]
n_fft = [512, 1024]
hop_length = [160, 400]
win_length = [512]
window = ['hann', 'hamming', ('gaussian', 50)]
center = [True, False]
pad_mode = ['reflect', 'constant']
power = [1.0, 2.0]
n_mels = [120, 32]
fmin = [0, 10]
fmax = [8000, None]
args = [
sr, n_fft, hop_length, win_length, window, center, pad_mode, power,
n_mels, fmin, fmax
]
return itertools.product(*args)
@pytest.mark.parametrize(
'sr,n_fft,hop_length,win_length,window,center,pad_mode,power,n_mels,fmin,fmax',
generate_mel_test())
def test_melspectrogram(sr, n_fft, hop_length, win_length, window, center,
pad_mode, power, n_mels, fmin, fmax):
melspectrogram = MelSpectrogram(sr, n_fft, hop_length, win_length, window,
center, pad_mode, power, n_mels, fmin, fmax)
signal_length = 32000 * 5
signal = np.random.uniform(-1, 1, signal_length).astype('float32')
signal_tensor = paddle.to_tensor(signal) #.to(device)
src = melspectrogram(signal_tensor.unsqueeze(0))
target = librosa.feature.melspectrogram(signal,
sr=sr,
n_fft=n_fft,
win_length=win_length,
hop_length=hop_length,
window=window,
center=center,
pad_mode=pad_mode,
power=power,
n_mels=n_mels,
fmin=fmin,
fmax=fmax)
assert np.allclose(src.numpy()[0], target, atol=1e-3)
tol = 1e-4
assert np.allclose(target.real, src[:, :, 0], rtol=tol, atol=tol)
assert np.allclose(target.imag, src[:, :, 1], rtol=tol, atol=tol)
# def generate_mel_test():
# sr = [16000]
# n_fft = [512, 1024]
# hop_length = [160, 400]
# win_length = [512]
# window = ['hann', 'hamming', ('gaussian', 50)]
# center = [True, False]
# pad_mode = ['reflect', 'constant']
# power = [1.0, 2.0]
# n_mels = [120, 32]
# fmin = [0, 10]
# fmax = [8000, None]
# args = [
# sr, n_fft, hop_length, win_length, window, center, pad_mode, power,
# n_mels, fmin, fmax
# ]
# return itertools.product(*args)
# @pytest.mark.parametrize(
# 'sr,n_fft,hop_length,win_length,window,center,pad_mode,power,n_mels,fmin,fmax',
# generate_mel_test())
# def test_melspectrogram(sr, n_fft, hop_length, win_length, window, center,
# pad_mode, power, n_mels, fmin, fmax):
# melspectrogram = MelSpectrogram(sr, n_fft, hop_length, win_length, window,
# center, pad_mode, power, n_mels, fmin, fmax)
# signal_length = 32000 * 5
# signal = np.random.uniform(-1, 1, signal_length).astype('float32')
# signal_tensor = paddle.to_tensor(signal) #.to(device)
# src = melspectrogram(signal_tensor.unsqueeze(0))
# target = librosa.feature.melspectrogram(signal,
# sr=sr,
# n_fft=n_fft,
# win_length=win_length,
# hop_length=hop_length,
# window=window,
# center=center,
# pad_mode=pad_mode,
# power=power,
# n_mels=n_mels,
# fmin=fmin,
# fmax=fmax)
# assert np.allclose(src.numpy()[0], target, atol=1e-4)
PaddleAudio/test/unit_test/test_window.py
浏览文件 @ 9cab6c61
......@@ -12,56 +12,75 @@
# See the License for the specific language governing permissions and
# limitations under the License.
import itertools
import numpy as np
import paddleaudio
import paddle
import paddleaudio as pa
import pytest
import scipy
from scipy.signal import get_window
def test_data():
win_length = [256, 512, 1024]
sym = [True, False]
device = ['gpu', 'cpu']
dtype = ['float32', 'float64']
args = [win_length, sym, device, dtype]
return itertools.product(*args)
@pytest.mark.parametrize('win_length,sym,device,dtype', test_data())
def test_window(win_length, sym, device, dtype):
paddle.set_device(device)
if dtype == 'float64':
upper_err = 7e-8
lower_err = 0
else:
upper_err = 8e-8
lower_err = 0
src = pa.blackman_window(win_length, sym, dtype=dtype).numpy()
expected = get_window('blackman', win_length, not sym)
assert np.mean(np.abs(src - expected)) < upper_err
assert np.mean(np.abs(src - expected)) >= lower_err
src = pa.bohman_window(win_length, sym, dtype=dtype).numpy()
expected = get_window('bohman', win_length, not sym)
assert np.mean(np.abs(src - expected)) < upper_err
assert np.mean(np.abs(src - expected)) >= lower_err
src = pa.triang_window(win_length, sym, dtype=dtype).numpy()
expected = get_window('triang', win_length, not sym)
assert np.mean(np.abs(src - expected)) < upper_err
assert np.mean(np.abs(src - expected)) >= lower_err
src = pa.hamming_window(win_length, sym, dtype=dtype).numpy()
expected = get_window('hamming', win_length, not sym)
assert np.mean(np.abs(src - expected)) < upper_err
assert np.mean(np.abs(src - expected)) >= lower_err
src = pa.hann_window(win_length, sym, dtype=dtype).numpy()
expected = get_window('hann', win_length, not sym)
assert np.mean(np.abs(src - expected)) < upper_err
assert np.mean(np.abs(src - expected)) >= lower_err
EPS = 1e-8
test_data = [
(512, True),
(512, False),
(1024, True),
(1024, False),
(200, False),
(200, True),
]
src = pa.tukey_window(win_length, 0.5, sym, dtype=dtype).numpy()
expected = get_window(('tukey', 0.5), win_length, not sym)
assert np.mean(np.abs(src - expected)) < upper_err
assert np.mean(np.abs(src - expected)) >= lower_err
src = pa.gaussian_window(win_length, 0.5, sym, dtype=dtype).numpy()
expected = get_window(('gaussian', 0.5), win_length, not sym)
assert np.mean(np.abs(src - expected)) < upper_err
assert np.mean(np.abs(src - expected)) >= lower_err
@pytest.mark.parametrize('win_length,sym', test_data)
def test_window(win_length, sym):
assert np.allclose(paddleaudio.blackman_window(win_length, sym).numpy(),
scipy.signal.get_window('blackman', win_length, not sym),
atol=1e-6)
assert np.allclose(paddleaudio.bohman_window(win_length, sym).numpy(),
scipy.signal.get_window('bohman', win_length, not sym),
atol=1e-6)
assert np.allclose(paddleaudio.triang_window(win_length, sym).numpy(),
scipy.signal.get_window('triang', win_length, not sym),
atol=1e-6)
assert np.allclose(paddleaudio.hamming_window(win_length, sym).numpy(),
scipy.signal.get_window('hamming', win_length, not sym),
atol=1e-6)
assert np.allclose(paddleaudio.hann_window(win_length, sym).numpy(),
scipy.signal.get_window('hann', win_length, not sym),
atol=1e-6)
assert np.allclose(paddleaudio.tukey_window(win_length, 0.5, sym).numpy(),
scipy.signal.get_window(('tukey', 0.5), win_length,
not sym),
atol=1e-6)
assert np.allclose(paddleaudio.gaussian_window(win_length, 0.5,
sym).numpy(),
scipy.signal.get_window(('gaussian', 0.5), win_length,
not sym),
atol=1e-6)
assert np.allclose(paddleaudio.exponential_window(win_length, None, 1.0,
sym).numpy(),
scipy.signal.get_window(('exponential', None, 1.0),
win_length, not sym),
atol=1e-6)
src = pa.exponential_window(win_length, None, 1.0, sym, dtype=dtype).numpy()
expected = get_window(('exponential', None, 1.0), win_length, not sym)
assert np.mean(np.abs(src - expected)) < upper_err
assert np.mean(np.abs(src - expected)) >= lower_err
assert np.allclose(paddleaudio.taylor_window(win_length, 4, 30, True,
sym).numpy(),
scipy.signal.get_window(('taylor', 4, 30, True),
win_length, not sym),
atol=1e-6)
src = pa.taylor_window(win_length, 4, 30, True, sym, dtype=dtype).numpy()
expected = get_window(('taylor', 4, 30, True), win_length, not sym)
assert np.mean(np.abs(src - expected)) <= upper_err
assert np.mean(np.abs(src - expected)) >= lower_err
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或