speechbrain.processing.features 模块

低级特征管道组件

这个库收集了在数据批次上计算常用语音特征的函数。所有的类都是 nn.Module 类型。这使得可以实现端到端可微性，并通过它们反向传播梯度。我们的函数是 torch audio toolkit (https://github.com/pytorch/audio) 中函数的修改版本。

示例

>>> 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())

作者

• Mirco Ravanelli 2020

• Peter Plantinga 2025

• Rogier van Dalen 2025

摘要

类

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

函数

combine_gaussian_statistics	合并两段数据的第一阶和第二阶矩。
combine_gaussian_statistics_distributed	使用 torch.distributed 合并多段数据的第一阶和第二阶矩。
gaussian_statistics	计算数据的第一阶和第二阶矩，并将其作为向量在一个或多个维度上的计数、均值和方差返回。
make_padding_mask	根据给定维度上的相对长度创建遮罩。
mean_std_update	更新已在 run_count 样本上计算的均值和方差统计信息 run_mean 和 run_std，以整合新样本 x。
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)

基类：Module

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

此类计算音频信号的短时傅里叶变换 (STFT)。它支持多通道音频输入 (batch, time, channels)。

参数:

• sample_rate (int) – 输入音频信号的采样率 (例如 16000)。

• win_length (float) – 用于计算 STFT 的滑动窗口长度 (毫秒)。

• hop_length (float) – 用于计算 STFT 的滑动窗口的跳跃长度 (毫秒)。

• n_fft (int) – STFT 的 FFT 点数。它定义了频率分辨率 (n_fft 应该小于等于 win_len)。

• window_fn (function) – 一个函数，接受一个整数 (样本数) 并输出一个 tensor，用于在 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’ 用一个常数值填充输入 tensor 的边界。‘reflect’ 使用输入边界的反射填充输入 tensor。‘replicate’ 使用输入边界的复制填充输入 tensor。‘circular’ 使用循环复制填充。

• onesided (True) – 如果为 True (默认)，只返回 nfft/2 个值。注意，由于傅里叶变换的共轭对称性，其他样本是冗余的。

示例

>>> 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)

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

参数:

x (torch.Tensor) – 要进行变换的音频信号批次。

返回:

stft

返回类型:

torch.Tensor

get_filter_properties() → FilterProperties

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)

基类：Module

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

此类计算音频信号的逆短时傅里叶变换 (ISTFT)。它支持多通道音频输入 (batch, time_step, n_fft, 2, n_channels [可选])。

参数:

• sample_rate (int) – 输入音频信号的采样率 (例如 16000)。

• n_fft (int) – FFT 点数。

• win_length (float) – 计算 STFT 时使用的滑动窗口长度 (毫秒)。

• hop_length (float) – 计算 STFT 时使用的滑动窗口的跳跃长度 (毫秒)。

• window_fn (function) – 一个函数，接受一个整数 (样本数) 并输出一个 tensor，用作 IFFT 的窗口。

• normalized_stft (bool) – 如果为 True，函数假定正在处理归一化的 STFT 结果。(默认为 False)

• center (bool) – 如果为 True (默认)，函数假定 STFT 结果已在两边填充。

• onesided (True) – 如果为 True (默认)，函数假定 STFT 的每个时间帧有 n_fft/2 个值。

• epsilon (float) – 一个小值，用于在按平方窗口总和归一化时避免除以 0。调整它可以修复重构信号开头和结尾的一些异常。epsilon 的默认值为 1e-12。

示例

>>> 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)

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

参数:

• x (torch.Tensor) – 要进行变换的频域音频信号批次。

• sig_length (int) – 输出信号的样本数长度。如果未指定，将等于：(time_step - 1) * hop_length + n_fft

返回:

istft

返回类型:

torch.Tensor

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

返回复数谱图的幅度。

参数:

• stft (torch.Tensor) – 一个 tensor，来自 stft 函数的输出。

• power (int) – 计算幅度时使用的幂。使用 power=1 表示功率谱图。使用 power=0.5 表示幅度谱图。

• log (bool) – 是否对频谱特征应用对数。

• eps (float) – 一个小值，用于防止对零开平方根。

返回:

spectr

返回类型:

torch.Tensor

示例

>>> 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)

基类：Module

根据频谱幅度计算滤波器组 (FBANK) 特征。

参数:

• 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) – 用于 dB 尺度的参考值。

• 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，则计算标准的冻结特征。

示例

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

forward(spectrogram)

返回 FBANK。

参数:

spectrogram (torch.Tensor) – 一批频谱图张量。

返回:

fbanks

返回类型:

torch.Tensor

class speechbrain.processing.features.DCT(input_size, n_out=20, ortho_norm=True)

基类：Module

计算离散余弦变换。

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

参数:

• input_size (int) – 输入的最后一维的期望大小。

• n_out (int) – 输出系数的数量。

• ortho_norm (bool) – 是否使用正交范数。

示例

>>> 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)

返回输入张量的 DCT。

参数:

x (torch.Tensor) – 要转换的一批张量，通常是 fbank 特征。

返回:

dct

返回类型:

torch.Tensor

class speechbrain.processing.features.Deltas(input_size, window_length=5)

基类：Module

计算 delta 系数 (时间导数)。

参数:

• input_size (int) – 用于参数初始化的输入数据的期望大小。

• window_length (int) – 用于计算时间导数的窗口长度。

示例

>>> 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)

返回 delta 系数。

参数:

x (torch.Tensor) – 一批张量。

返回:

delta_coeff

返回类型:

torch.Tensor

class speechbrain.processing.features.ContextWindow(left_frames=0, right_frames=0)

基类：Module

计算上下文窗口。

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

参数:

• left_frames (int) – 要收集的左侧帧数（即，过去的帧）。

• right_frames (int) – 要收集的右侧帧数（即，未来的帧）。

示例

>>> 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)

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

参数:

x (torch.Tensor) – 一批张量。

返回:

cw_x – 上下文丰富的张量

返回类型:

torch.Tensor

speechbrain.processing.features.gaussian_statistics(x: Tensor, mask: Tensor | None = None, dim: int | tuple | None = None)

计算数据的第一阶和第二阶矩，并将其作为向量在一个或多个维度上的计数、均值和方差返回。

参数:

• x (torch.Tensor) – 要计算统计数据的张量。

• mask (torch.Tensor) – 用于在统计计算中排除填充的填充掩码。对于 dim 中的维度，掩码大小应与 x 精确匹配。除 dim 外的所有维度都应为 1（例如 [B, T, 1, …]）。1 / True 表示有效位置，0 / False 表示填充位置。

• dim (int | tuple | None) – 应计算统计数据的一个或多个维度。输出中会保留其他维度。如果为 None，则返回标量值统计数据。

返回:

• count (int) – 统计计算中的值的数量，不包含填充时，这只是 dim 中维度的长度的乘积。

• mean (torch.Tensor) – dim 中维度的非填充值的平均值。

• variance (torch.Tensor) – dim 中维度的非填充值的（有偏）方差。

示例

>>> x = torch.tensor([[1., 3., 0.]])
>>> mask = torch.tensor([[True, True, False]])
>>> dim = (0, 1)
>>> count, mean, variance = gaussian_statistics(x, mask, dim)
>>> count
2
>>> mean
tensor(2.)
>>> variance
tensor(1.)

speechbrain.processing.features.combine_gaussian_statistics(left_statistics: Tuple[int, Tensor, Tensor | None], right_statistics: Tuple[int, Tensor, Tensor | None])

合并来自两部分数据的一阶和二阶矩。数据和结果的格式为 (count, mean, variance)。结果是如同在 left_statistics 和 right_statistics 的数据串联上计算得出的均值和方差。

参数:

• left_statistics (Tuple[int, torch.Tensor, Optional[torch.Tensor]]) – 一组高斯统计数据：count, mean, variance

• right_statistics (Tuple[int, torch.Tensor, Optional[torch.Tensor]]) – 另一组高斯统计数据：count, mean, variance

返回:

• count – 数据中的元素总数。

• mean – 合并后的均值。

• variance – 合并后的方差，相对于新的均值。如果任一组统计数据没有方差（为 None），则返回 None。

speechbrain.processing.features.combine_gaussian_statistics_distributed(statistics: Tuple[int, Tensor, Tensor])

使用 torch.distributed 合并来自多部分数据的一阶和二阶矩。数据和结果的格式为 (count, mean, variance)。结果是如同在所有并行进程的 statistics 数据串联上计算得出的均值和方差。

参数:

statistics (Tuple[int, torch.Tensor, torch.Tensor]) – 一组跨所有进程进行归约的高斯统计数据。元组的三个元素分别代表 count, mean 和 variance。

返回:

• count – 跨进程的数据中的元素总数。

• mean – 合并后的均值。

• variance – 合并后的方差，相对于新的均值。

speechbrain.processing.features.mean_std_update(x: Tensor, mask: Tensor | None, dim: int | tuple | None, run_count: int, run_mean: Tensor, run_std: Tensor)

更新已在 run_count 样本上计算的均值和方差统计信息 run_mean 和 run_std，以整合新样本 x。

警告：必须在所有进程之间同步调用。

参数:

• x (torch.Tensor) – 要添加到运行统计数据中的新值。

• mask (torch.Tensor) – 用于在统计计算中排除填充的填充掩码。除批量和时间外的所有维度都应为 1（例如 [B, T, 1, …]）。1 / True 表示有效位置，0 / False 表示填充位置。

• dim (tuple or int) – 要归约的一个或多个维度（例如，长度为 1）。

• run_count (float or torch.Tensor) – 到目前为止看到的样本的运行计数。

• run_mean (float or torch.Tensor) – 到目前为止看到的样本的运行均值。

• run_std (float or torch.Tensor) – 到目前为止看到的样本相对于均值的运行标准差。

返回:

• new_run_count (torch.Tensor) – 更新后的所有样本计数，现在包括 x。

• new_run_mean (torch.Tensor) – 更新后的所有样本的运行均值，现在包括 x。

• new_run_std (torch.Tensor) – 更新后的所有样本的运行标准差，现在包括 x。

示例

>>> input_tensor = torch.tensor([[-1.0, 0.0, 1.0, 0.0]])
>>> input_length = torch.tensor([0.75])
>>> input_length_dim = 1
>>> input_mask = make_padding_mask(input_tensor, input_length, input_length_dim)
>>> dim = (0, input_length_dim)
>>> run_count, run_mean, run_std = 0, torch.tensor(0.0), torch.tensor(1.0)
>>> run_count, run_mean, run_std = mean_std_update(
...     input_tensor, input_mask, dim, run_count, run_mean, run_std
... )
>>> run_count
3
>>> run_mean
tensor(0.)
>>> run_std
tensor(0.8165)

class speechbrain.processing.features.InputNormalization(mean_norm=True, std_norm=True, norm_type='global', avg_factor=None, length_dim=1, update_until_epoch=2, avoid_padding_norm=False, epsilon=1e-10, device='cpu')

基类：Module

对输入的时间维度和可能的 (全局) 批次维度执行均值和方差归一化。

当使用默认的 norm_type “global” 时，会计算并存储包含所有已见样本的运行均值和方差统计数据。

警告：起初，运行统计数据并不代表“真实”的均值和方差，而是基于迄今为止看到的数据进行的估计。一旦看到足够的数据，统计数据应能很好地近似“真实”值。

警告：使用全局归一化时，如果未执行任何更新（包括当前批次），首次调用 forward() 将引发错误，即首次调用时 epoch >= update_until_epoch 或模块首次在 .eval() 模式下被调用。

参数:

• mean_norm (bool, default True) – 如果为 True，则均值将被归一化。传递 False 已弃用。

• std_norm (bool, default True) – 如果为 True，则方差将被归一化。

• norm_type (str, default "global") –

  字符串参数，其值定义了如何计算统计数据

  • ’sentence’：按话语计算范数（无运行统计）

  • ’batch’：按输入张量计算范数（无运行统计）

  • ’global’：计算所有输入的范数（单个均值、方差）

  • ’speaker’ - 已弃用

• avg_factor (float, optional) – 传递 avg_factor 已弃用，因为这与 BatchNorm 的行为完全一致。要保持此行为，请使用 speechbrain.nnet.normalization.BatchNorm1d(momentum=avg_factor)。

• length_dim (int, default 1) – 用于屏蔽填充位置的维度。

• update_until_epoch (int, default 2) – 应停止更新范数统计数据的 epoch。默认情况下，在更新一个 epoch 后停止，因为当 epoch == update_until_epoch 时，更新会立即停止。

• avoid_padding_norm (bool, default False) – 无论此处传递的值如何，计算统计数据时都会忽略填充。但是，如果为 avoid_padding_norm 传递 False，填充将与输入张量的其余部分一起进行归一化。如果为 True，填充将不受此归一化操作的影响。

• epsilon (float, default 1e-10) – 一个用于提高方差数值稳定性的小值。

• device (str or torch.device) – 创建全局统计数据的设备。稍后可以使用 .to(device) 进行更改。

示例

>>> import torch
>>> inputs = torch.arange(9).view(3, 3).float()
>>> inputs
tensor([[0., 1., 2.],
        [3., 4., 5.],
        [6., 7., 8.]])
>>> input_lens = torch.ones(3)
>>> norm = InputNormalization(norm_type="sentence")
>>> features = norm(inputs, input_lens)
>>> features
tensor([[-1.2247,  0.0000,  1.2247],
        [-1.2247,  0.0000,  1.2247],
        [-1.2247,  0.0000,  1.2247]])
>>> norm = InputNormalization(norm_type="batch")
>>> features = norm(inputs, input_lens)
>>> features
tensor([[-1.5492, -1.1619, -0.7746],
        [-0.3873,  0.0000,  0.3873],
        [ 0.7746,  1.1619,  1.5492]])
>>> norm = InputNormalization(norm_type="global")
>>> features = norm(inputs, input_lens)
>>> features.mean() < 1e-7
tensor(True)
>>> features = norm(inputs + 1, input_lens)
>>> features.mean()
tensor(0.1901)
>>> features = norm(inputs, input_lens)
>>> features.mean()
tensor(-0.1270)
>>> features = norm(inputs - 1, input_lens)
>>> features.mean()
tensor(-0.3735)
>>> features = norm(inputs, input_lens)
>>> features.mean() < 1e-7
tensor(True)

Dict

的别名 Dict

spk_dict_mean: Dict[int, Tensor]

spk_dict_std: Dict[int, Tensor]

spk_dict_count: Dict[int, int]

NORM_TYPES = ('global', 'batch', 'sentence')

forward(x, lengths=None, epoch=None)

根据 norm_type 归一化输入张量 x。

通过使用传递的相对长度排除张量的填充部分。如果使用“global”或“speaker”范数，则自动更新运行均值、方差。

参数:

• x (torch.Tensor) – 要归一化的输入张量。

• lengths (torch.Tensor, optional) – 每个句子的相对长度（例如，[0.7, 0.9, 1.0]），用于避免在张量的填充部分计算统计数据。

• epoch (int, optional) – 当前 epoch 计数，用于在看到足够样本（例如一个 epoch）后停止更新全局统计数据。

返回:

x – 归一化后的张量。

返回类型:

torch.Tensor

to(device)

将所需张量放置到正确的设备上。

speechbrain.processing.features.make_padding_mask(x, lengths=None, length_dim=1, eps=1e-06)

根据给定维度上的相对长度创建遮罩。

参数:

• x (torch.Tensor) – 表示目标掩码大小的输入张量。

• lengths (torch.Tensor, optional) – 输入批次中每个话语的相对长度。如果为 None，则所有位置都被视为有效（即，掩码全部为 True）。

• length_dim (int, default 1) – 长度指示填充位置的维度。

• eps (float, default 1e-06) – 一个用于避免在计算填充掩码时出现浮点错误的微小常数。

返回:

padding_mask – 一个布尔张量，有效位置为 True，填充位置为 False。由于除长度和批量之外的所有维度都是单例维度，因此可以通过广播将 padding_mask 与 x 相乘。

返回类型:

torch.Tensor

示例

>>> input_tensor = torch.arange(3 * 4 * 2).view(3, 4, 2)
>>> lengths = torch.tensor([1.0, 0.75, 0.5])
>>> mask = make_padding_mask(input_tensor, lengths)
>>> mask.shape
torch.Size([3, 4, 1])
>>> input_tensor * mask
tensor([[[ 0,  1],
         [ 2,  3],
         [ 4,  5],
         [ 6,  7]],

        [[ 8,  9],
         [10, 11],
         [12, 13],
         [ 0,  0]],

        [[16, 17],
         [18, 19],
         [ 0,  0],
         [ 0,  0]]])

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

基类：Module

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

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

参数:

• norm_mean (float, default 0.0) – 期望的归一化均值

• norm_std (float, default 1.0) – 期望的归一化标准差

• update_steps (float, optional) – 将收集统计数据的步数

• length_dim (int, default 2) – 用于表示长度的维度

• mask_value (float, default 0.0) – 用于填充屏蔽位置的值，如果没有 mask_value，屏蔽位置将被归一化，这可能不是期望的行为

示例

>>> 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.2551, 0.5000, 0.7449]])
>>> x = torch.tensor([[5., 10., -4.]])
>>> x_norm = global_norm(x)
>>> x_norm
tensor([[0.6027, 0.8397, 0.1761]])
>>> 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.1054, -4.3740, -2.0041]])
>>> global_norm.denormalize(x_norm)
tensor([[ 5.0000, 10.0000, -4.0000]])
>>> global_norm.unfreeze()
>>> global_norm(x)
tensor([[ 5.1054, -4.3740, -2.0041]])
>>> global_norm.denormalize(x_norm)
tensor([[ 5.0000, 10.0000, -4.0000]])

forward(x, lengths=None, mask_value=None, skip_update=False)

归一化提供的张量

参数:

• x (torch.Tensor) – 要归一化的张量

• lengths (torch.Tensor, optional) – 相对长度张量（填充不计入归一化）

• mask_value (float, optional) – 用于屏蔽位置的值

• skip_update (bool, default False) – 是否跳过对范数的更新

返回:

result – 归一化后的张量

返回类型:

torch.Tensor

should_update()

是否执行更新。

normalize(x)

根据运行均值和标准差执行归一化操作

参数:

x (torch.Tensor) – 要归一化的张量

返回:

result – 归一化后的张量

返回类型:

torch.Tensor

denormalize(x)

反转归一化过程

参数:

x (torch.Tensor) – 归一化后的张量

返回:

result – x 的反归一化版本

返回类型:

torch.Tensor

freeze()

停止更新运行均值/标准差

unfreeze()

恢复更新运行均值/标准差

class speechbrain.processing.features.MinLevelNorm(min_level_db)

基类：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 的刻度上，范围的中心点为零。

参数:

min_level_db (float) – 最小级别

示例

>>> 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)

归一化分贝单位的音频特征（通常是频谱图）

参数:

x (torch.Tensor) – 输入特征

返回:

normalized_features – 归一化后的特征

返回类型:

torch.Tensor

denormalize(x)

反转最小级别归一化过程

参数:

x (torch.Tensor) – 归一化后的张量

返回:

result – 反归一化后的张量

返回类型:

torch.Tensor

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

基类：Module

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

参数:

• multiplier (float) – 乘数常数

• clip_val (float) – 最小接受值（低于此最小值的将被截断）

示例

>>> 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)

执行前向传递

参数:

x (torch.Tensor) – 源信号

返回:

result – 结果

返回类型:

torch.Tensor