语音数据增强及python实现

本兵發表於 2020-10-2 22:05:00

博客作者：凌逆战
博客地址：https://www.cnblogs.com/LXP-Never/p/13404523.html
<hr>
　　音频时域波形具有以下特征：音调，响度，质量。我们在进行数据增强时，最好只做一些小改动，使得增强数据和源数据存在较小差异即可，切记不能改变原有数据的结构，不然将产生“脏数据”，通过对音频数据进行数据增强，能有助于我们的模型避免过度拟合并变得更加通用。
　　我发现对声波的以下改变是有用的：Noise addition（增加噪音）、Add reverb（增加混响）、Time shifting（时移）、Pitch shifting（改变音调）和Time stretching（时间拉伸）。
本章需要使用的python库：
<ul>
<li>matplotlib：绘制图像</li>
<li>librosa：音频数据处理</li>
<li>numpy：矩阵数据处理</li>
</ul>
常见的失真有：
<ol>
<li>加性声学噪声：加性噪声与期望信号不相干，平稳加性噪声(背景环境声音、嗡嗡声、功放噪音)，非平稳加性噪声(媒体干扰、非期望语音干扰和一些电子干扰)</li>
<li>声学混响：多径反射引起的叠加效应(与期望信号相关)</li>
<li>卷积信道效应：导致不均匀或带宽限制响应，为了去除信道脉冲响应，做信道均衡时对通信信道没有有效建模</li>
<li>非线性失真：信号输入时不适当的增益，常出现与幅度限制、麦克风功放等</li>
<li>加性宽带电子噪声</li>
<li>电器干扰</li>
<li>编码失真：比如压缩编码</li>
<li>录音仪器引起的失真：麦克风频率响应不足</li>
</ol><hr>
　　使用先画出原始语音数据的语谱图和波形图
<div class="cnblogs_code">
<pre>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()</pre>
</div>
<img src="https://img2020.cnblogs.com/blog/1433301/202010/1433301-20201002213623124-2103237528.png" alt="" width="484" height="203" loading="lazy">
<h1>时域增强</h1>
<h2>噪声增强</h2>
　　通过信噪比的公式推导出噪声的增益系数k。
$$SNR=10*log_{10}(\frac{S^2}{(kN)^2}) \Rightarrow k=\sqrt{\frac{S^2}{N^2*10^{\frac{SNR}{10}}}}$$
<div class="cnblogs_code">
<pre>def snr_aug_changeNoise(clean, noise, snr):
""" 保持语音不变，改变噪声的幅度
snr = 10 * log10(signal_power / k*noise_power) """
p_clean = np.mean(clean ** 2)# 纯净语音功率
p_noise = np.mean(noise ** 2)# 噪声功率
noise_scale = np.sqrt(p_clean / (p_noise * 10 ** (snr / 10) + EPS))
noisy = clean + noise_scale * noise
return noisy, noise_scale

def snr_aug_changeClean(clean, noise, snr):
""" 保持噪声不变，改变语音的幅度
snr = 10 * log10(k*signal_power/ noise_power)"""
clean_power = np.mean(clean ** 2)
noise_power = np.mean(noise ** 2)
clean_scale = np.sqrt(noise_power * 10 ** (snr / 10) / (clean_power + 1e-8))
noisy = clean * clean_scale + noise

return noisy, clean_scale</pre>
</div>
<img src="https://img2020.cnblogs.com/blog/1433301/202010/1433301-20201002213835250-938287616.png" alt="" width="437" height="322" loading="lazy" style="display: block; margin-left: auto; margin-right: auto">
<h2>音量增强</h2>
　　语音音量的单位为dB，音量增益可以基于平均音量或者最大瞬时音量，下面公式是基于平均音量推得dB增益：
$$dB=10*log_{10}(kS)^2\Rightarrow k=\sqrt{\frac{10^{\frac{dB}{10}}}{S^2}}$$
<div class="cnblogs_code">
<pre>def volumeAument1(wav, dB):
"""
:param wav: 语音
:param dB: 音量
:return:返回以指定dB增益后的语音
"""
power = np.mean(wav ** 2)# 平均功率
scalar = np.sqrt(10 ** (dB / 10) / (power + np.finfo(np.float32).eps))
wav *= scalar
return wav, scalar</pre>
</div>
$$dB=20*log_{10}kS\Rightarrow k=\frac{10^{\frac{db}{20}}}{A}$$
<div class="cnblogs_code">
<pre>def volumeAument2(wav, dB):
"""
:param wav: 语音
:param dB: 音量
:return:返回以指定dB增益后的语音
"""
rmswav = (wav ** 2).mean() ** 0.5
scalar = 10 ** (dB / 20) / (rmswav + np.finfo(np.float32).eps)
wav = wav * scalar
return wav, scalar</pre>
</div>
其实这两个函数都可以，都可以达到目的，本质上都一样。
<div class="cnblogs_code"><img src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" id="code_img_closed_b1eb73c6-21dd-448f-9a7a-b8f35ef98da2" class="code_img_closed"><img src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" id="code_img_opened_b1eb73c6-21dd-448f-9a7a-b8f35ef98da2" class="code_img_opened" style="display: none">
<div id="cnblogs_code_open_b1eb73c6-21dd-448f-9a7a-b8f35ef98da2" class="cnblogs_code_hide">
<pre># -*- coding:utf-8 -*-
# Author:凌逆战 | Never
# Date: 2023/3/17
"""
音量增强
"""
import numpy as np
import librosa

EPS = np.finfo(float).eps

def mean_dbfs(sample_data):
rms = np.sqrt(np.mean(np.square(sample_data, dtype=np.float64)))
dbfs = 20.0 * np.log10(max(1e-16, rms))
return dbfs

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

def volumeAument2(wav, dB):
"""
:param wav: 语音
:param dB: 音量
:return:返回以指定dB增益后的语音
"""
rmswav = (wav ** 2).mean() ** 0.5
scalar = 10 ** (dB / 20) / (rmswav + np.finfo(np.float32).eps)
wav = wav * scalar
return wav, scalar

sr = 16000
wav = librosa.load("./wavdata/TIMIT.WAV", sr=sr)# (46797,)
print(wav.shape)
wav, scalar = volumeAument1(wav, dB=15)
print(mean_dbfs(wav))# 18.0103004778581

wav, scalar = volumeAument2(wav, 15)
print(mean_dbfs(wav))# 18.010299731550788</pre>
</div>
View Code</div>
另外，如果我们是想对带噪语音进行音量增益，为了不破坏带噪语音的信噪比，还需要对纯净语音语音进行相同的增益
<div class="cnblogs_code">
<pre>noisy, noisy_scalar = dB_gain(noisy, 20) # 得到增益后的带噪语音和增益系数
clean *= noisy_scalar # 为了控制snr不变，clean需要进行相同的增益</pre>
</div>
<h2>混响增强</h2>
　　我这里使用的是Image Source Method（镜像源方法）来实现语音加混响，我想用两种方法来给大家实现，第一种是直接调用python库—— Pyroomacoustics来实现音频加混响，第二种就是按照公式推导一步一步来实现，两种效果一样，想看细节的可以参考第二种方法，只想开始实现效果的可以只看第一种方法：
<h3>方法一： Pyroomacoustics实现音频加混响</h3>
　　首先需要安装 Pyroomacoustics，这个库非常强大，感兴趣也可以多看看其他API接口
<div class="cnblogs_code">
<pre>pip installPyroomacoustics</pre>
</div>
步骤：
<ol>
<li>创建房间（定义房间大小、所需的混响时间、墙面材料、允许的最大反射次数、）</li>
<li>在房间内创建信号源</li>
<li>在房间内放置麦克风</li>
<li>创建房间冲击响应</li>
<li>模拟声音传播</li>
</ol>
<div class="cnblogs_code">
<pre># 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 = # 我们定义了一个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)

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

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

plt.figure()
# 绘制其中一个RIR. both can also be plotted using room.plot_rir()
rir_1_0 = room.rir # 画出 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 ")

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

plt.tight_layout()
plt.show()</pre>
</div>
<div class="cnblogs_code"><img src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" id="code_img_closed_cf97e841-c7fd-47bb-93eb-f33a2c705ef3" class="code_img_closed"><img src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" id="code_img_opened_cf97e841-c7fd-47bb-93eb-f33a2c705ef3" class="code_img_opened" style="display: none">
<div id="cnblogs_code_open_cf97e841-c7fd-47bb-93eb-f33a2c705ef3" class="cnblogs_code_hide">
<pre>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()</pre>
</div>
混合ISM/射线跟踪房间模拟器</div>
<div class="cnblogs_code"><img src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" id="code_img_closed_4e4cd141-2352-4c54-bf84-752d6b12370f" class="code_img_closed"><img src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" id="code_img_opened_4e4cd141-2352-4c54-bf84-752d6b12370f" class="code_img_opened" style="display: none">
<div id="cnblogs_code_open_4e4cd141-2352-4c54-bf84-752d6b12370f" class="cnblogs_code_hide">
<pre>room.simulate(reference_mic=0, snr=10) # 控制信噪比</pre>
</div>
控制信噪比</div>
<img src="https://img2020.cnblogs.com/blog/1433301/202012/1433301-20201231114906950-1280504017.png" alt="" loading="lazy" style="display: block; margin-left: auto; margin-right: auto">
<img src="https://img2020.cnblogs.com/blog/1433301/202012/1433301-20201231114801743-1598415517.png" alt="" width="535" height="394" loading="lazy" style="display: block; margin-left: auto; margin-right: auto">
<h3>方法二：Image Source Method 算法讲解</h3>
　　从这里要讲算法和原理了，
代码参考：matlab版本：RIR-Generator，python版本：rir-generator
镜像源法简介：
 <img src="https://img2020.cnblogs.com/blog/1433301/202101/1433301-20210105114728229-1383941046.png" alt="" loading="lazy">
　　将反射面等效为一个虚像，或者说镜像。比如说，在一个开放空间里有一面平整墙面，那么一个声源可以等效为2两个声源；一个开放空间里有两面垂直的平整墙面，那么一个声源可以等效为4个；同理三面的话是8个。原理上就是这样，但是封闭的三维空间里情况有那么点复杂，
　　一般来说，家里的空房间可以一定程度上近似为矩形盒子，假设房间尺寸为：
$$L=\left$$
元素大小分别代表长宽高，而声源的三维坐标为
$$S=\left$$
麦克风的三维坐标为
$$M=\left$$
镜像声源$(i,j,k)$到麦克风距离在三个坐标轴上的位置为
$$x_{i}=(-1)^{i} x_{s}+\left x_{r}-x_{m}$$
$$y_{j}=(-1)^{j} y_{s}+\left y_{r}-y_{m}$$
$$z_{k}=(-1)^{k} z_{s}+\left 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$$
滤波器的抽头系数与镜面的反射系数与距离相关，如果每个面的反射系数不同则形式略复杂。详细代码还是要看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
<div class="cnblogs_code"><img src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" id="code_img_closed_620392c2-e038-4d0b-b378-234e09ca8499" class="code_img_closed"><img src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" id="code_img_opened_620392c2-e038-4d0b-b378-234e09ca8499" class="code_img_opened" style="display: none">
<div id="cnblogs_code_open_620392c2-e038-4d0b-b378-234e09ca8499" class="cnblogs_code_hide">
<pre>clc;clear;
c = 340; % 声速 (m/s)
fs = 16000; % Sample frequency (samples/s)
r = [2 2 1.5]; % 麦克风位置 (m)
s = [2 2 0]; % 扬声器位置 (m)
L = [4 4 3]; % 房间大小 (m)
beta = 0.2; % 混响时间 (s)
n = 512; % RIR长度

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

= 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)</pre>
</div>
Image Source方法</div>
<img src="https://img2020.cnblogs.com/blog/1433301/202103/1433301-20210326180655255-1618003965.png" alt="" width="635" height="450" loading="lazy" style="display: block; margin-left: auto; margin-right: auto">
gpuRIR：使用图像源方法(ISM)和GPU加速进行房间脉冲响应(RIR)模拟
<ul>
<li class="title mathjax">【论文】gpuRIR: 基于GPU加速的房间脉冲响应仿真的Python库</li>
<li class="title mathjax">【代码】https://github.com/DavidDiazGuerra/gpuRIR</li>
</ul>
一种专用于机器学习应用中音频数据增强的随机房间脉冲响应生成方法。与图像源或光线追踪等几何方法相反，这种技术不需要预先定义房间几何形状、吸收系数或麦克风和源位置，并且仅依赖于房间的声学参数。该方法直观、易于实施，并允许生成非常复杂的外壳的 RIR
<ul>
<li class="title mathjax">【论文】StoRIR: 用于音频数据增强的随机房间脉冲响应生成</li>
<li class="title mathjax">【代码】https://github.com/SRPOL-AUI/storir</li>
</ul>
基于神经网络的快速房间脉冲响应生成器
<ul>
<li>【论文】FAST-RIR: 快速神经扩散房间脉冲响应发生器</li>
<li>【代码】https://github.com/anton-jeran/FAST-RIR</li>
</ul>
基于生成对抗网络 (GAN) 的房间脉冲响应发生器 (IR-GAN)
<ul>
<li>【论文】IR-GAN：用于远场语音识别的房间脉冲响应发生器</li>
<li>【代码】https://github.com/GAMMA-UMD/IR-GAN</li>
</ul>
一种提高远场语音识别合成房间脉冲响应质量的方法
<ul>
<li>【论文】TS-RIR：翻译合成房间脉冲反应语音增强</li>
<li>【代码】https://github.com/GAMMA-UMD/TS-RIR</li>
</ul>
在房间脉冲响应 (RIR) 生成中加入以下因素的影响：空气吸收、真实材料的表面和频率相关系数以及随机光线追踪
<ul>
<li>【论文】2020_远场关键字识别的更真实的房间模拟研究</li>
<li>【代码】https://github.com/ebezzam/room-simulation</li>
</ul>
<h3>方法三：利用RIR生成混响</h3>
<div class="cnblogs_code">
<pre>def add_pyreverb(wav, rir):
reverb_wav = signal.fftconvolve(wav, rir, mode="full")
reverb_wav = reverb_wav]# 使 reverb_wav 和 wav 具有相同的长度
return reverb_wav</pre>
</div>
<h2>指定SER生成远端语音</h2>
　　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的混响。
<div class="cnblogs_code">
<pre>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</pre>
</div>
<img src="https://img2020.cnblogs.com/blog/1433301/202101/1433301-20210107150628285-1924499876.png" alt="" width="565" height="419" loading="lazy" style="display: block; margin-left: auto; margin-right: auto">
<div> </div>
<h2>波形位移</h2>
　　语音波形移动使用numpy.roll函数向右移动shift距离
numpy.roll(a, shift, axis=None)
参数：
<ul>
<li>a：数组</li>
<li>shift：滚动的长度</li>
<li>axis：滚动的维度。0为垂直滚动，1为水平滚动，参数为None时，会先将数组扁平化，进行滚动操作后，恢复原始形状</li>
</ul>
<div class="cnblogs_code">
<pre>x = np.arange(10)
# array()

print(np.roll(x, 2))
# array()</pre>
</div>
波形位移函数：
<div class="cnblogs_code">
<pre>def time_shift(x, shift):
# shift：移动的长度
return np.roll(x, int(shift))

Augmentation = time_shift(wav_data, shift=fs//2)</pre>
</div>
<img src="https://img2020.cnblogs.com/blog/1433301/202010/1433301-20201002214715571-915114976.png" alt="" width="514" height="381" loading="lazy" style="display: block; margin-left: auto; margin-right: auto">
<h2 id="blogTitle11">谐波失真</h2>
参考自：soundpy
<div class="cnblogs_code">
<pre>def harmonic_distortion(wav):
wav = 2 * np.pi * wav
count = 0
while count < 5:
 wav = np.sin(wav)
 count += 1
return wav</pre>
</div>
<img src="https://img2023.cnblogs.com/blog/1433301/202303/1433301-20230320121727066-1933499933.png" alt="" width="441" height="327" loading="lazy" style="display: block; margin-left: auto; margin-right: auto">
<h2>重采样数据增强</h2>
　　重采样后语音数据会丢失重采样采样率到源采样值之间的频谱信息。
<div class="cnblogs_code">
<pre>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</pre>
</div>
<img src="https://img2020.cnblogs.com/blog/1433301/202110/1433301-20211031171654953-1544219624.png" alt="" width="501" height="376" loading="lazy" style="display: block; margin-left: auto; margin-right: auto">
<h2>编解码数据增强</h2>
　　这个我有空再来补全，参考DeepSpeech，先numpu to pcm，在转成 opus。
<h1>频域增强</h1>
<h2>音高增强(Pitch Shifting)</h2>
　　在频率轴上缩放频谱图，从而改变音高。音高修正只改变音高而不影响音速，我发现-5到5之间的步数更合适
<div class="cnblogs_code">
<pre># sr: 音频采样率
# n_steps: 要移动多少步
# bins_per_octave: 每个八度音阶(半音)多少步

# 上移大三度（如果bins_per_octave为12，则4步）
augment = librosa.effects.pitch_shift(wav_data, sr=sr, n_steps=4, bins_per_octave=12)
# 向下移动一个三全音（如果bins_per_octave是 12，则为六步）
augment = librosa.effects.pitch_shift(wav_data, sr=sr, n_steps=-6, bins_per_octave=12)
# 上移 3 个四分音符
augment = librosa.effects.pitch_shift(wav_data, sr=sr, n_steps=3, bins_per_octave=24)</pre>
</div>
<img src="https://img2020.cnblogs.com/blog/1433301/202110/1433301-20211031211623546-262509465.png" alt="" width="480" height="356" loading="lazy" style="display: block; margin-left: auto; margin-right: auto">
<h2>速度增强(Tempo)</h2>
在时间轴上缩放频谱图，从而改变播放速度。
<h3>变速不变调</h3>
方法一：ffmpeg
　　在变速之前我们需要安装 pip install ffmpeg  
<div class="cnblogs_code">
<pre>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")</pre>
</div>
ffmpeg是基于fmpeg开发的，Python的这个库不能加载太大的文件，但是原生的fmpeg。或者我们可以直接使用原生的ffmpeg工具包
<img src="https://img2020.cnblogs.com/blog/1433301/202110/1433301-20211031211859530-1890650943.png" alt="" width="528" height="396" loading="lazy" style="display: block; margin-left: auto; margin-right: auto">
我们可以看到变速前后的波形图和语谱图没变，但是他们的时间维度却减少了一半。
方法二：SoundTorch
　　SoundTouch 是一个开源音频处理库，用于更改音频流或音频文件的速度、音高和播放速率。该库还支持估计音轨的稳定每分钟节拍率。
命令实例见：https://www.surina.net/soundtouch/soundstretch.html
速度增加100%
<div class="cnblogs_code">
<pre>soundstretch input.wav output.wav -tempo=100</pre>
</div>
速度降低50%
<div class="cnblogs_code">
<pre>soundstretch input.wav output.wav -tempo=-50</pre>
</div>
<img src="https://img2020.cnblogs.com/blog/1433301/202110/1433301-20211031212039182-308366139.png" alt="" width="576" height="432" loading="lazy" style="display: block; margin-left: auto; margin-right: auto">
<h3>变速变调</h3>
方法一：SOX
　　需要在linux上运行，具体参考https://github.com/rabitt/pysox
<div class="cnblogs_code">
<pre>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)</pre>
</div>
或者我们直接使用原生的sox工具包
<div class="cnblogs_code">
<pre>$ sox input.wav output.wav speed 1.3 #速度变为原来的1.3倍
$ sox input.wav output.wav speed 0.8 #速度变为原来的0.8倍</pre>
</div>
<img src="https://img2020.cnblogs.com/blog/1433301/202110/1433301-20211031212140600-1676171515.png" alt="" width="490" height="367" loading="lazy" style="display: block; margin-left: auto; margin-right: auto">
方法二：librosa
　　按固定速率对音频系列进行时间拉伸。
<div class="cnblogs_code">
<pre>def time_stretch(x, rate):
# rate：拉伸的尺寸，
# rate > 1 加快速度
# rate < 1 放慢速度
return librosa.effects.time_stretch(x, rate)

Augmentation = time_stretch(wav_data, rate=2)</pre>
</div>
<img src="https://img2020.cnblogs.com/blog/1433301/202110/1433301-20211031212213347-132573291.png" alt="" width="497" height="367" loading="lazy" style="display: block; margin-left: auto; margin-right: auto">
　　我们来观察语谱图和波形图，发现形状变了，并且变速后的语音波形振幅降低了，为什么呢？难道变速还会减少语音的音量？求解答
<hr>
　　SpecAugment 通过在时间方向上通过在时间方向上扭曲来增强，并屏蔽（多个）连续时间步长（垂直掩模）和 mel 频率通道（水平掩模）的块
<ol>
<li>帮助网络在时间方向上的变形、频率信息的部分丢失和输入的小段语音的部分丢失方面具有鲁棒性</li>
<li>防止网络过度拟合</li>
</ol>
SpecAugment 中有三种增强策略：
<ul>
<li>时间扭曲(Time Warping)：在时间轴上随机扭曲频谱图。与速度扰动不同，这种方法不会增加或减少持续时间，而是在局部压缩和拉伸频谱图。</li>
<li>频率掩蔽(Frequency Mask)：频谱图的连续频率bin被随机掩蔽</li>
<li>时间掩蔽(Time Mask)：频谱图的连续时间帧被掩蔽</li>
</ul>
<img src="https://img2020.cnblogs.com/blog/1433301/202110/1433301-20211028115534027-2062185206.png" alt="" width="447" height="233" loading="lazy" style="display: block; margin-left: auto; margin-right: auto">
paperwithcode：SpecAugment几乎所有的代码都列出来了
<ul>
<li>tensorflow和pytorch实现：SpecAugment</li>
<li>numpy实现：SpecAugment_numpy_scipy</li>
<li>numpy实现：SpecAugment (很好理解)</li>
</ul>
<h2>扭曲增强(Warp)</h2>
　　将非线性图像扭曲应用于频谱图。这是通过沿时间和频率轴随机移动均匀分布的扭曲点网格来实现的。代码修改自：DeepSpeech
<div class="cnblogs_code">
<pre>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(, seed, mean=0.0, stddev=warp, dtype=tf.float32)
 return tf.pad(f, tf.constant([, ]), 'CONSTANT')# zero flow at all edges

flows = tf.stack(, axis=2)
flows = tf.image.resize_bicubic(tf.expand_dims(flows, 0), )
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</pre>
</div>
<h2>频率掩膜(Frequency Mask)</h2>
在幅度谱随机的将频点置零。推荐使用单个掩码（num_mask=1）
<ul class="nested">
<li class="nested" data-indent="4">模拟真实场景：在真实世界中，影响频率的因素（如不同的麦克风、不同的通话信道）通常是持续性的。一个单一、连续的频带掩码能很好地模拟这种“信道变化”，强迫模型不要过度依赖某几个特定的频率通道，而是学会从整个频谱中综合信息。</li>
<li class="nested" data-indent="4">避免过度破坏：多个离散的频率掩码会像“盐和胡椒”噪声一样，把频谱弄得“千疮百孔”，这很容易破坏掉对识别至关重要的谐波结构（比如元音的共振峰）。一个单一的掩码更有可能只遮挡部分信息，而不是摧毁整体结构。</li>
</ul>
有关更多详细信息，请参阅 SpecAugment 论文：SpecAugment: A Simple Data Augmentation Method for Automatic Speech Recognition
<div class="cnblogs_code">
<pre>def FreqMask(mag, num_mask=1, mask_percentage=0.01):
"""
:param mag: (F,T)
:param num_freq_mask: mask的数量
:param mask_percentage: mask的百分比 0.001~0.015
"""
F = mag.shape# 频点数
mask_width = int(mask_percentage * F)# mask的宽度
for i in range(num_mask):
 mask_start = np.random.randint(low=0, high=F - mask_width)# mask的index
 mag = 0 # 掩码F维度
return mag</pre>
</div>
<img src="https://img2023.cnblogs.com/blog/1433301/202303/1433301-20230320163620899-990607474.png" alt="" width="468" height="344" loading="lazy" style="display: block; margin-left: auto; margin-right: auto">
<h2>时间掩码(Time Mask)</h2>
在频谱上在时间维度将帧置零。代码修改自：DeepSpeech
主流推荐：使用少量固定的掩码，通常是 1 到 2 个 (num_masks = 1 或 num_masks = 2)。
<ul class="nested">
<li class="nested" data-indent="4">模拟真实干扰：在一段话中，可能会出现一两个短暂的干扰音，比如一声咳嗽、一次关门声、或者一个短暂的信号中断。使用 1-2 个时间掩码正好可以模拟这种场景</li>
</ul>
控制信息损失：
<ul class="nested">
<li class="nested" data-indent="8">如果只用一个很长的时间掩码，可能会把一整个关键词完全抹掉，这样模型就彻底学不到东西了，这对训练是有害的。</li>
<li class="nested" data-indent="8">如果用非常多（比如5个以上）的短掩码，又会把语音切得过于零碎，同样可能破坏语音的连贯性。</li>
<li class="nested" data-indent="8">可调超参：在 SpecAugment 论文中，作者把时间掩码的数量 m_T 作为一个可以调整的超参数，并在实验中发现 m_T = 2 是一个很好的选择。</li>
</ul>
<div class="cnblogs_code">
<pre>def TimeMask(mag, num_mask=1, mask_percentage=0.01):
"""
:param mag: (F,T)
:param num_freq_mask: mask的数量
:param mask_percentage: mask的百分比 0.001~0.015
"""
T = mag.shape# 频点数
mask_width = int(mask_percentage * T)# mask的宽度
for i in range(num_mask):
 mask_start = np.random.randint(low=0, high=T - mask_width)
 mag[:, mask_start:mask_start + mask_width] = 0# 掩码T维度
return mag</pre>
</div>
<img src="https://img2023.cnblogs.com/blog/1433301/202303/1433301-20230320164336290-998200386.png" alt="" width="454" height="333" loading="lazy" style="display: block; margin-left: auto; margin-right: auto">
<h2>频谱交换(SpecSwap)</h2>
<blockquote>
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.
</blockquote>
频谱交换提供两个增强策略：
<ul>
<li>频率交换：随机交换频谱图的两个频率块</li>
<li>时间交换：在时间轴上随机交换频谱图的两个帧块</li>
</ul>
SpecSwap 增强策略在 E2E ASR 模型中也运行良好，但缺乏与 SpecAugment 的比较。
<h1>多领域增强</h1>
<h2>drop增强</h2>
　　将目标数据表示的随机数据点归零。代码修改自：DeepSpeech
<div class="cnblogs_code">
<pre>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))</pre>
</div>
<h2>添加增强</h2>
将从正态分布（均值为 0.0）中选取的随机值添加到目标数据表示的所有数据点。代码修改自：DeepSpeech
<div class="cnblogs_code">
<pre>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)</pre>
</div>
<h2>乘法增强</h2>
将目标数据表示的所有数据点与从正态分布（均值为 1.0）中选取的随机值相乘。代码修改自：DeepSpeech
<div class="cnblogs_code">
<pre>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)</pre>
</div>
<h1>通道Shuffle</h1>
打乱原先通道顺序，这可以帮助对抗位置偏见。但是需要考虑打乱后会不会破坏麦克风阵列原始排布顺序，举个例子：
<blockquote>
双麦：01,10可以随机打乱
三麦(等间隔环形)：012、120、201、210、102、021。这6个位置都是等价的。
3麦(等间隔线性)：012和120就完全不一样了，只能012，210两种
</blockquote>
<div class="cnblogs_code">
<pre>def ChannelShuffle(wav, ratio=0.7):
""" 打乱通道顺序
Args:
 wav: (T, C)
 ratio: 打乱的概率
Returns:
"""
if random.random() < ratio:
 channel_num = wav.shape[-1]
 shuffled_channel_indexes = list(range(channel_num))
 random.shuffle(shuffled_channel_indexes)
 wav = wav[..., shuffled_channel_indexes]
return wav</pre>
</div>
<h1>参考</h1>
【python 音频处理库】
<ul>
<li>librosa</li>
<li>Pyroomacoustics</li>
<li class="_mce_tagged_br">PythonAudioEffects：专注音效</li>
<li class="_mce_tagged_br">WavAugment</li>
<li class="_mce_tagged_br">Audiogmenter：一个用于音频数据增强的MATLAB工具箱</li>
<li class="_mce_tagged_br">audiomentations：我愿称他为最强王者，专门的数据增强库，很全面，没事可以多看看</li>
</ul>
【知乎文章】简单地为语音加混响
【国际音频实验室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 音频处理工具使用方法
还有写没有跑通，但是总感觉有些价值的代码，记录在这里：
<ul>
<li>py-RIR-Generator（没跑通的原因是我是window系统）</li>
<li>gpuRIR（这个我跑通了，但是需要较大的计算资源）</li>
<li>去github找代码的时候，不一定要搜索“回声”，“混响”，也可以通过搜索"RIR"同样可以得到想要的结果</li>
</ul>
本文画图代码：
<div class="cnblogs_code"><img src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" id="code_img_closed_aff3d3be-31ac-4f49-b2f3-87750aca0fef" class="code_img_closed"><img src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" id="code_img_opened_aff3d3be-31ac-4f49-b2f3-87750aca0fef" class="code_img_opened" style="display: none">
<div id="cnblogs_code_open_aff3d3be-31ac-4f49-b2f3-87750aca0fef" class="cnblogs_code_hide">
<pre># 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()</pre>
</div>
View Code</div>
 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.
 M, Vorlaender, Auralization, 1st ed. Berlin: Springer-Verlag, 2008, pp. 1-340.
 D.Schroeder, Physically based real-time auralization of interactive virtual environments. PhD Thesis, RWTH Aachen University, 2011.
<div id="gtx-trans" style="position: absolute; left: 847px; top: 17331.9px"> </div> 
来源：https://www.cnblogs.com/LXP-Never/p/13404523.html

頁: [1]

琼殿技术论坛's Archiver

语音数据增强及python实现