如何绘制波形图

读取双通道波形并绘制波形图
import wave
import matplotlib.pyplot as plt
import numpy as np
"""读取双通道波形并绘制波形图"""
# 打开WAV音频
f = wave.open("./audio/audio.wav", "rb")

# 读取格式信息
# (声道数、量化位数、采样频率、采样点数、压缩类型、压缩类型的描述)
# (nchannels, sampwidth, framerate, nframes, comptype, compname)
params = f.getparams()
nchannels, sampwidth, framerate, nframes = params[:4]
print("声道数---", nchannels)
print("量化位数---", sampwidth)
print("采样频率---", framerate)
print("采样点数---", nframes)

# 读取nframes个数据，返回字符串格式
str_data = f.readframes(nframes)
f.close()

# 将字符串转换为数组，得到一维的short类型的数组
wave_data = np.fromstring(str_data, dtype=np.short)

# 赋值的归一化
wave_data = wave_data * 1.0 / (max(abs(wave_data)))

# 整合左声道和右声道的数据
wave_data = np.reshape(wave_data, [nframes, nchannels])
# wave_data.shape = (-1, 2)   # -1的意思就是没有指定,根据另一个维度的数量进行分割

# 最后通过采样点数和取样频率计算出每个取样的时间
time = np.arange(0, nframes) * (1.0 / framerate)

plt.figure()
# 左声道波形
plt.subplot(3, 1, 1)
plt.plot(time, wave_data[:, 0])
plt.xlabel("time (seconds)")
plt.ylabel("Amplitude")
plt.title("Left channel")
plt.grid()  # 标尺

plt.subplot(3, 1, 3)
# 右声道波形
plt.plot(time, wave_data[:, 1], c="g")
plt.xlabel("time (seconds)")
plt.ylabel("Amplitude")
plt.title("Left channel")
plt.title("right channel")
plt.grid()

plt.show()

这种方法读取的是字符型，需要经过 np.fromstring(str_data, dtype=np.short)类型转换。
第二种读取wav文件的方式：
from scipy.io import wavfile
sampling_freq, audio = wavfile.read("   	.wav")
这里读取的audio直接是数组形式。
import wave
import matplotlib.pyplot as plt
import numpy as np
from scipy.io import wavfile
"""读取双通道波形并绘制波形图"""
f = wavfile.read("./audio/audio.wav")
nframes = len(f[1])  #获取采样点数
nchannels = 2  #  通道数=2
framerate = f[0] #  获取采样频率
wave_data = f[1]  #  获取音频数据
wave_data = np.reshape(wave_data, [nframes, nchannels])
# 最后通过采样点数和取样频率计算出每个取样的时间
time = np.arange(0, nframes) * (1.0 / framerate)

plt.figure()
# 左声道波形
plt.subplot(3, 1, 1)
plt.plot(time, wave_data[:, 0])
plt.xlabel("time (seconds)")
plt.ylabel("Amplitude")
plt.title("Left channel")
plt.grid()  # 标尺

plt.subplot(3, 1, 3)
# 右声道波形
plt.plot(time, wave_data[:, 1], c="g")
plt.xlabel("time (seconds)")
plt.ylabel("Amplitude")
plt.title("Left channel")
plt.title("right channel")
plt.grid()
plt.show()

结果如下：

音频信号的短时频域处理
语音信号处理中，信号再频域或其他变换域上的分析处理非常重要，再频域上研究语音可以使信号在时域上无法表现出来的特征变得十分明显，一个音频信号的本质是由其频率内容来决定的。—短时傅里叶变换
import numpy as np
from scipy.io import wavfile
import matplotlib.pyplot as plt

sampling_freq, audio = wavfile.read("./audio/audio.wav")  # 读取文件

audio = audio / np.max(audio)  # 归一化，标准化

# 应用傅里叶变换
fft_signal = np.fft.fft(audio)
print(fft_signal)

fft_signal = abs(fft_signal)
print(fft_signal)

# 建立时间轴
Freq = np.arange(0, len(fft_signal))

# 绘制语音信号的
plt.figure()
plt.plot(Freq, fft_signal, color='blue')
plt.xlabel('Freq (in kHz)')
plt.ylabel('Amplitude')
plt.show()


显示双通道语音信号和频谱图：
import wave
import matplotlib.pyplot as plt
import numpy as np
from scipy.io import wavfile
"""读取双通道波形并绘制波形图"""
sampling_freq, f = wavfile.read("./audio/audio.wav")

nframes = len(f)  #获取采样点数
nchannels = 2  #  通道数=2
framerate = sampling_freq #  获取采样频率
wave_data = f  #  获取音频数据
wave_data = np.reshape(wave_data, [nframes, nchannels])
# 最后通过采样点数和取样频率计算出每个取样的时间
time = np.arange(0, nframes) * (1.0 / framerate)
#  归一化标准化
f = f / np.max(f)
# 应用傅里叶变换
f = np.fft.fft(f)
f = abs(f)
# 建立时间轴
freq = np.arange(0, len(f))

plt.figure()
# 左声道波形
plt.subplot(3, 1, 1)
plt.plot(time, wave_data[:, 0])
plt.xlabel("time (seconds)")
plt.ylabel("Amplitude")
plt.title("Left channel")
plt.grid()  # 标尺

# 右声道波形
plt.subplot(3, 1, 2)
plt.plot(time, wave_data[:, 1], c="g")
plt.xlabel("time (seconds)")
plt.ylabel("Amplitude")
plt.title("Left channel")
plt.title("right channel")
plt.grid()

# 绘制频谱图
plt.subplot(3, 1, 3)
plt.plot(freq, f, color='blue')
plt.xlabel('Freq (in kHz)')
plt.ylabel('Amplitude')
plt.grid()

plt.show()


写入wav文件（合成wav文件）
先读取一个存在的音频文件，然后写入一个新的文件。
import wave
import numpy as np
import struct

f = wave.open("./audio/audio.wav", "rb")  # 已存在的wav文件
params = f.getparams()  # 读取该文件的参数
# 读取原文件的通道数，量化位数，采样频率，采样点数
nchannels_old, sampwidth_old, framerate_old, nframes_old = params[:4]
strData = f.readframes(nframes_old)
#转换读取的格式
waveData = np.fromstring(strData, dtype=np.int16)
f.close()
waveData = waveData * 1.0 / (max(abs(waveData)))

# wav文件写入
# 待写入wav的数据，这里仍然取waveData数据
outData = waveData
outwave = wave.open("./audio/compose_test.wav", 'wb')
# 通道数，量化位数，采样频率，采样点数设置。也可自行选择
nchannels = nchannels_old 
sampwidth = sampwidth_old  
framerate = framerate_old  
nframes = nframes_old  
# 写入文件参数配置
comptype = "NONE"
compname = "not compressed"
outwave.setparams((nchannels, sampwidth, framerate, nframes,
                   comptype, compname))

for i in outData:
    outwave.writeframes(struct.pack('h', int(i * 64000 / 2)))

    # struct.pack(FMT, V1)将V1的值转换为FMT格式字符串
outwave.close()

录音
以SAMPLING_RATE为采样频率，每次读入一块有NUM_SAMPLES个采样的数据块，当读入的采样数据中有COUNT_NUM个值大于LEVEL的取样的时候，将数据保存进WAV文件，一旦开始保存数据，所保存的数据长度最短为SAVE_LENGTH个块。WAV文件以保存时的时刻作为文件名。
从声卡读入的数据和从WAV文件读入的类似，都是二进制数据，由于我们用paInt16格式(16bit的short类型)保存采样值，因此将它自己转换为dtype为np.short的数组。
'''
以SAMPLING_RATE为采样频率，
每次读入一块有NUM_SAMPLES个采样点的数据块，
当读入的采样数据中有COUNT_NUM个值大于LEVEL的取样的时候，
将采样数据保存进WAV文件，
一旦开始保存数据，所保存的数据长度最短为SAVE_LENGTH个数据块。
 
从声卡读入的数据和从WAV文件读入的类似，都是二进制数据，
由于我们用paInt16格式(16bit的short类型)保存采样值，
因此将它自己转换为dtype为np.short的数组。
'''
 
 
from pyaudio import PyAudio, paInt16
import numpy as np
import wave
 
# 将data中的数据保存到名为filename的WAV文件中
def save_wave_file(filename, data):
    wf = wave.open(filename, 'wb')
    wf.setnchannels(1)          # 单通道
    wf.setsampwidth(2)          # 量化位数
    wf.setframerate(SAMPLING_RATE)  # 设置采样频率
    wf.writeframes(b"".join(data))  # 写入语音帧
    wf.close()
 
 
NUM_SAMPLES = 2000      # pyAudio内部缓存块的大小
SAMPLING_RATE = 8000    # 取样频率
LEVEL = 1500           # 声音保存的阈值，小于这个阈值不录
COUNT_NUM = 20 # 缓存快类如果有20个大于阈值的取样则记录声音
SAVE_LENGTH = 8 # 声音记录的最小长度：SAVE_LENGTH * NUM_SAMPLES 个取样
 
# 开启声音输入
pa = PyAudio()
stream = pa.open(format=paInt16, channels=1, rate=SAMPLING_RATE, input=True,
                frames_per_buffer=NUM_SAMPLES)
 
save_count = 0  # 用来计数
save_buffer = []    #
 
while True:
    # 读入NUM_SAMPLES个取样
    string_audio_data = stream.read(NUM_SAMPLES)
    # 将读入的数据转换为数组
    audio_data = np.fromstring(string_audio_data, dtype=np.short)
    # 计算大于LEVEL的取样的个数
    large_sample_count = np.sum( audio_data > LEVEL )
    print(np.max(audio_data))
    # 如果个数大于COUNT_NUM，则至少保存SAVE_LENGTH个块
    if large_sample_count > COUNT_NUM:
        save_count = SAVE_LENGTH
    else:
        save_count -= 1
 
    if save_count < 0:
        save_count = 0
 
    if save_count > 0:
        # 将要保存的数据存放到save_buffer中
        save_buffer.append( string_audio_data )
    else:
        # 将save_buffer中的数据写入WAV文件，WAV文件的文件名是保存的时刻
        if len(save_buffer) > 0:
            filename = "recorde" + ".wav"
            save_wave_file(filename, save_buffer)
            print(filename, "saved")
            break

MFCC特征提取
import numpy as np
import matplotlib.pyplot as plt
from scipy.io import wavfile
from python_speech_features import mfcc, logfbank

# 读取输入音频文件
sampling_freq, audio = wavfile.read("./audio/audio.wav")

# 提取MFCC和滤波器组特征
mfcc_features = mfcc(audio, sampling_freq)
filterbank_features = logfbank(audio, sampling_freq)

print('\nMFCC:\n窗口数 =', mfcc_features.shape[0])
print('每个特征的长度 =', mfcc_features.shape[1])
print('\nFilter bank:\n窗口数 =', filterbank_features.shape[0])
print('每个特征的长度 =', filterbank_features.shape[1])

# 画出特征图，将MFCC可视化。转置矩阵，使得时域是水平的
mfcc_features = mfcc_features.T
plt.matshow(mfcc_features)
plt.title('MFCC')
# 将滤波器组特征可视化。转置矩阵，使得时域是水平的
filterbank_features = filterbank_features.T
plt.matshow(filterbank_features)
plt.title('Filter bank')

plt.show()

结果如下（因为输入的音频较大，故有点长。在传统的音频处理中，输入音频大多为短时音频，形状为矩形。感兴趣的可尝试输入不同的音频）：


语谱图
import wave
import matplotlib.pyplot as plt
import numpy as np

f = wave.open('./audio/audio.wav', 'rb')
params = f.getparams()
nchannels, sampwidth, framerate, nframes = params[:4]
strdata = f.readframes(nframes)
wavedata = np.fromstring(strdata, dtype=np.int16)
wavedata = wavedata * 1.0 / (max(abs(wavedata)))
wavedata = np.reshape(wavedata, [nframes, nchannels]).T
f.close()

plt.specgram(wavedata[0], Fs=framerate, scale_by_freq=True, sides = 'default')
plt.ylabel('Frequency(HZ)')
plt.xlabel('Time(s)')
plt.show()


语音识别
如下是一个语音识别的实例
import os
import argparse
import numpy as np
from scipy.io import wavfile
from hmmlearn import hmm
from python_speech_features import mfcc

# 解析命令行的输入参数
def build_arg_parser():
    parser = argparse.ArgumentParser(description='Trains the HMM classifier')
    parser.add_argument( "--input-folder",dest="input_folder", required=True,
            help="Input folder containing the audio files in subfolders")
    return parser

# 创建类，处理HMM相关过程
class HMMTrainer(object):
    '''用到高斯隐马尔科夫模型
    n_components：定义了隐藏状态的个数
    cov_type：定义了转移矩阵的协方差类型
    n_iter:定义了训练的迭代次数
    '''
    def __init__(self, model_name='GaussianHMM', n_components=4, cov_type='diag', n_iter=1000):
        self.model_name = model_name
        self.n_components = n_components
        self.cov_type = cov_type
        self.n_iter = n_iter
        self.models = []

        if self.model_name == 'GaussianHMM':
            self.model = hmm.GaussianHMM(n_components=self.n_components,
                    covariance_type=self.cov_type, n_iter=self.n_iter)
        else:
            raise TypeError('Invalid model type')

    # X是二维数组，其中每一行有13个数
    def train(self, X):
        np.seterr(all='ignore')
        self.models.append(self.model.fit(X))

    # 对输入数据运行模型
    def get_score(self, input_data):
        return self.model.score(input_data)

if __name__=='__main__':
    # 解析输入参数
    args = build_arg_parser().parse_args(['--input-folder', 'input_folder'])
    input_folder = args.input_folder

    hmm_models = [] # 初始化隐马尔科夫模型的变量

    # 解析输入路径
    for dirname in os.listdir(input_folder):
        # 获取子文件夹名称
        subfolder = os.path.join(input_folder, dirname)
        if not os.path.isdir(subfolder):
            continue
        # 子文件夹名称即为该类的标记
        # 提取特征
        label = subfolder[subfolder.rfind('/') + 1:]

        # 初始化变量
        X = np.array([])
        y_words = []

        # 迭代所有音频文件(分别保留一个进行测试)
        for filename in [x for x in os.listdir(subfolder) if x.endswith('.wav')][:-1]:
            # 读取每个音频文件
            filepath = os.path.join(subfolder, filename)
            sampling_freq, audio = wavfile.read(filepath)

            # 提取MFCC特征
            mfcc_features = mfcc(audio, sampling_freq)

            # 将MFCC特征添加到X变量
            if len(X) == 0:
                X = mfcc_features
            else:
                X = np.append(X, mfcc_features, axis=0)


            # 添加标记
            y_words.append(label)

        print('X.shape =', X.shape)
        # 训练并且保存HMM模型
        hmm_trainer = HMMTrainer()
        hmm_trainer.train(X)
        hmm_models.append((hmm_trainer, label))

        hmm_trainer = None

    # 测试文件
    input_files = [
            'data/pineapple/pineapple15.wav',
            'data/orange/orange15.wav',
            'data/apple/apple15.wav',
            'data/kiwi/kiwi15.wav'
            ]

    # 为输入数据分类
    for input_file in input_files:
        # 读取每个音频文件
        sampling_freq, audio = wavfile.read(input_file)

        # 提取MFCC特征
        mfcc_features = mfcc(audio, sampling_freq)

        # 定义变量
        max_score = 0
        output_label = None
        score_data = []
        # 迭代HMM模型并选取得分最高的模型
        for item in hmm_models:
            hmm_model, label = item
            score = hmm_model.get_score(mfcc_features)
            score_data.append(score)
            max_score = max(score_data)
        for item in hmm_models:
            hmm_model, label = item
            score = hmm_model.get_score(mfcc_features)
            if score >= max_score:
                max_score = score
                output_label = label

        # 打印结果
        print("\nTrue:", input_file[input_file.find('/')+1:input_file.rfind('/')])
        print("Predicted:", output_label)



信号分帧

wlen为帧长，inc 为帧移，重叠部分为overlap，overlap = wlen - inc
信号帧数为：fn = (N - overlap) / inc = (N - wlen) / inc + 1
N为语音数据长度。
加窗
通常对信号截断，分帧需要加窗，因为截断都有频域能量泄露，而窗函数可以减少截断带来的影响。窗函数再scipy.signal信号处理工具箱中。
短时能量
短时能量主要用于区分浊音段和清音段
下面绘制未加窗，加窗，以及短时能量图：
import numpy as np
import wave
import matplotlib.pyplot as plt
import scipy.signal as signal

wlen = 512  # 每一帧信号的长度
inc = 128  #  帧移
f = wave.open('./data/apple/apple01.wav', 'rb')
params = f.getparams()
nchannels, sampwidth, framerate, nframes = params[:4]  # 读取文件的参数并赋值-通道数，量化位数，采样频率，采样点数
str_data = f.readframes(nframes)
wave_data = np.fromstring(str_data, dtype=np.short)  # 处理采样点数的数据，将str型转为为short型
wave_data = wave_data * 1.0 / (max(abs(wave_data)))  #  归一化处理

time = np.arange(0, wlen) * (1.0 / framerate)

signal_length = len(wave_data)  # 获取信号长度

if signal_length <= wlen:
    nf = 1
else :
    nf = int(np.ceil((1.0 * signal_length - wlen + inc) / inc))

pad_length = int((nf - 1 ) * inc + wlen)
zeros = np.zeros((pad_length - signal_length,))
pad_signal = np.concatenate((wave_data, zeros))
indices = np.tile(np.arange(0, wlen), (nf, 1)) + np.tile(np.arange(0, nf*inc, inc), (wlen, 1)).T

indices = np.array(indices, dtype = np.int32)
frames = pad_signal[indices]
# 绘制第10-11帧的图像
a = frames[10:11]
# 使用汉明窗
windown = np.hanning(wlen)
b = a[0] * windown
c = np.square(b)

plt.figure(figsize=(10, 4))
# 绘制未加窗的图
plt.subplot(3, 1, 1)
plt.plot(time, a[0], c='b')
plt.xlabel("no-window")
plt.grid()
#  绘制增加汉明窗的图
plt.subplot(3, 1, 2)
plt.plot(time, b, c='g')
plt.xlabel("hanning-window")
plt.grid()
#  绘制短时能量图
plt.subplot(3, 1, 3)
plt.plot(time, c, c='r')
plt.xlabel("short-power")
plt.grid()
plt.show()


绘制第10-11帧的图像
a = frames[10:11]
使用汉明窗
windown = np.hanning(wlen)

b = a[0] * windown

c = np.square(b)
plt.figure(figsize=(10, 4))
绘制未加窗的图
plt.subplot(3, 1, 1)

plt.plot(time, a[0], c=‘b’)

plt.xlabel(“no-window”)

plt.grid()
绘制增加汉明窗的图
plt.subplot(3, 1, 2)

plt.plot(time, b, c=‘g’)

plt.xlabel(“hanning-window”)

plt.grid()
绘制短时能量图
plt.subplot(3, 1, 3)

plt.plot(time, c, c=‘r’)

plt.xlabel(“short-power”)

plt.grid()

plt.show()