python 语音识别学习（1）

采点，绘制波形图，显示频谱

import wave
import pyaudio
import numpy
import pylab

#打开WAV文档，文件路径根据需要做修改
wf = wave.open("test.wav", "rb")
#创建PyAudio对象
p = pyaudio.PyAudio()
stream = p.open(format=p.get_format_from_width(wf.getsampwidth()),
channels=wf.getnchannels(),
rate=wf.getframerate(),
output=True)
nframes = wf.getnframes()
framerate = wf.getframerate()
#读取完整的帧数据到str_data中，这是一个string类型的数据
str_data = wf.readframes(nframes)
wf.close()
#将波形数据转换为数组
# A new 1-D array initialized from raw binary or text data in a string.
wave_data = numpy.fromstring(str_data, dtype=numpy.short)
#将wave_data数组改为2列，行数自动匹配。在修改shape的属性时，需使得数组的总长度不变。
wave_data.shape = -1,2
#将数组转置
wave_data = wave_data.T
#time 也是一个数组，与wave_data[0]或wave_data[1]配对形成系列点坐标
#time = numpy.arange(0,nframes)*(1.0/framerate)
#绘制波形图
#pylab.plot(time, wave_data[0])
#pylab.subplot(212)
#pylab.plot(time, wave_data[1], c="g")
#pylab.xlabel("time (seconds)")
#pylab.show()
#
# 采样点数，修改采样点数和起始位置进行不同位置和长度的音频波形分析
N=44100
start=0 #开始采样位置
df = framerate/(N-1) # 分辨率
freq = [df*n for n in range(0,N)] #N个元素
wave_data2=wave_data[0][start:start+N]
c=numpy.fft.fft(wave_data2)*2/N
#常规显示采样频率一半的频谱
d=int(len(c)/2)
#仅显示频率在4000以下的频谱
while freq[d]>4000:
    d-=10
pylab.plot(freq[:d-1],abs(c[:d-1]),'r')
pylab.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 = 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 = None
        output_label = None
 
        # 迭代HMM模型并选取得分最高的模型
        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)

#! /usr/bin/env python
#! -*- coding=utf-8 -*-
 
#模拟两个正态分布的均值估计
 
from numpy import *
import numpy as np
import random
import copy
 
SIGMA = 6
EPS = 0.0001
#生成方差相同,均值不同的样本
def generate_data():	
	Miu1 = 20
	Miu2 = 40
	N = 1000
	X = mat(zeros((N,1)))
	for i in range(N):
		temp = random.uniform(0,1)
		if(temp > 0.5):
			X[i] = temp*SIGMA + Miu1
		else:
			X[i] = temp*SIGMA + Miu2
	return X
 
#EM算法
def my_EM(X):
	k = 2
	N = len(X)
	Miu = np.random.rand(k,1)
	Posterior = mat(zeros((N,2)))
	dominator = 0
	numerator = 0
	#先求后验概率
	for iter in range(1000):
		for i in range(N):
			dominator = 0
			for j in range(k):
				dominator = dominator + np.exp(-1.0/(2.0*SIGMA**2) * (X[i] - Miu[j])**2)
				#print dominator,-1/(2*SIGMA**2) * (X[i] - Miu[j])**2,2*SIGMA**2,(X[i] - Miu[j])**2
				#return
			for j in range(k):
				numerator = np.exp(-1.0/(2.0*SIGMA**2) * (X[i] - Miu[j])**2)
				Posterior[i,j] = numerator/dominator			
		oldMiu = copy.deepcopy(Miu)
		#最大化	
		for j in range(k):
			numerator = 0
			dominator = 0
			for i in range(N):
				numerator = numerator + Posterior[i,j] * X[i]
				dominator = dominator + Posterior[i,j]
			Miu[j] = numerator/dominator
		print ((abs(Miu - oldMiu)).sum() )
			#print '\n'
		if (abs(Miu - oldMiu)).sum() < EPS:
			print (Miu,iter)
			break
 
if __name__ == '__main__':
	X = generate_data()
	my_EM(X)