自然语言处理之语音识别：HiddenMarkovModel(HMM)：语音信号处理

    import numpy as np
    import matplotlib.pyplot as plt
    from scipy.io import wavfile
    
    # 读取语音信号
    sample_rate, signal = wavfile.read('speech_signal.wav')
    
    # 进行傅里叶变换
    fft_output = np.fft.fft(signal)
    
    # 计算频率轴
    freq_axis = np.fft.fftfreq(signal.size, 1/sample_rate)
    
    # 绘制频谱图
    plt.figure(figsize=(10, 6))
    plt.plot(freq_axis, np.abs(fft_output))
    plt.title('频谱图')
    plt.xlabel('频率 (Hz)')
    plt.ylabel('振幅')
    plt.show()

    import numpy as np
    from scipy.signal import lfilter
    from scipy.io import wavfile
    
    # 读取语音信号
    sample_rate, signal = wavfile.read('speech_signal.wav')
    
    # 预加重
    pre_emphasis = 0.97
    emphasized_signal = np.append(signal[0], signal[1:] - pre_emphasis * signal[:-1])
    
    # 分帧
    frame_size = 0.025  # 25ms
    frame_stride = 0.01  # 10ms
    frame_length, frame_step = int(round(frame_size * sample_rate)), int(round(frame_stride * sample_rate))
    signal_length = len(emphasized_signal)
    num_frames = int(np.ceil(float(np.abs(signal_length - frame_length)) / frame_step)) + 1
    pad_signal_length = num_frames * frame_step + frame_length
    z = np.zeros((pad_signal_length - signal_length))
    pad_signal = np.append(emphasized_signal, z)
    indices = np.tile(np.arange(0, frame_length), (num_frames, 1)) + np.tile(np.arange(0, num_frames * frame_step, frame_step), (frame_length, 1)).T
    frames = pad_signal[indices.astype(np.int32, copy=False)]
    
    # 端点检测
    # 假设我们使用能量阈值法进行端点检测
    energy_threshold = 1000
    start_frame = None
    end_frame = None
    for i, frame in enumerate(frames):
    energy = np.sum(frame**2)
    if energy > energy_threshold and start_frame is None:
        start_frame = i
    if energy < energy_threshold and start_frame is not None:
        end_frame = i
        break
    
    # 选取有效语音段
    speech_frames = frames[start_frame:end_frame]
    
    # 绘制预加重后的信号
    plt.figure(figsize=(10, 6))
    plt.plot(emphasized_signal)
    plt.title('预加重后的信号')
    plt.xlabel('时间')
    plt.ylabel('振幅')
    plt.show()

    # 导入必要的库
    from hmmlearn import hmm
    
    # 创建一个隐马尔可夫模型实例
    model = hmm.GaussianHMM(n_components=3, covariance_type="full")
    
    # 设置初始状态概率
    model.startprob_ = np.array([0.6, 0.3, 0.1])
    
    # 设置状态转移概率矩阵
    model.transmat_ = np.array([[0.7, 0.2, 0.1],
                            [0.3, 0.5, 0.2],
                            [0.3, 0.3, 0.4]])
    
    # 设置观测概率（均值和协方差）
    model.means_ = np.array([[0.0, 0.0], [3.0, -3.0], [5.0, 10.0]])
    model.covars_ = np.tile(np.identity(2), (3, 1, 1))

    # 导入必要的库
    import numpy as np
    from hmmlearn import hmm
    from sklearn.preprocessing import StandardScaler
    
    # 假设我们有两个HMM模型，分别代表音素'a'和'b'
    model_a = hmm.GaussianHMM(n_components=3, covariance_type="full")
    model_b = hmm.GaussianHMM(n_components=3, covariance_type="full")
    
    # 训练模型'a'和'b'
    # 这里使用虚构的数据，实际应用中需要使用大量真实语音信号数据
    X_a = np.random.randn(1000, 2)
    X_b = np.random.randn(1000, 2) + np.array([5, -5])
    
    # 数据预处理
    scaler = StandardScaler()
    X_a = scaler.fit_transform(X_a)
    X_b = scaler.transform(X_b)
    
    # 训练模型
    model_a.fit(X_a)
    model_b.fit(X_b)
    
    # 识别过程
    # 假设我们有一个未知的语音信号X
    X_unknown = np.random.randn(500, 2)
    
    # 使用模型计算概率
    prob_a = model_a.score(X_unknown)
    prob_b = model_b.score(X_unknown)
    
    # 选择概率最高的模型
    if prob_a > prob_b:
    print("识别结果为音素'a'")
    else:
    print("识别结果为音素'b'")

    import numpy as np
    import scipy.io.wavfile as wav
    from scipy.fftpack import dct
    from scipy.signal import lfilter, get_window
    from numpy.lib.stride_tricks import as_strided
    
    def pre_emphasis(signal, coeff=0.97):
    """预加重"""
    return lfilter([1, -coeff], [1], signal)
    
    def framing(signal, frame_len, frame_step, sample_rate):
    """分帧与加窗"""
    frame_len, frame_step = int(round(frame_len * sample_rate)), int(round(frame_step * sample_rate))
    signal_len = len(signal)
    frame_num = int(np.ceil(np.abs(signal_len - frame_len) / frame_step)) + 1
    pad_signal_len = frame_num * frame_step + frame_len
    pad_signal = np.append(signal, np.zeros(pad_signal_len - signal_len))
    indices = np.tile(np.arange(0, frame_len), (frame_num, 1)) + np.tile(np.arange(0, frame_num * frame_step, frame_step), (frame_len, 1)).T
    frames = pad_signal[indices.astype(np.int32, copy=False)]
    frames *= get_window('hamming', frame_len)
    return frames
    
    def mfcc(signal, sample_rate=16000, num_cep=13, num_filter=26, frame_len=0.025, frame_step=0.01):
    """计算MFCC"""
    signal = pre_emphasis(signal)
    frames = framing(signal, frame_len, frame_step, sample_rate)
    power_spec = np.square(np.abs(np.fft.rfft(frames, 512)))
    low_freq_mel = 0
    high_freq_mel = (2595 * np.log10(1 + (sample_rate / 2) / 700))
    mel_points = np.linspace(low_freq_mel, high_freq_mel, num_filter + 2)
    hz_points = (700 * (10**(mel_points / 2595) - 1))
    bin = np.floor((512 + 1) * hz_points / sample_rate)
    fbank = np.zeros((num_filter, 257))
    for m in range(1, num_filter + 1):
        f_m_minus = int(bin[m - 1])
        f_m = int(bin[m])
        f_m_plus = int(bin[m + 1])
        for k in range(f_m_minus, f_m):
            fbank[m - 1, k] = (k - bin[m - 1]) / (bin[m] - bin[m - 1])
        for k in range(f_m, f_m_plus):
            fbank[m - 1, k] = (bin[m + 1] - k) / (bin[m + 1] - bin[m])
    filter_banks = np.dot(power_spec, fbank.T)
    filter_banks = np.where(filter_banks == 0, np.finfo(float).eps, filter_banks)
    filter_banks = 20 * np.log10(np.sqrt(filter_banks))
    mfcc = dct(filter_banks, type=2, axis=1, norm='ortho')[:, 1 : (num_cep + 1)]
    return mfcc
    
    # 示例数据
    sample_rate, signal = wav.read('example.wav')
    mfcc_features = mfcc(signal, sample_rate)

    def energy(signal):
    """计算信号能量"""
    return np.sum(signal ** 2)
    
    def zero_crossing_rate(signal):
    """计算过零率"""
    return np.sum(np.abs(np.diff(np.sign(signal)))) / (2 * len(signal))
    
    def endpoint_detection(signal, frame_len=0.025, frame_step=0.01, energy_threshold=10, zcr_threshold=0.01):
    """端点检测"""
    frames = framing(signal, frame_len, frame_step, 16000)
    energies = np.array([energy(frame) for frame in frames])
    zcrs = np.array([zero_crossing_rate(frame) for frame in frames])
    voice_frames = np.where((energies > energy_threshold) & (zcrs > zcr_threshold))[0]
    return voice_frames
    
    # 示例数据
    sample_rate, signal = wav.read('example.wav')
    voice_frames = endpoint_detection(signal)
    pre_emphasized_signal = pre_emphasis(signal[voice_frames])

    from hmmlearn import hmm
    import numpy as np
    
    # 初始化 HMM 参数
    model = hmm.GaussianHMM(n_components=6, covariance_type="diag", n_iter=1000)
    
    # 设置观测模型参数（均值和方差）
    start_means = np.array([[0.0], [3.0], [6.0], [9.0], [12.0], [15.0]])
    start_covars = np.tile(np.array([[1.0]]), (6, 1))
    model.means_ = start_means
    model.covars_ = start_covars
    
    # 设置状态转移概率
    start_transmat = np.array([[0.0, 1.0, 0.0, 0.0, 0.0, 0.0],
                           [0.0, 0.0, 1.0, 0.0, 0.0, 0.0],
                           [0.0, 0.0, 0.0, 1.0, 0.0, 0.0],
                           [0.0, 0.0, 0.0, 0.0, 1.0, 0.0],
                           [0.0, 0.0, 0.0, 0.0, 0.0, 1.0],
                           [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]])
    model.transmat_ = start_transmat
    
    # 训练数据（假设为 MFCC 特征）
    X = np.array([[1.0], [2.0], [3.0], [4.0], [5.0], [6.0],
              [7.0], [8.0], [9.0], [10.0], [11.0], [12.0],
              [13.0], [14.0], [15.0], [16.0], [17.0], [18.0]])
    
    # 训练 HMM
    model.fit(X)
    
    # 输出训练后的参数
    print("Means:\n", model.means_)
    print("Covars:\n", model.covars_)
    print("Transmat:\n", model.transmat_)

    from hmmlearn import hmm
    from hmmlearn import gmm
    
    # 定义 HMM 参数
    n_states = 3  # 每个模型的状态数
    n_mixtures = 2  # 每个状态的混合成分数
    n_features = 13  # 特征向量的维度
    
    # 创建 HMM/GMM 模型
    model = hmm.GMMHMM(n_components=n_states, n_mix=n_mixtures)
    
    # 训练模型
    model.fit(features)
    
    # 使用模型进行识别
    logprob, posteriors = model.score_samples(features)

    # 使用 Viterbi 算法解码
    logprob, state_sequence = model.decode(observation, algorithm="viterbi")
    
    # 输出结果
    print("Log probability: ", logprob)
    print("State sequence: ", state_sequence)

    import numpy as np
    from hmmlearn import hmm
    import librosa
    
    # 定义特征提取函数
    def extract_features(audio_file):
    y, sr = librosa.load(audio_file)
    mfccs = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=13)
    delta_mfccs = librosa.feature.delta(mfccs)
    features = np.vstack((mfccs, delta_mfccs))
    return features.T
    
    # 读取训练数据
    train_data = {
    'yes': [extract_features(f'yes_{i}.wav') for i in range(100)],
    'no': [extract_features(f'no_{i}.wav') for i in range(100)]
    }
    
    # 构建HMM模型
    models = {}
    for word, data in train_data.items():
    model = hmm.GaussianHMM(n_components=3, covariance_type="diag", n_iter=1000)
    model.fit(np.concatenate(data))
    models[word] = model
    
    # 读取测试数据
    test_data = {
    'yes': [extract_features(f'yes_test_{i}.wav') for i in range(10)],
    'no': [extract_features(f'no_test_{i}.wav') for i in range(10)]
    }
    
    # 识别测试数据
    results = {}
    for word, data in test_data.items():
    scores = {w: m.score(d) for w, m in models.items() for d in data}
    results[word] = [max(scores, key=scores.get) for _ in range(len(data))]
    
    # 输出识别结果
    for word, predictions in results.items():
    print(f"识别结果({word}): {predictions}")

    # 假设我们有以下的词序列模型
    word_sequence_model = hmm.GMMHMM(n_components=10, n_mix=3)
    
    # 训练词序列模型
    word_sequence_model.fit(np.concatenate([train_data['yes'], train_data['no']]))
    
    # 识别测试数据中的词序列
    test_sequence = np.concatenate(test_data['yes'][:5] + test_data['no'][:5])
    logprob, sequence = word_sequence_model.decode(test_sequence, algorithm='viterbi')
    
    # 输出识别的词序列
    print(f"识别的词序列: {sequence}")

    # 导入必要的库
    import numpy as np
    from hmmlearn import hmm
    
    # 创建HMM模型
    model = hmm.GaussianHMM(n_components=3, covariance_type="diag", n_iter=1000)
    
    # 假设观测数据为一维高斯分布
    observations = np.random.randn(1000, 1)
    
    # 训练模型
    model.fit(observations)
    
    # 打印模型参数
    print("状态转移概率矩阵A:")
    print(model.transmat_)
    print("观测概率矩阵B:")
    print(model.means_)

    # 假设我们有两个语言模型，分别用LM1和LM2表示
    # LM1和LM2都是词序列的概率分布
    
    # 定义词序列
    word_sequence = ["我", "爱", "自然", "语言", "处理"]
    
    # 计算词序列在两个模型下的概率
    prob_LM1 = calculate_probability(word_sequence, LM1)
    prob_LM2 = calculate_probability(word_sequence, LM2)
    
    # 定义融合权重
    weight_LM1 = 0.6
    weight_LM2 = 0.4
    
    # 使用线性插值进行融合
    final_prob = weight_LM1 * prob_LM1 + weight_LM2 * prob_LM2
    
    # 输出最终概率
    print("融合后的词序列概率:", final_prob)