speechbrain.processing.features 模块

低级特征管道组件

该库收集了计算流行语音特征的函数，这些函数适用于批量数据。所有类都是nn.Module类型。这使得能够实现端到端的可微分性，并通过它们反向传播梯度。我们的函数是torch音频工具包中函数的修改版本（https://github.com/pytorch/audio）。

Example

>>> import torch
>>> from speechbrain.dataio.dataio import read_audio
>>> signal =read_audio('tests/samples/single-mic/example1.wav')
>>> signal = signal.unsqueeze(0)
>>> compute_STFT = STFT(
...     sample_rate=16000, win_length=25, hop_length=10, n_fft=400
... )
>>> features = compute_STFT(signal)
>>> features = spectral_magnitude(features)
>>> compute_fbanks = Filterbank(n_mels=40)
>>> features = compute_fbanks(features)
>>> compute_mfccs = DCT(input_size=40, n_out=20)
>>> features = compute_mfccs(features)
>>> compute_deltas = Deltas(input_size=20)
>>> delta1 = compute_deltas(features)
>>> delta2 = compute_deltas(delta1)
>>> features = torch.cat([features, delta1, delta2], dim=2)
>>> compute_cw = ContextWindow(left_frames=5, right_frames=5)
>>> features  = compute_cw(features)
>>> norm = InputNormalization()
>>> features = norm(features, torch.tensor([1]).float())

Authors

Mirco Ravanelli 2020

摘要

类：

`ContextWindow`	计算上下文窗口。
`DCT`	计算离散余弦变换。
`Deltas`	计算delta系数（时间导数）。
`DynamicRangeCompression`	音频信号的动态范围压缩 - 带有可选乘数的裁剪对数尺度
`Filterbank`	计算给定频谱幅度的滤波器组（FBANK）特征。
`GlobalNorm`	一个全局归一化模块 - 计算整个批次中未屏蔽位置的单一均值和标准差，并使用它来将输入归一化为所需的均值和标准差。
`ISTFT`	计算逆短时傅里叶变换 (ISTFT)
`InputNormalization`	对输入张量进行均值和方差归一化。
`MinLevelNorm`	分贝尺度常用的归一化方法
`STFT`	计算短时傅里叶变换 (STFT)。

函数：

spectral_magnitude

返回复数频谱图的幅度。

参考

class speechbrain.processing.features.STFT(sample_rate, win_length=25, hop_length=10, n_fft=400, window_fn=<built-in method hamming_window of type object>, normalized_stft=False, center=True, pad_mode='constant', onesided=True)[source]

基础：Module

计算短时傅里叶变换 (STFT)。

该类计算音频信号的短时傅里叶变换。它支持多通道音频输入（批次，时间，通道）。

Parameters:

sample_rate (int) – 输入音频信号的采样率（例如 16000）。
win_length (float) – 用于计算STFT的滑动窗口的长度（以毫秒为单位）。
hop_length (float) – 用于计算STFT的滑动窗口的跳跃长度（以毫秒为单位）。
n_fft (int) – STFT的fft点数。它定义了频率分辨率 (n_fft 应该小于或等于 win_len)。
window_fn (function) – 一个函数，该函数接受一个整数（样本数量）并输出一个张量，该张量将在进行fft之前与每个窗口相乘。
normalized_stft (bool) – 如果为True，函数将返回归一化的STFT结果，即乘以win_length^-0.5（默认为False）。
center (bool) – 如果为True（默认值），输入将在两侧填充，以便第t帧在时间t×hop_length处居中。否则，第t帧从时间t×hop_length开始。
pad_mode (str) – 可以是‘constant’,’reflect’,’replicate’, ‘circular’, ‘reflect’ （默认）。‘constant’ 使用常数值填充输入张量的边界。‘reflect’ 使用输入边界的反射来填充输入张量。‘replicate’ 使用输入边界的复制来填充输入张量。‘circular’ 使用循环复制来填充。
onesided (True) – 如果为True（默认），则仅返回nfft/2个值。请注意，由于傅里叶变换的共轭对称性，其他样本是冗余的。

Example

>>> import torch
>>> compute_STFT = STFT(
...     sample_rate=16000, win_length=25, hop_length=10, n_fft=400
... )
>>> inputs = torch.randn([10, 16000])
>>> features = compute_STFT(inputs)
>>> features.shape
torch.Size([10, 101, 201, 2])

forward(x)[source]

返回从输入波形生成的STFT。

Parameters:: x (torch.Tensor) – 要转换的一批音频信号。
Returns:: stft
Return type:: torch.Tensor

get_filter_properties() → FilterProperties[source]

class speechbrain.processing.features.ISTFT(sample_rate, n_fft=None, win_length=25, hop_length=10, window_fn=<built-in method hamming_window of type object>, normalized_stft=False, center=True, onesided=True, epsilon=1e-12)[source]

基础：Module

计算逆短时傅里叶变换 (ISTFT)

该类计算音频信号的逆短时傅里叶变换。它支持多通道音频输入（批次，时间步长，n_fft，2，n_channels [可选]）。

Parameters:

sample_rate (int) – 输入音频信号的采样率（例如 16000）。
n_fft (int) – FFT中的点数。
win_length (float) – 计算STFT时使用的滑动窗口的长度（以毫秒为单位）。
hop_length (float) – 计算STFT时使用的滑动窗口的跳跃长度（以毫秒为单位）。
window_fn (function) – 一个接受整数（样本数量）并输出张量的函数，该张量将用作ifft的窗口。
normalized_stft (bool) – 如果为True，函数假设它正在处理归一化的STFT结果。（默认为False）
center (bool) – 如果为True（默认值），函数假设STFT结果在两侧进行了填充。
onesided (True) – 如果为True（默认值），该函数假设每个时间帧的STFT有n_fft/2个值。
epsilon (float) – 一个小的值，用于在通过平方窗口的和进行归一化时避免除以0。调整它可以修复重建信号在开始和结束时的一些异常。epsilon的默认值是1e-12。

Example

>>> import torch
>>> compute_STFT = STFT(
...     sample_rate=16000, win_length=25, hop_length=10, n_fft=400
... )
>>> compute_ISTFT = ISTFT(
...     sample_rate=16000, win_length=25, hop_length=10
... )
>>> inputs = torch.randn([10, 16000])
>>> outputs = compute_ISTFT(compute_STFT(inputs))
>>> outputs.shape
torch.Size([10, 16000])

forward(x, sig_length=None)[source]

返回从输入信号生成的ISTFT。

Parameters:

x (torch.Tensor) – 要转换的一批频域音频信号。
sig_length (int) – 输出信号的长度，以样本数表示。如果未指定，将等于：(time_step - 1) * hop_length + n_fft

Returns:

istft

Return type:

torch.Tensor

speechbrain.processing.features.spectral_magnitude(stft, power: int = 1, log: bool = False, eps: float = 1e-14)[source]

返回复数频谱图的幅度。

Parameters:

stft (torch.Tensor) – 一个张量，来自stft函数的输出。
power (int) – 在计算幅度时使用的幂次。使用 power=1 来生成功率谱图。使用 power=0.5 来生成幅度谱图。
log (bool) – 是否对频谱特征应用对数。
eps (float) – 一个防止零平方根的小值。

Returns:

光谱

Return type:

torch.Tensor

Example

>>> a = torch.Tensor([[3, 4]])
>>> spectral_magnitude(a, power=0.5)
tensor([5.])

class speechbrain.processing.features.Filterbank(n_mels=40, log_mel=True, filter_shape='triangular', f_min=0, f_max=8000, n_fft=400, sample_rate=16000, power_spectrogram=2, amin=1e-10, ref_value=1.0, top_db=80.0, param_change_factor=1.0, param_rand_factor=0.0, freeze=True)[source]

基础：Module

计算给定频谱幅度的滤波器组（FBANK）特征。

Parameters:

n_mels (float) – 用于平均频谱图的Mel滤波器数量。
log_mel (bool) – 如果为True，则计算FBANKs的对数。
filter_shape (str) – 过滤器的形状（‘triangular’, ‘rectangular’, ‘gaussian’）。
f_min (int) – Mel滤波器的最低频率。
f_max (int) – Mel滤波器的最高频率。
n_fft (int) – STFT的FFT点数。它定义了频率分辨率 (n_fft 应该小于或等于 win_len)。
sample_rate (int) – 输入音频信号的采样率（例如，16000）
power_spectrogram (float) – 用于频谱图计算的指数。
amin (float) – 最小振幅（用于数值稳定性）。
ref_value (float) – 用于分贝刻度的参考值。
top_db (float) – 最小负截止值，单位为分贝。
param_change_factor (bool) – 如果 freeze=False，此参数会影响滤波器参数（即 central_freqs 和 bands）在训练过程中变化的速度。当值较高时（例如，param_change_factor=1），滤波器在训练过程中变化较大。当值较低时（例如，param_change_factor=0.1），滤波器参数在训练过程中更加稳定。
param_rand_factor (float) – 此参数可用于在训练期间随机更改滤波器参数（即中心频率和带宽）。因此，它是一种正则化方法。param_rand_factor=0 不会产生影响，而 param_rand_factor=0.15 允许在滤波器参数标准值的 +-15% 范围内进行随机变化（例如，如果中心频率为 100 Hz，我们可以随机将其更改为 85 Hz 到 115 Hz）。
freeze (bool) – 如果为False，则每个滤波器的中心频率和带宽将被添加到nn.parameters中。如果为True，则计算标准的冻结特征。

Example

>>> import torch
>>> compute_fbanks = Filterbank()
>>> inputs = torch.randn([10, 101, 201])
>>> features = compute_fbanks(inputs)
>>> features.shape
torch.Size([10, 101, 40])

forward(spectrogram)[source]

返回FBANks。

Parameters:: spectrogram (torch.Tensor) – 一批频谱图张量。
Returns:: fbanks
Return type:: torch.Tensor

class speechbrain.processing.features.DCT(input_size, n_out=20, ortho_norm=True)[source]

基础：Module

计算离散余弦变换。

该类主要用于计算音频信号的MFCC特征，给定一组FBANK特征作为输入。

Parameters:

input_size (int) – 输入中最后一个维度的预期大小。
n_out (int) – 输出系数的数量。
ortho_norm (bool) – 是否使用正交范数。

Example

>>> import torch
>>> inputs = torch.randn([10, 101, 40])
>>> compute_mfccs = DCT(input_size=inputs.size(-1))
>>> features = compute_mfccs(inputs)
>>> features.shape
torch.Size([10, 101, 20])

forward(x)[source]

返回输入张量的DCT。

Parameters:: x (torch.Tensor) – 要转换的一批张量，通常是fbank特征。
Returns:: dct
Return type:: torch.Tensor

class speechbrain.processing.features.Deltas(input_size, window_length=5)[source]

基础：Module

计算delta系数（时间导数）。

Parameters:

input_size (int) – 用于参数初始化的输入预期大小。
window_length (int) – 用于计算时间导数的窗口长度。

Example

>>> inputs = torch.randn([10, 101, 20])
>>> compute_deltas = Deltas(input_size=inputs.size(-1))
>>> features = compute_deltas(inputs)
>>> features.shape
torch.Size([10, 101, 20])

forward(x)[source]

返回增量系数。

Parameters:: x (torch.Tensor) – 一批张量。
Returns:: delta_coeff
Return type:: torch.Tensor

class speechbrain.processing.features.ContextWindow(left_frames=0, right_frames=0)[source]

基础：Module

计算上下文窗口。

该类通过将多个时间步聚集在一个特征向量中来应用上下文窗口。该操作是通过一个基于固定核的卷积层来执行的，该核是为此设计的。

Parameters:

left_frames (int) – 要收集的左侧帧数（即过去的帧）。
right_frames (int) – 要收集的右侧帧数（即未来的帧）。

Example

>>> import torch
>>> compute_cw = ContextWindow(left_frames=5, right_frames=5)
>>> inputs = torch.randn([10, 101, 20])
>>> features = compute_cw(inputs)
>>> features.shape
torch.Size([10, 101, 220])

forward(x)[source]

返回带有周围上下文的张量。

Parameters:: x (torch.Tensor) – 一批张量。
Returns:: cw_x – 上下文丰富的张量
Return type:: torch.Tensor

class speechbrain.processing.features.InputNormalization(mean_norm=True, std_norm=True, norm_type='global', avg_factor=None, requires_grad=False, update_until_epoch=3)[source]

基础：Module

对输入张量执行均值和方差归一化。

Parameters:

mean_norm (True) – 如果为True，则均值将被归一化。
std_norm (True) – 如果为True，标准差将被归一化。
norm_type (str) – 它定义了如何计算统计量（'sentence' 在句子级别计算，'batch' 在批次级别计算，'speaker' 在说话者级别计算，而 global 则为数据集中的所有句子计算一个单一的归一化向量）。说话者和全局统计量是通过移动平均方法计算的。
avg_factor (float) – 它可以用于手动设置当前统计数据和累积统计数据之间的加权因子。
requires_grad (bool) – 该模块是否应在训练期间使用梯度进行更新。
update_until_epoch (int) – 在此时期之后，规范统计的更新应停止。

Example

>>> import torch
>>> norm = InputNormalization()
>>> inputs = torch.randn([10, 101, 20])
>>> inp_len = torch.ones([10])
>>> features = norm(inputs, inp_len)

Dict: Dict 的别名

spk_dict_mean: Dict[int, Tensor]

spk_dict_std: Dict[int, Tensor]

spk_dict_count: Dict[int, int]

forward(x, lengths, spk_ids=tensor([]), epoch=0)[source]

返回带有周围上下文的张量。

Parameters:

x (torch.Tensor) – 一批张量。
lengths (torch.Tensor) – 一批包含每个句子相对长度的张量（例如，[0.7, 0.9, 1.0]）。它用于避免在零填充步骤上计算统计信息。
spk_ids (包含每个说话者ID的torch.Tensor（例如[0 10 6]）。) – 当norm_type='speaker'时，用于执行每个说话者的归一化。
epoch (int) – 周期计数。

Returns:

x – 归一化的张量。

Return type:

torch.Tensor

to(device)[source]: 将所需的张量放置在正确的设备上。

class speechbrain.processing.features.GlobalNorm(norm_mean=0.0, norm_std=1.0, update_steps=None, length_dim=2, mask_value=0.0)[source]

基础：Module

一个全局归一化模块 - 计算整个批次中未屏蔽位置的单一均值和标准差，并使用它来将输入归一化为所需的均值和标准差。

这种标准化是可逆的 - 可以使用 .denormalize() 方法恢复原始值。

Parameters:

norm_mean (float) – 期望的归一化均值
norm_std (float) – 期望的归一化标准差
update_steps (float) – 统计信息将被收集的步骤数
length_dim (int) – 用于表示长度的维度
mask_value (float) – 用于填充被屏蔽位置的值如果没有mask_value，被屏蔽的位置将被归一化，这可能不是期望的结果

Example

>>> import torch
>>> from speechbrain.processing.features import GlobalNorm
>>> global_norm = GlobalNorm(
...     norm_mean=0.5,
...     norm_std=0.2,
...     update_steps=3,
...     length_dim=1
... )
>>> x = torch.tensor([[1., 2., 3.]])
>>> x_norm = global_norm(x)
>>> x_norm
tensor([[0.3000, 0.5000, 0.7000]])
>>> x = torch.tensor([[5., 10., -4.]])
>>> x_norm = global_norm(x)
>>> x_norm
tensor([[0.6071, 0.8541, 0.1623]])
>>> x_denorm = global_norm.denormalize(x_norm)
>>> x_denorm
tensor([[ 5.0000, 10.0000, -4.0000]])
>>> x = torch.tensor([[100., -100., -50.]])
>>> global_norm.freeze()
>>> global_norm(x)
tensor([[ 5.3016, -4.5816, -2.1108]])
>>> global_norm.denormalize(x_norm)
tensor([[ 5.0000, 10.0000, -4.0000]])
>>> global_norm.unfreeze()
>>> global_norm(x)
tensor([[ 5.3016, -4.5816, -2.1108]])
>>> global_norm.denormalize(x_norm)
tensor([[ 5.0000, 10.0000, -4.0000]])

forward(x, lengths=None, mask_value=None, skip_update=False)[source]

对提供的张量进行归一化

Parameters:

x (torch.Tensor) – 要标准化的张量
lengths (torch.Tensor) – 一个相对长度的张量（填充不会计入归一化）
mask_value (float) – 用于掩码位置的值
skip_update (false) – 是否跳过对规范的更新

Returns:

result – 归一化后的张量

Return type:

torch.Tensor

normalize(x)[source]

对运行中的均值和标准差执行归一化操作

Parameters:: x (torch.Tensor) – 要标准化的张量
Returns:: result – 归一化后的张量
Return type:: torch.Tensor

get_mask(x, lengths)[source]

返回指定张量的长度掩码

Parameters:

x (torch.Tensor) – 将为其获取掩码的张量
lengths (torch.Tensor) – 长度张量

Returns:

mask – 掩码张量

Return type:

torch.Tensor

denormalize(x)[source]

反转归一化过程

Parameters:: x (torch.Tensor) – 一个归一化的张量
Returns:: result – x的非规范化版本
Return type:: torch.Tensor

freeze()[source]: 停止对运行均值/标准差的更新

unfreeze()[source]: 恢复对运行均值/标准差的更新

class speechbrain.processing.features.MinLevelNorm(min_level_db)[source]

基础：Module

分贝尺度常用的归一化方法

方案如下

x_norm = (x - min_level_db)/-min_level_db * 2 - 1

该方案的基本原理如下：

量表的顶部被假定为0db。 x_rel = (x - min) / (max - min) 给出了在最小值和最大值之间的相对位置，其中最小值为0，最大值为1。

随后的重新缩放 (x_rel * 2 - 1) 将其置于从 -1 到 1 的范围内，范围的中间点位于零。

Parameters:: min_level_db (float) – 最小级别

Example

>>> norm = MinLevelNorm(min_level_db=-100.)
>>> x = torch.tensor([-50., -20., -80.])
>>> x_norm = norm(x)
>>> x_norm
tensor([ 0.0000,  0.6000, -0.6000])

forward(x)[source]

将音频特征（通常是频谱图）以分贝为单位进行归一化

Parameters:: x (torch.Tensor) – 输入特征
Returns:: normalized_features – 归一化特征
Return type:: torch.Tensor

denormalize(x)[source]

反转最小级别归一化过程

Parameters:: x (torch.Tensor) – 归一化的张量
Returns:: result – 反归一化的张量
Return type:: torch.Tensor

class speechbrain.processing.features.DynamicRangeCompression(multiplier=1, clip_val=1e-05)[source]

基础：Module

音频信号的动态范围压缩 - 带有可选乘数的裁剪对数尺度

Parameters:

multiplier (float) – 乘数常数
clip_val (float) – 最小接受值（低于此最小值的值将被裁剪）

Example

>>> drc = DynamicRangeCompression()
>>> x = torch.tensor([10., 20., 0., 30.])
>>> drc(x)
tensor([  2.3026,   2.9957, -11.5129,   3.4012])
>>> drc = DynamicRangeCompression(2.)
>>> x = torch.tensor([10., 20., 0., 30.])
>>> drc(x)
tensor([  2.9957,   3.6889, -10.8198,   4.0943])

forward(x)[source]

执行前向传递

Parameters:: x (torch.Tensor) – 源信号
Returns:: result – 结果
Return type:: torch.Tensor