语音识别入门

什么是语音识别

语音识别是将语音信号转换为文本的技术，是人机交互的重要接口。

声学特征提取

语音信号需要转换为特征向量：

import numpy as np

def extract_features(signal, sr=16000, n_mfcc=13):
    frame_length = int(0.025 * sr)
    frame_stride = int(0.01 * sr)
    
    num_frames = int(np.ceil((len(signal) - frame_length) / frame_stride))
    
    frames = np.zeros((num_frames, frame_length))
    for i in range(num_frames):
        start = i * frame_stride
        frames[i] = signal[start:start+frame_length]
    
    return frames

signal = np.random.randn(16000)
frames = extract_features(signal)
print("帧数:", frames.shape[0])

MFCC特征

MFCC是最常用的语音特征：

def compute_mfcc(signal, sr=16000, n_mfcc=13, n_fft=512):
    frames = extract_features(signal, sr)
    
    fft_result = np.fft.rfft(frames, n=n_fft)
    magnitude = np.abs(fft_result)
    
    mel_filters = np.random.randn(n_fft//2 + 1, 40)
    mel_spectrum = np.dot(magnitude, mel_filters)
    
    log_mel = np.log(mel_spectrum + 1e-8)
    mfcc = np.zeros((frames.shape[0], n_mfcc))
    
    for i in range(frames.shape[0]):
        mfcc[i] = np.fft.irfft(log_mel[i])[:n_mfcc]
    
    return mfcc

mfcc = compute_mfcc(signal)
print("MFCC形状:", mfcc.shape)

CTC损失

CTC处理输入输出长度不匹配问题：

import torch
import torch.nn as nn

class CTCDecoder(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super(CTCDecoder, self).__init__()
        self.lstm = nn.LSTM(input_dim, hidden_dim, batch_first=True, 
                           bidirectional=True)
        self.fc = nn.Linear(hidden_dim * 2, output_dim)
    
    def forward(self, x):
        lstm_out, _ = self.lstm(x)
        output = self.fc(lstm_out)
        return output

ctc_loss = nn.CTCLoss(blank=0, zero_infinity=True)

model = CTCDecoder(input_dim=39, hidden_dim=256, output_dim=28)
inputs = torch.randn(32, 100, 39)
log_probs = torch.log_softmax(model(inputs), dim=-1)

targets = torch.randint(1, 28, (32, 20))
input_lengths = torch.full((32,), 100)
target_lengths = torch.full((32,), 20)

loss = ctc_loss(log_probs.transpose(0, 1), targets, input_lengths, target_lengths)
print("CTC损失:", loss.item())

端到端模型

使用Transformer进行端到端语音识别：

class SpeechTransformer(nn.Module):
    def __init__(self, input_dim, d_model, num_heads, num_layers, 
                 vocab_size):
        super(SpeechTransformer, self).__init__()
        self.embedding = nn.Linear(input_dim, d_model)
        self.pos_encoding = nn.Parameter(torch.randn(1, 1000, d_model))
        
        encoder_layer = nn.TransformerEncoderLayer(d_model, num_heads)
        self.transformer = nn.TransformerEncoder(encoder_layer, num_layers)
        self.fc = nn.Linear(d_model, vocab_size)
    
    def forward(self, x):
        x = self.embedding(x)
        x = x + self.pos_encoding[:, :x.size(1), :]
        x = x.transpose(0, 1)
        output = self.transformer(x)
        output = self.fc(output.transpose(0, 1))
        return output

model = SpeechTransformer(input_dim=39, d_model=512, num_heads=8,
                          num_layers=6, vocab_size=28)
input_features = torch.randn(32, 200, 39)
output = model(input_features)
print("输出形状:", output.shape)

语音增强

def add_noise(signal, noise_level=0.01):
    noise = np.random.randn(len(signal)) * noise_level
    return signal + noise

def time_mask(signal, max_mask=10):
    mask_length = np.random.randint(1, max_mask)
    start = np.random.randint(0, len(signal) - mask_length)
    signal[start:start+mask_length] = 0
    return signal

augmented = add_noise(signal)
augmented = time_mask(augmented)

总结

语音识别是AI的重要应用。MFCC提供有效的声学特征，CTC解决序列对齐问题，端到端模型简化了系统设计。