语音数据增强及python实现

博客作者:凌逆战博客地址:https://www.cnblogs.com/LXP-Never/p/13404523.html音频时域波形具有以下特征:音调,响度,质量。我们在进行数据增强时,最好只
强烈推介IDEA2021.1.3破解激活,IntelliJ IDEA 注册码,2021.1.3IDEA 激活码  

博客作者:凌逆战

博客地址:https://www.cnblogs.com/LXP-Never/p/13404523.html


  音频时域波形具有以下特征:音调,响度,质量。我们在进行数据增强时,最好只做一些小改动,使得增强数据和源数据存在较小差异即可,切记不能改变原有数据的结构,不然将产生“脏数据”,通过对音频数据进行数据增强,能有助于我们的模型避免过度拟合并变得更加通用。

  我发现对声波的以下改变是有用的:Noise addition(增加噪音)、Add reverb增加混响)Time shifting(时移)Pitch shifting(改变音调)Time stretching(时间拉伸)

本章需要使用的python库:

  • matplotlib:绘制图像
  • librosa:音频数据处理
  • numpy:矩阵数据处理

常见的失真有:

  1. 加性声学噪声:加性噪声与期望信号不相干,平稳加性噪声(背景环境声音、嗡嗡声、功放噪音),非平稳加性噪声(媒体干扰、非期望语音干扰和一些电子干扰)
  2. 声学混响:多径反射引起的叠加效应(与期望信号相关)
  3. 卷积信道效应:导致不均匀或带宽限制响应,为了去除信道脉冲响应,做信道均衡时对通信信道没有有效建模
  4. 非线性失真:信号输入时不适当的增益,常出现与幅度限制、麦克风功放等
  5. 加性宽带电子噪声
  6. 电器干扰
  7. 编码失真:比如压缩编码
  8. 录音仪器引起的失真:麦克风频率响应不足

  使用先画出原始语音数据的语谱图和波形图

import librosa
import numpy as np
import matplotlib.pyplot as plt

plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示符号
fs = 16000

wav_data, _ = librosa.load("./p225_001.wav", sr=fs, mono=True)

# ########### 画图
plt.subplot(2, 2, 1)
plt.title("语谱图", fontsize=15)
plt.specgram(wav_data, Fs=16000, scale_by_freq=True, sides='default', cmap="jet")
plt.xlabel('秒/s', fontsize=15)
plt.ylabel('频率/Hz', fontsize=15)

plt.subplot(2, 2, 2)
plt.title("波形图", fontsize=15)
time = np.arange(0, len(wav_data)) * (1.0 / fs)
plt.plot(time, wav_data)
plt.xlabel('秒/s', fontsize=15)
plt.ylabel('振幅', fontsize=15)

plt.tight_layout()
plt.show()

只听到从山间传来架构君的声音:
芝为车,龙为马,览遨游,四海外。有谁来对上联或下联?

语音数据增强及python实现

时域增强

噪声增强

  本文添加的噪声为均值为0,标准差为1的高斯白噪声,有两种方法对数据进行加噪

第一种:控制噪声因子

此代码由Java架构师必看网-架构君整理
def add_noise1(x, w=0.004): # w:噪声因子 output = x + w * np.random.normal(loc=0, scale=1, size=len(x)) return output Augmentation = add_noise1(x=wav_data, w=0.004)

语音数据增强及python实现

第二种:控制信噪比

  通过信噪比的公式推导出噪声。

$$SNR=10*log_{10}(\frac{S^2}{N^2}) \Rightarrow k=\sqrt{\frac{S^2}{10^{\frac{SNR}{10}}}}$$

def add_noise2(x, snr):
    """
    :param x:纯净语音
    :param snr: 信噪比
    :return: 生成执行信噪比的带噪语音
    """
    P_signal = np.mean(x**2)    # 信号功率
    k = np.sqrt(P_signal / 10 ** (snr / 10.0))  # 噪声系数 k
    return x + np.random.randn(len(x)) * k

Augmentation = add_noise2(x=wav_data, snr=50)

语音数据增强及python实现

第三种:纯净语音+噪声(指定信噪比)

  通过信噪比的公式推导出噪声的增益系数k。

$$SNR=10*log_{10}(\frac{S^2}{N^2}) \Rightarrow k=\sqrt{\frac{S^2}{N^2*10^{\frac{SNR}{10}}}}$$

此代码由Java架构师必看网-架构君整理
def snr2noise(clean, noise, SNR): """ :param clean: 纯净语音 :param far_echo: 噪音 :param SER: 指定的SNR :return: 根据指定的SNR求带噪语音(纯净语音+噪声) """ p_clean = np.mean(clean ** 2) # 纯净语音功率 p_noise = np.mean(noise ** 2) # 噪声功率 scalar = np.sqrt(p_clean / (10 ** (SNR / 10)) / (p_noise + np.finfo(np.float32).eps)) noisy = clean + scalar * noise return noisy

第四种:制造鸡尾酒效应的带噪语音

  其实并没有那么玄乎,就是将纯净语音和多段带噪语音进行相加,然后控制一下信噪比。

音量增强

  语音音量的单位为dB,音量增益可以基于平均音量或者最大瞬时音量,下面公式是基于平均音量推得dB增益:

$$\left\{\begin{matrix}dB=10*log_{10}(S^2)\\\ S=kS\end{matrix}\right.\Rightarrow k=\sqrt{\frac{10^{\frac{dB}{10}}}{S^2}}$$

def dB_gain(wav, dB):
    """
    :param wav: 语音
    :param dB: 音量
    :return:返回以指定dB增益后的语音 
    """
    wav_p = np.mean(wav ** 2)  # 平均功率
    scalar = np.sqrt(10 ** (dB / 10) / (wav_p + np.finfo(np.float32).eps))
    wav *= scalar
    return wav, scalar

如果我们是想对带噪语音进行音量增益,为了不破坏带噪语音的信噪比,还需要对纯净语音语音进行相同的增益

noisy, noisy_scalar = dB_gain(noisy, 20)    # 得到增益后的带噪语音和增益系数
clean *= noisy_scalar    # 为了控制snr不变,clean需要进行相同的增益

混响增强

  我这里使用的是Image Source Method(镜像源方法)来实现语音加混响,我想用两种方法来给大家实现,第一种是直接调用python库—— Pyroomacoustics来实现音频加混响,第二种就是按照公式推导一步一步来实现,两种效果一样,想看细节的可以参考第二种方法,只想开始实现效果的可以只看第一种方法:

方法一: Pyroomacoustics实现音频加混响

  首先需要安装 Pyroomacoustics,这个库非常强大,感兴趣也可以多看看其他API接口

pip install  Pyroomacoustics

步骤:

  1. 创建房间(定义房间大小、所需的混响时间、墙面材料、允许的最大反射次数、)
  2. 在房间内创建信号源
  3. 在房间内放置麦克风
  4. 创建房间冲击响应
  5. 模拟声音传播
# Author:凌逆战
# -*- coding:utf-8 -*-
import pyroomacoustics as pra
import numpy as np
import matplotlib.pyplot as plt
import librosa

# 1、创建房间
# 所需的混响时间和房间的尺寸
rt60_tgt = 0.5  # 所需的混响时间,秒
room_dim = [9, 7.5, 3.5]  # 我们定义了一个9m x 7.5m x 3.5m的房间,米

# 我们可以使用Sabine’s公式来计算壁面能量吸收和达到预期混响时间所需的ISM的最大阶数(RT60,即RIR衰减60分贝所需的时间)
e_absorption, max_order = pra.inverse_sabine(rt60_tgt, room_dim)    # 返回 墙壁吸收的能量 和 允许的反射次数
# 我们还可以自定义 墙壁材料 和 最大反射次数
# m = pra.Material(energy_absorption="hard_surface")    # 定义 墙的材料,我们还可以定义不同墙面的的材料
# max_order = 3

room = pra.ShoeBox(room_dim, fs=16000, materials=pra.Material(e_absorption), max_order=max_order)

# 在房间内创建一个位于[2.5,3.73,1.76]的源,从0.3秒开始向仿真中发出wav文件的内容
audio, _ = librosa.load("speech.wav",sr=16000)  # 导入一个单通道语音作为源信号 source signal
room.add_source([2.5, 3.73, 1.76], signal=audio, delay=0.3)

# 3、在房间放置麦克风
# 定义麦克风的位置:(ndim, nmics) 即每个列包含一个麦克风的坐标
# 在这里我们创建一个带有两个麦克风的数组,
# 分别位于[6.3,4.87,1.2]和[6.3,4.93,1.2]。
mic_locs = np.c_[
    [6.3, 4.87, 1.2],  # mic 1
    [6.3, 4.93, 1.2],  # mic 2
]

room.add_microphone_array(mic_locs)     # 最后将麦克风阵列放在房间里

# 4、创建房间冲击响应(Room Impulse Response)
room.compute_rir()

# 5、模拟声音传播,每个源的信号将与相应的房间脉冲响应进行卷积。卷积的输出将在麦克风上求和。
room.simulate()

# 保存所有的信号到wav文件
room.mic_array.to_wav("./guitar_16k_reverb_ISM.wav", norm=True, bitdepth=np.float32,)

# 测量混响时间
rt60 = room.measure_rt60()
print("The desired RT60 was {}".format(rt60_tgt))
print("The measured RT60 is {}".format(rt60[1, 0]))


plt.figure()
# 绘制其中一个RIR. both can also be plotted using room.plot_rir()
rir_1_0 = room.rir[1][0]    # 画出 mic 1和 source 0 之间的 RIR
plt.subplot(2, 1, 1)
plt.plot(np.arange(len(rir_1_0)) / room.fs, rir_1_0)
plt.title("The RIR from source 0 to mic 1")
plt.xlabel("Time [s]")

# 绘制 microphone 1 处接收到的信号
plt.subplot(2, 1, 2)
plt.plot(np.arange(len(room.mic_array.signals[1, :])) / room.fs, room.mic_array.signals[1, :])
plt.title("Microphone 1 signal")
plt.xlabel("Time [s]")

plt.tight_layout()
plt.show()
语音数据增强及python实现
语音数据增强及python实现

room = pra.ShoeBox(
    room_dim,
    fs=16000,
    materials=pra.Material(e_absorption),
    max_order=3,
    ray_tracing=True,
    air_absorption=True,
)

# 激活射线追踪
room.set_ray_tracing()

混合ISM/射线跟踪房间模拟器

语音数据增强及python实现
语音数据增强及python实现

room.simulate(reference_mic=0, snr=10)      # 控制信噪比

控制信噪比

语音数据增强及python实现

语音数据增强及python实现

方法二:Image Source Method 算法讲解

  从这里要讲算法和原理了,

代码参考:matlab版本:RIR-Generator,python版本:rir-generator

镜像源法简介:

 语音数据增强及python实现

  将反射面等效为一个虚像,或者说镜像。比如说,在一个开放空间里有一面平整墙面,那么一个声源可以等效为2两个声源;一个开放空间里有两面垂直的平整墙面,那么一个声源可以等效为4个;同理三面的话是8个。原理上就是这样,但是封闭的三维空间里情况有那么点复杂,

  一般来说,家里的空房间可以一定程度上近似为矩形盒子,假设房间尺寸为:

$$L=\left[x_{r}, y_{r}, z_{r}\right]$$

元素大小分别代表长宽高,而声源的三维坐标为

$$S=\left[x_{s}, y_{s}, z_{s}\right]$$

麦克风的三维坐标为

$$M=\left[x_{m}, y_{m}, z_{m}\right]$$

镜像声源$(i,j,k)$到麦克风距离在三个坐标轴上的位置为

$$x_{i}=(-1)^{i} x_{s}+\left[i+\left(1-(-1)^{i}\right) / 2\right] x_{r}-x_{m}$$

$$y_{j}=(-1)^{j} y_{s}+\left[j+\left(1-(-1)^{j}\right) / 2\right] y_{r}-y_{m}$$

$$z_{k}=(-1)^{k} z_{s}+\left[k+\left(1-(-1)^{k}\right) / 2\right] z_{r}-z_{m}$$

那么声源$(i,j,k)$距离麦克风的距离为

$$d_{i j k}=\sqrt{\left(x_{i}^{2}+y_{j}^{2}+z_{k}^{2}\right)}$$

相对于直达声的到达延迟时间为

$$\tau_{i j k}=\left(d_{i j k}-r\right) / c$$

其中$c$为声速,$r$为声源到麦克风的直线距离。那么,混响效果等效为不同延迟的信号的叠加,即混响效果可以表示为一个FIR滤波器与信号源卷积的形式,此滤波器可写为如下形式

$$h(t)=\sum_{i} \sum_{j} \sum_{k}\left[A_{i j k} \delta\left(t-\tau_{i j k}\right)\right]$$

滤波器的抽头系数与镜面的反射系数与距离相关,如果每个面的反射系数不同则形式略复杂。详细代码还是要看RIR-Generator,我这里只做抛转引玉,写一个最简单的。

模拟镜像源:

房间尺寸(m):4 X 4 X 3

声源坐标(m):2 X 2 X 0

麦克风坐标(m):2 X 2 X 1.5

混响时间(s):0.2

RIR长度:512

语音数据增强及python实现
语音数据增强及python实现

clc;clear;
c = 340;                    % 声速 (m/s)
fs = 16000;                 % Sample frequency (samples/s)
r = [2 2 1.5];              % 麦克风位置 [x y z] (m)
s = [2 2 0];              % 扬声器位置 [x y z] (m)
L = [4 4 3];                % 房间大小 [x y z] (m)
beta = 0.2;                 % 混响时间 (s)
n = 512;                   % RIR长度

h = rir_generator(c, fs, r, s, L, beta, n);
disp(size(h))   % (1,4096)

[speech, fs] = audioread("./test_wav/p225_001.wav");
disp(size(speech)); % (46797,1)

y = conv(speech', h);
disp(length(y))


% 开始画图
figure('color','w');    % 背景色设置成白色
subplot(3,1,1)
plot(h)
title("房间冲击响应 RIR","FontSize",14)

subplot(3,2,3)
plot(speech)
title("原语音波形","FontSize",14)

subplot(3,2,4)
plot(y)
title("加混响语音波形","FontSize",14)

subplot(3,2,5)
specgram(speech,512,fs,512,256);
title("原语音频谱","FontSize",14)

subplot(3,2,6)
specgram(y,512,fs,512,256);
title("加混响语音频谱","FontSize",14)

audiowrite("./test_wav/matlab_p225_001_reverber.wav",y,fs)

Image Source方法

语音数据增强及python实现

gpuRIR:使用图像源方法(ISM)和GPU加速进行房间脉冲响应(RIR)模拟

一种专用于机器学习应用中音频数据增强的随机房间脉冲响应生成方法。与图像源或光线追踪等几何方法相反,这种技术不需要预先定义房间几何形状、吸收系数或麦克风和源位置,并且仅依赖于房间的声学参数。该方法直观、易于实施,并允许生成非常复杂的外壳的 RIR

基于神经网络的快速房间脉冲响应生成器

基于生成对抗网络 (GAN) 的房间脉冲响应发生器 (IR-GAN)

一种提高远场语音识别合成房间脉冲响应质量的方法

在房间脉冲响应 (RIR) 生成中加入以下因素的影响:空气吸收、真实材料的表面和频率相关系数以及随机光线追踪

指定SER生成远端语音

  SER的公式为

$$SER=10\log_{10}\frac{E\{s^2(n)\}}{E\{d^2(n)\}}$$

其中E是统计 期望操作,$s(n)$是近端语音,$d(n)$是远端回声,

  由于我们需要根据指定的SER求混响信号,并且近端语音和远端混响都是已知的,我们只需要求得一个系数,来调整回声信号的能量大小,与远端混响相乘即可得我们想要的混响语音,即调整后的回声信号为$kd(n)$

根据以上公式,可以推导出$k$的值

$$k=\sqrt{\frac{E\{s^2(n)\}}{E\{d^2(n)\}*10^{\frac{SER}{10}}}}$$

最终$kd(n)$即我们所求的指定SER的混响。

def add_echo_ser(near_speech, far_echo, SER):
    """根据指定的SER求回声
    :param near_speech: 近端语音
    :param far_echo: 远端回声
    :param SER: 指定的SER
    :return: 指定SER的回声
    """
    p_near_speech = np.mean(near_speech ** 2)  # 近端语音功率
    p_far_echo = np.mean(far_echo ** 2)  # 远端回声功率

    k = np.sqrt(p_near_speech / (10 ** (SER / 10)) / p_far_echo)

    return k * far_echo

语音数据增强及python实现

 

波形位移

  语音波形移动使用numpy.roll函数向右移动shift距离

numpy.roll(a, shift, axis=None)

参数

  • a:数组
  • shift:滚动的长度
  • axis:滚动的维度。0为垂直滚动,1为水平滚动,参数为None时,会先将数组扁平化,进行滚动操作后,恢复原始形状
x = np.arange(10)
# array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

print(np.roll(x, 2))
# array([8, 9, 0, 1, 2, 3, 4, 5, 6, 7])

波形位移函数:

def time_shift(x, shift):
    # shift:移动的长度
    return np.roll(x, int(shift))

Augmentation = time_shift(wav_data, shift=fs//2)

语音数据增强及python实现

谐波失真

import soundpy

y1 = sp.augment.harmonic_distortion(y, sr=sr)

语音数据增强及python实现

 

重采样数据增强

  重采样后语音数据会丢失 重采样采样率到源采样值之间的频谱信息。

def augment_resample(wav, sr):
    resample_sr = np.random.uniform(sr)     # 从一个均匀分布中随机采样
    print("target_sr", resample_sr)
    resample = librosa.resample(wav, orig_sr=sr, target_sr=resample_sr)
    resample = librosa.resample(resample, orig_sr=resample_sr, target_sr=sr)
    return resample

语音数据增强及python实现

编解码数据增强

  这个我有空再来补全,参考DeepSpeech,先numpu to pcm,在转成 opus。

频域增强

音高增强(Pitch Shifting)

  在频率轴上缩放频谱图,从而改变音高。音高修正只改变音高而不影响音速,我发现-5到5之间的步数更合适

def pitch_shifting(x, sr, n_steps, bins_per_octave=12):
    # sr: 音频采样率
    # n_steps: 要移动多少步
    # bins_per_octave: 每个八度音阶(半音)多少步
    return librosa.effects.pitch_shift(x, sr, n_steps, bins_per_octave=bins_per_octave)

# 上移大三度(如果bins_per_octave为12,则4步)
Augmentation = pitch_shifting(wav_data, sr=fs, n_steps=4, bins_per_octave=12)
# 向下移动一个三全音(如果bins_per_octave是 12,则为六步)
Augmentation = pitch_shifting(wav_data, sr=fs, n_steps=-6, bins_per_octave=12)
# 上移 3 个四分音符
y_three_qt = librosa.effects.pitch_shift(y, sr, n_steps=3, bins_per_octave=24)

语音数据增强及python实现

速度增强(Tempo)

在时间轴上缩放频谱图,从而改变播放速度。

变速不变调

方法一:ffmpeg

  在变速之前我们需要安装 pip install ffmpeg  

from ffmpeg import audio

# 加快2倍速度
audio.a_speed("./sample/p225_001.wav",speed=2,out_file="./sample/p225_001_2.wav")

# 放慢2倍速度
audio.a_speed("./sample/p225_001.wav",speed=0.5,out_file="./sample/p225_001_0.5.wav")

ffmpeg是基于fmpeg开发的,Python的这个库不能加载太大的文件,但是原生的fmpeg。或者我们可以直接使用原生的ffmpeg工具包

语音数据增强及python实现

我们可以看到变速前后的波形图和语谱图没变,但是他们的时间维度却减少了一半。

方法二:SoundTorch

  SoundTouch 是一个开源音频处理库,用于更改音频流或音频文件的速度、音高和播放速率。该库还支持估计音轨的稳定每分钟节拍率。

命令实例见:https://www.surina.net/soundtouch/soundstretch.html

速度增加100%

soundstretch input.wav output.wav -tempo=100

速度降低50%

soundstretch input.wav output.wav -tempo=-50

语音数据增强及python实现

变速变调

方法一:SOX

  需要在linux上运行,具体参考https://github.com/rabitt/pysox

import soundfile
import sox

sr = 16000

tfm = sox.Transformer()     # create transformer
tfm.speed(2)                # 变速2倍

# 创建输出文件
# tfm.build_file("./sample/p225_001.wav", "./sample/pysox_2x.wav")

# 内存中以numpy数组的形式获取输出
array_out = tfm.build_array(input_filepath="./sample/p225_001.wav")
soundfile.write("./sample/pysox_2x.wav",data=array_out,samplerate=sr)

或者我们直接使用原生的sox工具包

$ sox input.wav output.wav speed 1.3 #速度变为原来的1.3倍
$ sox input.wav output.wav speed 0.8 #速度变为原来的0.8倍

语音数据增强及python实现

方法二:librosa

  按固定速率对音频系列进行时间拉伸。

def time_stretch(x, rate):
    # rate:拉伸的尺寸,
    # rate > 1 加快速度
    # rate < 1 放慢速度
    return librosa.effects.time_stretch(x, rate)

Augmentation = time_stretch(wav_data, rate=2)

语音数据增强及python实现

  我们来观察语谱图和波形图,发现形状变了,并且变速后的语音波形振幅降低了,为什么呢?难道变速还会减少语音的音量?求解答


  SpecAugment 通过在时间方向上通过在时间方向上扭曲来增强,并屏蔽(多个)连续时间步长(垂直掩模)和 mel 频率通道(水平掩模)的块

  1. 帮助网络在时间方向上的变形、频率信息的部分丢失和输入的小段语音的部分丢失方面具有鲁棒性
  2. 防止网络过度拟合

SpecAugment 中有三种增强策略:

  • 时间扭曲(Time Warping):在时间轴上随机扭曲频谱图。与速度扰动不同,这种方法不会增加或减少持续时间,而是在局部压缩和拉伸频谱图。
  • 频率掩蔽(Frequency Mask):频谱图的 连续频率bin被随机掩蔽
  • 时间掩蔽(Time Mask):频谱图的 连续时间帧被掩蔽

语音数据增强及python实现

paperwithcode:SpecAugment几乎所有的代码都列出来了

扭曲增强(Warp)

  将非线性图像扭曲应用于频谱图。这是通过沿时间和频率轴随机移动均匀分布的扭曲点网格来实现的。代码修改自:DeepSpeech

def tf_pick_value_from_range(value, r, clock=None, double_precision=False):
    clock = (tf.random.stateless_uniform([], seed=(-1, 1), dtype=tf.float64) if clock is None
             else tf.maximum(tf.constant(0.0, dtype=tf.float64), tf.minimum(tf.constant(1.0, dtype=tf.float64), clock)))
    value = tf.random.stateless_uniform([],
                                        minval=value - r,
                                        maxval=value + r,
                                        seed=(clock * tf.int32.min, clock * tf.int32.max),
                                        dtype=tf.float64)
    if isinstance(value, int):
        return tf.cast(tf.math.round(value), tf.int64 if double_precision else tf.int32)
    return tf.cast(value, tf.float64 if double_precision else tf.float32)


def Warp(spectrogram, num_t=1, num_f=1, warp_t=0.1, warp_f=0.0, r=0, clock=0.0):
    """
    :param spectrogram: tensor (batch size,t,f)
    :param num_t: 
    :param num_f: 
    :param warp_t: 
    :param warp_f: 
    :param r: 波动范围
    :param clock: 
    :return: 
    """
    size_t, size_f = spectrogram.shape

    seed = (clock * tf.int32.min, clock * tf.int32.max)

    num_t = tf_pick_value_from_range(num_t, r, clock=clock)
    num_f = tf_pick_value_from_range(num_f, r, clock=clock)

    def get_flows(n, size, warp, r):
        warp = tf_pick_value_from_range(warp, range, clock=clock)
        warp = warp * tf.cast(size, dtype=tf.float32) / tf.cast(2 * (n + 1), dtype=tf.float32)
        f = tf.random.stateless_normal([num_t, num_f], seed, mean=0.0, stddev=warp, dtype=tf.float32)
        return tf.pad(f, tf.constant([[1, 1], [1, 1]]), 'CONSTANT')  # zero flow at all edges

    flows = tf.stack([get_flows(num_t, size_t, warp_t, r), get_flows(num_f, size_f, warp_f, r)], axis=2)
    flows = tf.image.resize_bicubic(tf.expand_dims(flows, 0), [size_t, size_f])
    spectrogram_aug = tf.contrib.image.dense_image_warp(tf.expand_dims(spectrogram, -1), flows)
    spectrogram_aug = tf.reshape(spectrogram_aug, shape=(1, -1, size_f))
    return spectrogram_aug

频率掩膜增强(Frequency Mask)

在随机频率下将增强样本中的频率间隔设置为零(静音)。有关更多详细信息,请参阅 SpecAugment 论文 - https://arxiv.org/abs/1904.08779

def tf_pick_value_from_range(value, r, clock=None, double_precision=False):
    clock = (tf.random.stateless_uniform([], seed=(-1, 1), dtype=tf.float64) if clock is None
             else tf.maximum(tf.constant(0.0, dtype=tf.float64), tf.minimum(tf.constant(1.0, dtype=tf.float64), clock)))
    value = tf.random.stateless_uniform([],
                                        minval=value - r,
                                        maxval=value + r,
                                        seed=(clock * tf.int32.min, clock * tf.int32.max),
                                        dtype=tf.float64)
    if isinstance(value, int):
        return tf.cast(tf.math.round(value), tf.int64 if double_precision else tf.int32)
    return tf.cast(value, tf.float64 if double_precision else tf.float32)


def FrequencyMask(tensor, n=3, size=2, r=0, transcript=None, clock=0.0):
    time_max = tf.shape(tensor)[1]
    freq_max = tf.shape(tensor)[2]
    n = tf_pick_value_from_range(n, r, clock=clock)

    def body(i, size, spectrogram_aug):
        size = tf_pick_value_from_range(size, r, clock=clock)
        size = tf.math.maximum(1, tf.math.minimum(freq_max - 1, size))
        seed = tf.cast(clock * tf.int32.max, tf.int32) - i
        f0 = tf.random.stateless_uniform((), (-seed, seed), minval=0, maxval=freq_max - size, dtype=tf.dtypes.int32)
        freq_mask = tf.concat([tf.ones([1, time_max, f0]),
                               tf.zeros([1, time_max, size]),
                               tf.ones([1, time_max, freq_max - f0 - size])], axis=2)
        return i + 1, spectrogram_aug * freq_mask

    return tf.while_loop(lambda i, size, spectrogram_aug: i < n, body, (0, tensor))[1]

时间掩码增强(Time Mask)

在随机位置将增强样本内的时间间隔设置为零(静音)。代码修改自:DeepSpeech

def tf_pick_value_from_range(value, r, clock=None, double_precision=False):
    clock = (tf.random.stateless_uniform([], seed=(-1, 1), dtype=tf.float64) if clock is None
             else tf.maximum(tf.constant(0.0, dtype=tf.float64), tf.minimum(tf.constant(1.0, dtype=tf.float64), clock)))
    value = tf.random.stateless_uniform([],
                                        minval=value - r,
                                        maxval=value + r,
                                        seed=(clock * tf.int32.min, clock * tf.int32.max),
                                        dtype=tf.float64)
    if isinstance(value, int):
        return tf.cast(tf.math.round(value), tf.int64 if double_precision else tf.int32)
    return tf.cast(value, tf.float64 if double_precision else tf.float32)


def TimeMask(self, tensor, n=3, size=10.0, r=0, transcript=None, clock=0.0):
    time_max = tf.shape(tensor)[0 if self.domain == 'signal' else 1]
    n = tf_pick_value_from_range(n, r, clock=clock)

    def body(i, size, augmented):
        size = tf.cast(tf_pick_value_from_range(size, r, clock=clock) * self.units_per_ms(), dtype=tf.int32)
        size = tf.math.maximum(1, tf.math.minimum(time_max - 1, size))
        seed = tf.cast(clock * tf.int32.max, tf.int32) - i
        t0 = tf.random.stateless_uniform((), (-seed, seed), minval=0, maxval=time_max - size, dtype=tf.dtypes.int32)
        rest = time_max - t0 - size
        if self.domain == 'spectrogram':
            fm = tf.shape(tensor)[2]
            time_mask = tf.concat([tf.ones([1, t0, fm]), tf.zeros([1, size, fm]), tf.ones([1, rest, fm])], axis=1)
        elif self.domain == 'signal':
            time_mask = tf.concat([tf.ones([t0, 1]), tf.zeros([size, 1]), tf.ones([rest, 1])], axis=0)
        else:
            time_mask = tf.concat([tf.ones([1, t0]), tf.zeros([1, size]), tf.ones([1, rest])], axis=1)
        return i + 1, augmented * time_mask

    return tf.while_loop(lambda i, size, augmented: i < n, body, (0, tensor))[1]

频谱交换(SpecSwap)

X. Song, Z. Wu, Y. Huang, D. Su, and H. Meng, "SpecSwap: A Simple Data Augmentation Method for End-to-End Speech Recognition", in INTERSPEECH, 2020.

频谱交换提供两个增强策略:

  • 频率交换:随机交换频谱图的两个频率块
  • 时间交换:在时间轴上随机交换频谱图的两个帧块

SpecSwap 增强策略在 E2E ASR 模型中也运行良好,但缺乏与 SpecAugment 的比较。

多领域增强

drop增强

  将目标数据表示的随机数据点归零。代码修改自:DeepSpeech

def tf_pick_value_from_range(value, r, clock=None, double_precision=False):
    clock = (tf.random.stateless_uniform([], seed=(-1, 1), dtype=tf.float64) if clock is None
             else tf.maximum(tf.constant(0.0, dtype=tf.float64), tf.minimum(tf.constant(1.0, dtype=tf.float64), clock)))
    value = tf.random.stateless_uniform([],
                                        minval=value - r,
                                        maxval=value + r,
                                        seed=(clock * tf.int32.min, clock * tf.int32.max),
                                        dtype=tf.float64)
    if isinstance(value, int):
        return tf.cast(tf.math.round(value), tf.int64 if double_precision else tf.int32)
    return tf.cast(value, tf.float64 if double_precision else tf.float32)


def Dropout(tensor, rate=0.05, r=0, transcript=None, clock=0.0):
    rate = tf_pick_value_from_range(rate, r, clock=clock)
    rate = tf.math.maximum(0.0, rate)
    factors = tf.random.stateless_uniform(tf.shape(tensor),
                                          (clock * tf.int32.min, clock * tf.int32.max),
                                          minval=0.0,
                                          maxval=1.0,
                                          dtype=tf.float32)
    return tensor * tf.math.sign(tf.math.floor(factors + rate))

添加增强

将从正态分布(均值为 0.0)中选取的随机值添加到目标数据表示的所有数据点。代码修改自:DeepSpeech

def tf_pick_value_from_range(value, r, clock=None, double_precision=False):
    clock = (tf.random.stateless_uniform([], seed=(-1, 1), dtype=tf.float64) if clock is None
             else tf.maximum(tf.constant(0.0, dtype=tf.float64), tf.minimum(tf.constant(1.0, dtype=tf.float64), clock)))
    value = tf.random.stateless_uniform([],
                                        minval=value - r,
                                        maxval=value + r,
                                        seed=(clock * tf.int32.min, clock * tf.int32.max),
                                        dtype=tf.float64)
    if isinstance(value, int):
        return tf.cast(tf.math.round(value), tf.int64 if double_precision else tf.int32)
    return tf.cast(value, tf.float64 if double_precision else tf.float32)


def Add(tensor, stddev=5, r=0, transcript=None, clock=0.0):
    stddev = tf_pick_value_from_range(stddev, r, clock=clock)
    seed = (clock * tf.int32.min, clock * tf.int32.max)
    return tensor + tf.random.stateless_normal(tf.shape(tensor), seed, mean=0.0, stddev=stddev)

乘法增强

将目标数据表示的所有数据点与从正态分布(均值为 1.0)中选取的随机值相乘。代码修改自:DeepSpeech

def tf_pick_value_from_range(value, r, clock=None, double_precision=False):
    clock = (tf.random.stateless_uniform([], seed=(-1, 1), dtype=tf.float64) if clock is None
             else tf.maximum(tf.constant(0.0, dtype=tf.float64), tf.minimum(tf.constant(1.0, dtype=tf.float64), clock)))
    value = tf.random.stateless_uniform([],
                                        minval=value - r,
                                        maxval=value + r,
                                        seed=(clock * tf.int32.min, clock * tf.int32.max),
                                        dtype=tf.float64)
    if isinstance(value, int):
        return tf.cast(tf.math.round(value), tf.int64 if double_precision else tf.int32)
    return tf.cast(value, tf.float64 if double_precision else tf.float32)


def Multiply(self, tensor, stddev=5, r=0, transcript=None, clock=0.0):
    stddev = tf_pick_value_from_range(stddev, r=0, clock=clock)
    seed = (clock * tf.int32.min, clock * tf.int32.max)
    return tensor * tf.random.stateless_normal(tf.shape(tensor), seed, mean=1.0, stddev=stddev)

参考

【python 音频处理库】

【知乎文章】简单地为语音加混响

【国际音频实验室EmanuëlHabets提供的代码】International Audio Laboratories Erlangen

【Image-source method】Image-source method for room acoustics

【Image-source 原理讲解】Image-source Model

【CSDN】变速变调原理与方法总结

【CSDN】音频倍速(变速不变调)的实现

【CSDN】音频变调算法小结

【CSDN】python 音频变调不变速方法

【论文】用于语音识别的音频增强

【论文】SpecAugment:一种简单的自动语音识别数据增强方法

【CSDN】SoX 音频处理工具使用方法

还有写没有跑通,但是总感觉有些价值的代码,记录在这里:

  • py-RIR-Generator(没跑通的原因是我是window系统)
  • gpuRIR(这个我跑通了,但是需要较大的计算资源)
  • 去github找代码的时候,不一定要搜索“回声”,“混响”,也可以通过搜索"RIR"同样可以得到想要的结果

本文画图代码:

语音数据增强及python实现
语音数据增强及python实现

# Author:凌逆战
# -*- coding:utf-8 -*-
import matplotlib.pyplot as plt
import librosa
import numpy as np

plt.rcParams['font.sans-serif']=['SimHei'] #用来正常显示中文标签
plt.rcParams['axes.unicode_minus']=False #用来正常显示符号


y1, _ = librosa.load("./speech.wav", sr=16000)
y2, _ = librosa.load("./guitar_16k_reverb_ISM.wav", sr=16000)


plt.subplot(2, 2, 1)
plt.specgram(y1, Fs=16000, scale_by_freq=True, sides='default', cmap="jet")
plt.title("语谱图", fontsize=13)
plt.xlabel('时间/s', fontsize=13)
plt.ylabel('频率/Hz', fontsize=13)

plt.subplot(2, 2, 2)
plt.plot(np.arange(len(y1)) / 16000, y1)
plt.title("波形图", fontsize=13)
plt.xlabel('时间/s', fontsize=13)
plt.ylabel('振幅', fontsize=13)

plt.subplot(2, 2, 3)
plt.specgram(y2, Fs=16000, scale_by_freq=True, sides='default', cmap="jet")
plt.title("语谱图(加混响)", fontsize=13)
plt.xlabel('时间/s', fontsize=13)
plt.ylabel('频率/Hz', fontsize=13)


plt.subplot(2, 2, 4)
plt.plot(np.arange(len(y2)) / 16000, y2)
plt.title("波形图(加混响)", fontsize=13)
plt.xlabel('时间/s', fontsize=13)
plt.ylabel('振幅', fontsize=13)

plt.tight_layout()
plt.show()

View Code

[1] J,B. Allen and D. A. Berkley, Image method for efficiently simulating small-room acoustics, J. Acoust. Soc. Am., vol. 65, no. 4, p. 943, 1979.

[2] M, Vorlaender, Auralization, 1st ed. Berlin: Springer-Verlag, 2008, pp. 1-340.

[3] D.Schroeder, Physically based real-time auralization of interactive virtual environments. PhD Thesis, RWTH Aachen University, 2011.

架构君码字不易,如需转载,请注明出处:https://javajgs.com/archives/42203
0

发表评论