基于GRU的语音情感分析识别
GRU架构下的语音情感识别
情感识别模型优化详细文档
📋 目录
📖 概述
本文档详细介绍了IEMOCAP情感识别模型的核心优化技术，主要解决跨说话人情感识别中的泛化能力问题。优化策略包括说话人无关化技术、高级训练策略和综合损失函数设计。
主要优化目标
- 🎯 提升跨说话人泛化能力：消除说话人特征对情感识别的干扰
- 📈 增强模型鲁棒性：通过多种正则化和数据增强技术
- ⚡ 优化训练效率：采用先进的学习率调度和早停策略
- 🔍 提供全面监控：实时可视化训练过程和模型性能
🔧 核心优化技术
1. 说话人无关化技术
1.1 自适应实例归一化 (AdaIN)
原理：通过实例级别的归一化消除不同说话人的音频特征差异，保留情感相关信息。
class AdaptiveInstanceNormalization(nn.Module):
"""
自适应实例归一化 - 说话人归一化层
原理：
1. 计算每个样本在时序维度上的均值和方差
2. 进行归一化处理，消除说话人特征差异
3. 通过可学习参数重新缩放，保留情感信息
数学公式：
μ = mean(x, dim=1) # 时序维度均值
σ² = var(x, dim=1) # 时序维度方差
x_norm = (x - μ) / √(σ² + ε) # 归一化
output = γ * x_norm + β # 仿射变换
"""
def __init__(self, num_features, eps=1e-5):
super(AdaptiveInstanceNormalization, self).__init__()
self.num_features = num_features
self.eps = eps # 数值稳定性参数
# 可学习的缩放和偏移参数
self.weight = nn.Parameter(torch.ones(num_features)) # γ 缩放参数
self.bias = nn.Parameter(torch.zeros(num_features)) # β 偏移参数
def forward(self, x):
"""
前向传播
Args:
x: [batch_size, seq_len, num_features] 输入特征
Returns:
归一化后的特征
"""
# 计算实例级别的均值和方差（跨序列维度）
mean = x.mean(dim=1, keepdim=True) # [batch_size, 1, num_features]
var = x.var(dim=1, keepdim=True, unbiased=False) # [batch_size, 1, num_features]
# 归一化处理
x_norm = (x - mean) / torch.sqrt(var + self.eps)
# 应用可学习的仿射变换
out = x_norm * self.weight.unsqueeze(0).unsqueeze(0) + self.bias.unsqueeze(0).unsqueeze(0)
return out关键参数：
num_features: 特征维度数量eps: 数值稳定性参数，防止除零错误weight: 可学习的缩放参数γbias: 可学习的偏移参数β
1.2 梯度反转对抗训练
原理：通过梯度反转层实现对抗训练，迫使模型学习说话人无关的特征表示。
class GradientReversalLayer(torch.autograd.Function):
"""
梯度反转层 - 对抗训练核心组件
原理：
1. 前向传播：正常传递特征，不做任何改变
2. 反向传播：将梯度乘以负的缩放因子α
3. 效果：使模型无法从特征中识别说话人身份
数学表示：
forward: y = x
backward: ∂L/∂x = -α * ∂L/∂y
"""
@staticmethod
def forward(ctx, x, alpha):
"""
前向传播：直接传递输入
Args:
x: 输入特征
alpha: 梯度反转强度
"""
ctx.alpha = alpha # 保存alpha用于反向传播
return x.view_as(x)
@staticmethod
def backward(ctx, grad_output):
"""
反向传播：梯度符号反转
Args:
grad_output: 来自上层的梯度
Returns:
反转后的梯度
"""
return grad_output.neg() * ctx.alpha, None
def gradient_reverse(x, alpha=1.0):
"""梯度反转函数包装器"""
return GradientReversalLayer.apply(x, alpha)说话人分类器：
# 说话人分类头（用于对抗训练）
if self.use_adversarial:
self.speaker_classifier = nn.Sequential(
nn.Linear(hidden_size * 4, hidden_size), # 特征降维
nn.ReLU(inplace=True), # 非线性激活
nn.Dropout(self.dropout_rate), # 防过拟合
nn.Linear(hidden_size, hidden_size // 2), # 进一步降维
nn.ReLU(inplace=True),
nn.Dropout(self.dropout_rate),
nn.Linear(hidden_size // 2, 10) # 10个说话人分类
)2. 多头自注意力机制
原理：通过多头注意力机制捕获序列中的长距离依赖关系，增强情感特征表示。
class MultiHeadSelfAttention(nn.Module):
"""
多头自注意力机制
原理：
1. 将输入特征分别投影到Q、K、V空间
2. 计算多个注意力头的注意力权重
3. 加权聚合特征信息
4. 通过残差连接和层归一化稳定训练
注意力公式：
Attention(Q,K,V) = softmax(QK^T/√d_k)V
MultiHead = Concat(head_1, ..., head_h)W^O
"""
def __init__(self, d_model, num_heads, dropout=0.1):
super(MultiHeadSelfAttention, self).__init__()
assert d_model % num_heads == 0
self.d_model = d_model # 模型维度
self.num_heads = num_heads # 注意力头数量
self.d_k = d_model // num_heads # 每个头的维度
# 线性投影层
self.w_q = nn.Linear(d_model, d_model) # Query投影
self.w_k = nn.Linear(d_model, d_model) # Key投影
self.w_v = nn.Linear(d_model, d_model) # Value投影
self.w_o = nn.Linear(d_model, d_model) # 输出投影
# 正则化层
self.dropout = nn.Dropout(dropout)
self.layer_norm = nn.LayerNorm(d_model)
def forward(self, x):
"""
前向传播
Args:
x: [batch_size, seq_len, d_model] 输入特征
Returns:
注意力增强后的特征和注意力权重
"""
batch_size, seq_len, d_model = x.size()
# 保存残差连接
residual = x
# 1. 线性投影到Q、K、V
Q = self.w_q(x).view(batch_size, seq_len, self.num_heads, self.d_k).transpose(1, 2)
K = self.w_k(x).view(batch_size, seq_len, self.num_heads, self.d_k).transpose(1, 2)
V = self.w_v(x).view(batch_size, seq_len, self.num_heads, self.d_k).transpose(1, 2)
# 2. 计算缩放点积注意力
attention_scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
attention_weights = F.softmax(attention_scores, dim=-1)
attention_weights = self.dropout(attention_weights)
# 3. 加权聚合Value
context = torch.matmul(attention_weights, V)
# 4. 拼接多头输出
context = context.transpose(1, 2).contiguous().view(
batch_size, seq_len, self.d_model
)
# 5. 输出投影
output = self.w_o(context)
# 6. 残差连接和层归一化
output = self.layer_norm(output + residual)
return output, attention_weights.mean(dim=1) # 返回平均注意力权重用于可视化3. 位置编码
class PositionalEncoding(nn.Module):
"""
正弦位置编码
原理：
使用不同频率的正弦和余弦函数为序列中的每个位置生成唯一的编码
公式：
PE(pos, 2i) = sin(pos / 10000^(2i/d_model))
PE(pos, 2i+1) = cos(pos / 10000^(2i/d_model))
"""
def __init__(self, d_model, max_length=5000):
super(PositionalEncoding, self).__init__()
# 创建位置编码矩阵
pe = torch.zeros(max_length, d_model)
position = torch.arange(0, max_length).unsqueeze(1).float()
# 计算除数项
div_term = torch.exp(torch.arange(0, d_model, 2).float() *
-(math.log(10000.0) / d_model))
# 应用正弦和余弦函数
pe[:, 0::2] = torch.sin(position * div_term) # 偶数位置使用sin
pe[:, 1::2] = torch.cos(position * div_term) # 奇数位置使用cos
self.register_buffer('pe', pe.unsqueeze(0))
def forward(self, x):
"""添加位置编码到输入特征"""
seq_len = x.size(1)
pos_encoding = self.pe[:, :seq_len, :].to(x.device)
return x + pos_encoding🏗️ 代码实现详解
1. 增强GRU模型架构
class EnhancedGRUModel(nn.Module):
"""
增强的GRU模型 - 针对跨说话人情感识别优化
架构特点：
1. 输入投影 + 位置编码
2. 说话人归一化层 (AdaIN)
3. 多层双向GRU + 层归一化 + 残差连接
4. 多头自注意力机制
5. 特征增强模块
6. 双路分类头（情感 + 说话人对抗）
"""
def __init__(self, input_size, hidden_size, output_size, args):
super(EnhancedGRUModel, self).__init__()
# 基础参数
self.input_size = input_size
self.hidden_size = hidden_size
self.output_size = output_size
self.num_layers = args.dia_layers
self.dropout_rate = args.dropout
# 功能开关
self.use_attention = args.attention
self.use_speaker_norm = getattr(args, 'speaker_norm', True)
self.use_adversarial = getattr(args, 'speaker_adversarial', True)
# 1. 输入处理层
self.input_projection = nn.Linear(input_size, hidden_size * 2)
self.pos_encoding = PositionalEncoding(hidden_size * 2)
# 2. 说话人归一化层
if self.use_speaker_norm:
self.speaker_norm = AdaptiveInstanceNormalization(hidden_size * 2)
# 3. 多层双向GRU
self.gru_layers = nn.ModuleList()
self.layer_norms = nn.ModuleList()
for i in range(self.num_layers):
input_dim = hidden_size * 2 if i == 0 else hidden_size * 4
self.gru_layers.append(
nn.GRU(input_dim, hidden_size * 2, batch_first=True,
bidirectional=True, dropout=self.dropout_rate if i < self.num_layers-1 else 0)
)
self.layer_norms.append(nn.LayerNorm(hidden_size * 4))
# 4. 多头自注意力
if self.use_attention:
self.self_attention = MultiHeadSelfAttention(
d_model=hidden_size * 4,
num_heads=8,
dropout=self.dropout_rate
)
# 5. 特征增强模块
self.feature_enhancement = nn.Sequential(
nn.Linear(hidden_size * 4, hidden_size * 2),
nn.ReLU(inplace=True),
nn.Dropout(self.dropout_rate),
nn.Linear(hidden_size * 2, hidden_size * 2),
nn.ReLU(inplace=True),
nn.Dropout(self.dropout_rate)
)
# 6. 全局池化策略
self.global_pooling = nn.AdaptiveAvgPool1d(1) # 平均池化
self.global_max_pooling = nn.AdaptiveMaxPool1d(1) # 最大池化
# 7. 情感分类头
self.emotion_classifier = nn.Sequential(
nn.Linear(hidden_size * 4, hidden_size),
nn.ReLU(inplace=True),
nn.Dropout(self.dropout_rate),
nn.Linear(hidden_size, hidden_size // 2),
nn.ReLU(inplace=True),
nn.Dropout(self.dropout_rate),
nn.Linear(hidden_size // 2, output_size)
)
# 8. 说话人分类头（对抗训练）
if self.use_adversarial:
self.speaker_classifier = nn.Sequential(
nn.Linear(hidden_size * 4, hidden_size),
nn.ReLU(inplace=True),
nn.Dropout(self.dropout_rate),
nn.Linear(hidden_size, hidden_size // 2),
nn.ReLU(inplace=True),
nn.Dropout(self.dropout_rate),
nn.Linear(hidden_size // 2, 10) # IEMOCAP有10个说话人
)
self.dropout = nn.Dropout(self.dropout_rate)
self._init_weights()2. 前向传播流程
def forward(self, x, alpha=1.0):
"""
前向传播
Args:
x: [batch_size, seq_len, input_size] 输入特征
alpha: 梯度反转强度（用于对抗训练）
Returns:
dict: 包含情感和说话人预测结果的字典
"""
batch_size, seq_len, _ = x.size()
# 1. 输入投影和位置编码
x = self.input_projection(x) # [batch_size, seq_len, hidden_size*2]
x = self.pos_encoding(x) # 添加位置信息
# 2. 说话人归一化（消除说话人特征）
if self.use_speaker_norm:
x = self.speaker_norm(x)
x = self.dropout(x)
# 3. 多层双向GRU处理
for i, (gru_layer, layer_norm) in enumerate(zip(self.gru_layers, self.layer_norms)):
residual = x if i > 0 else None
gru_out, _ = gru_layer(x) # [batch_size, seq_len, hidden_size*4]
gru_out = layer_norm(gru_out)
# 残差连接（从第二层开始）
if residual is not None and residual.size(-1) == gru_out.size(-1):
gru_out = gru_out + residual
x = self.dropout(gru_out)
# 4. 多头自注意力增强
attention_weights = None
if self.use_attention:
x, attention_weights = self.self_attention(x)
# 5. 特征增强
enhanced_features = self.feature_enhancement(x)
combined_features = torch.cat([x, enhanced_features], dim=-1)
combined_features = combined_features[:, :, :self.hidden_size*4]
# 6. 全局池化
pooling_input = combined_features.transpose(1, 2)
avg_pooled = self.global_pooling(pooling_input).squeeze(-1)
max_pooled = self.global_max_pooling(pooling_input).squeeze(-1)
# 拼接池化结果
pooled_features = torch.cat([avg_pooled, max_pooled], dim=1)
final_features = pooled_features[:, :self.hidden_size*4]
# 7. 情感分类
emotion_logits = self.emotion_classifier(final_features)
# 8. 说话人对抗分类
speaker_logits = None
if self.use_adversarial:
# 应用梯度反转
adversarial_features = gradient_reverse(final_features, alpha)
speaker_logits = self.speaker_classifier(adversarial_features)
return {
'emotion_logits': emotion_logits,
'speaker_logits': speaker_logits,
'attention_weights': attention_weights,
'features': final_features
}⚙️ 参数配置说明
1. 模型结构参数
# 基础架构参数
input_size = 768 # HuBERT特征维度
hidden_size = 256 # GRU隐藏层大小
output_size = 4 # 情感类别数量（angry, happy, neutral, sad）
dia_layers = 3 # GRU层数
# 正则化参数
dropout = 0.3 # Dropout概率
max_grad_norm = 1.0 # 梯度裁剪阈值
l2_reg = 1e-5 # L2正则化权重2. 优化策略参数
# 学习率调度
learning_rate = 0.0005 # 初始学习率
lr_schedule = 'cosine' # 学习率调度策略
warmup_steps = 1000 # 预热步数
min_lr = 1e-7 # 最小学习率
# 训练策略
batch_size = 32 # 批次大小
epochs = 50 # 训练轮数
patience = 10 # 早停耐心值3. 说话人无关化参数
# AdaIN归一化
speaker_norm = True # 启用说话人归一化
eps = 1e-5 # 数值稳定性参数
# 对抗训练
speaker_adversarial = True # 启用对抗训练
adversarial_weight = 0.05 # 对抗损失权重
alpha_schedule = 'linear' # 梯度反转强度调度
max_alpha = 1.0 # 最大梯度反转强度4. 注意力机制参数
# 多头注意力
attention = True # 启用注意力机制
num_heads = 8 # 注意力头数量
attention_dropout = 0.1 # 注意力dropout🎯 训练策略优化
1. 综合损失函数
def compute_loss(self, model_outputs, targets, speaker_targets, alpha=1.0):
"""
综合损失函数
组成：
1. 主任务损失：情感分类交叉熵损失
2. 对抗损失：说话人混淆损失
3. 正则化损失：L2权重衰减
Args:
model_outputs: 模型输出字典
targets: 情感标签
speaker_targets: 说话人标签
alpha: 梯度反转强度
Returns:
total_loss: 总损失
loss_dict: 各项损失详情
"""
emotion_logits = model_outputs['emotion_logits']
speaker_logits = model_outputs['speaker_logits']
# 1. 情感分类损失（主要任务）
emotion_loss = F.cross_entropy(emotion_logits, targets)
total_loss = emotion_loss
loss_dict = {'emotion_loss': emotion_loss.item()}
# 2. 说话人对抗损失
if speaker_logits is not None and self.args.speaker_adversarial:
speaker_loss = F.cross_entropy(speaker_logits, speaker_targets)
total_loss += self.args.adversarial_weight * speaker_loss
loss_dict['speaker_loss'] = speaker_loss.item()
# 3. 正则化损失
if self.args.l2_reg > 0:
l2_loss = sum(torch.norm(p, 2) for p in model_outputs.get('regularization_params', []))
total_loss += self.args.l2_reg * l2_loss
loss_dict['l2_loss'] = l2_loss.item() if isinstance(l2_loss, torch.Tensor) else l2_loss
loss_dict['total_loss'] = total_loss.item()
return total_loss, loss_dict2. 动态对抗训练策略
def get_alpha_schedule(self, epoch, total_epochs):
"""
动态调整梯度反转强度
策略：
1. 前期（epoch < 5）：α = 0，专注情感分类
2. 中期（5 ≤ epoch < total_epochs*0.7）：线性增长
3. 后期：保持最大值
"""
if epoch < 5:
return 0.0 # 前期不使用对抗训练
elif epoch < total_epochs * 0.7:
# 线性增长阶段
progress = (epoch - 5) / (total_epochs * 0.7 - 5)
return progress * self.args.max_alpha
else:
return self.args.max_alpha # 后期保持最大值3. 学习率调度策略
def create_lr_scheduler(self, optimizer, total_steps):
"""
创建学习率调度器
策略：余弦退火 + 预热
1. 预热阶段：线性增长到初始学习率
2. 主训练阶段：余弦退火到最小学习率
3. 重启机制：周期性重启提升性能
"""
# 预热调度器
warmup_scheduler = LinearLR(
optimizer,
start_factor=0.1,
end_factor=1.0,
total_iters=self.args.warmup_steps
)
# 余弦退火调度器
cosine_scheduler = CosineAnnealingWarmRestarts(
optimizer,
T_0=total_steps // 4, # 第一个周期长度
T_mult=2, # 周期倍增因子
eta_min=self.args.min_lr
)
# 组合调度器
scheduler = SequentialLR(
optimizer,
schedulers=[warmup_scheduler, cosine_scheduler],
milestones=[self.args.warmup_steps]
)
return scheduler4. 数据增强策略
def apply_augmentation(self, audio_features):
"""
训练时数据增强
策略：
1. 高斯噪声：增加鲁棒性
2. 时间拉伸：模拟语速变化
3. 特征掩蔽：防止过拟合
"""
if self.is_training:
# 1. 添加高斯噪声
if torch.rand(1) < 0.3:
noise = torch.randn_like(audio_features) * self.noise_factor
audio_features = audio_features + noise
# 2. 时间维度拉伸（简化版）
if torch.rand(1) < 0.2:
stretch_factor = 1.0 + torch.rand(1) * self.time_stretch_factor * 2 - self.time_stretch_factor
# 实际实现需要插值操作
# 3. 特征掩蔽
if torch.rand(1) < 0.2:
mask_size = int(audio_features.size(0) * 0.1)
mask_start = torch.randint(0, max(1, audio_features.size(0) - mask_size), (1,))
audio_features[mask_start:mask_start + mask_size] *= 0.1
return audio_features📊 性能监控与可视化
1. 训练监控指标
class TrainingMonitor:
"""训练过程监控器"""
def __init__(self):
self.metrics = {
'train_loss': [],
'val_loss': [],
'train_acc': [],
'val_acc': [],
'train_f1': [],
'val_f1': [],
'learning_rate': [],
'alpha_values': []
}
def update_metrics(self, epoch, train_metrics, val_metrics, lr, alpha):
"""更新训练指标"""
self.metrics['train_loss'].append(train_metrics['loss'])
self.metrics['val_loss'].append(val_metrics['loss'])
self.metrics['train_acc'].append(train_metrics['accuracy'])
self.metrics['val_acc'].append(val_metrics['accuracy'])
self.metrics['train_f1'].append(train_metrics['f1_score'])
self.metrics['val_f1'].append(val_metrics['f1_score'])
self.metrics['learning_rate'].append(lr)
self.metrics['alpha_values'].append(alpha)
def plot_training_curves(self, save_path):
"""绘制训练曲线"""
fig, axes = plt.subplots(2, 3, figsize=(18, 12))
# 损失曲线
axes[0, 0].plot(self.metrics['train_loss'], label='Train Loss', color='blue')
axes[0, 0].plot(self.metrics['val_loss'], label='Val Loss', color='red')
axes[0, 0].set_title('Loss Curves')
axes[0, 0].legend()
# 准确率曲线
axes[0, 1].plot(self.metrics['train_acc'], label='Train Acc', color='blue')
axes[0, 1].plot(self.metrics['val_acc'], label='Val Acc', color='red')
axes[0, 1].set_title('Accuracy Curves')
axes[0, 1].legend()
# F1分数曲线
axes[0, 2].plot(self.metrics['train_f1'], label='Train F1', color='blue')
axes[0, 2].plot(self.metrics['val_f1'], label='Val F1', color='red')
axes[0, 2].set_title('F1 Score Curves')
axes[0, 2].legend()
# 学习率变化
axes[1, 0].plot(self.metrics['learning_rate'], color='green')
axes[1, 0].set_title('Learning Rate Schedule')
axes[1, 0].set_yscale('log')
# Alpha值变化
axes[1, 1].plot(self.metrics['alpha_values'], color='orange')
axes[1, 1].set_title('Adversarial Alpha Schedule')
# 验证损失放大图
axes[1, 2].plot(self.metrics['val_loss'], color='red', linewidth=2)
axes[1, 2].set_title('Validation Loss (Detailed)')
plt.tight_layout()
plt.savefig(save_path, dpi=300, bbox_inches='tight')
plt.close()2. 跨说话人性能分析
def analyze_speaker_performance(self, model, test_loader, save_dir):
"""
跨说话人性能分析
分析内容：
1. 各说话人准确率对比
2. 性能方差分析
3. 性别差异分析
4. 会话差异分析
"""
model.eval()
speaker_results = defaultdict(list)
with torch.no_grad():
for batch in test_loader:
features = batch['audio_features'].to(self.device)
labels = batch['emotion_label'].to(self.device)
speakers = batch['speaker']
outputs = model(features)
predictions = torch.argmax(outputs['emotion_logits'], dim=1)
for pred, label, speaker in zip(predictions.cpu(), labels.cpu(), speakers):
speaker_results[speaker].append({
'prediction': pred.item(),
'label': label.item(),
'correct': pred.item() == label.item()
})
# 计算各说话人性能
speaker_metrics = {}
for speaker, results in speaker_results.items():
correct = sum(r['correct'] for r in results)
total = len(results)
accuracy = correct / total if total > 0 else 0
# 计算F1分数
y_true = [r['label'] for r in results]
y_pred = [r['prediction'] for r in results]
f1 = f1_score(y_true, y_pred, average='weighted')
speaker_metrics[speaker] = {
'accuracy': accuracy,
'f1_score': f1,
'total_samples': total
}
# 可视化结果
self.plot_speaker_performance(speaker_metrics, save_dir)
return speaker_metrics
def plot_speaker_performance(self, speaker_metrics, save_dir):
"""绘制说话人性能对比图"""
speakers = list(speaker_metrics.keys())
accuracies = [speaker_metrics[s]['accuracy'] for s in speakers]
f1_scores = [speaker_metrics[s]['f1_score'] for s in speakers]
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6))
# 准确率对比
bars1 = ax1.bar(speakers, accuracies, color='skyblue', alpha=0.7)
ax1.set_title('Speaker-wise Accuracy Comparison')
ax1.set_ylabel('Accuracy')
ax1.set_ylim(0, 1)
# 添加数值标签
for bar, acc in zip(bars1, accuracies):
ax1.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.01,
f'{acc:.3f}', ha='center', va='bottom')
# F1分数对比
bars2 = ax2.bar(speakers, f1_scores, color='lightcoral', alpha=0.7)
ax2.set_title('Speaker-wise F1 Score Comparison')
ax2.set_ylabel('F1 Score')
ax2.set_ylim(0, 1)
# 添加数值标签
for bar, f1 in zip(bars2, f1_scores):
ax2.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.01,
f'{f1:.3f}', ha='center', va='bottom')
plt.tight_layout()
plt.savefig(f'{save_dir}/speaker_performance_comparison.png', dpi=300, bbox_inches='tight')
plt.close()🎯 使用示例
1. 模型初始化
# 创建参数对象
args = argparse.Namespace(
input_size=768,
hidden_size=256,
output_size=4,
dia_layers=3,
dropout=0.3,
attention=True,
speaker_norm=True,
speaker_adversarial=True,
adversarial_weight=0.05,
max_alpha=1.0
)
# 初始化模型
model = EnhancedGRUModel(
input_size=args.input_size,
hidden_size=args.hidden_size,
output_size=args.output_size,
args=args
)
print(f"模型参数量: {sum(p.numel() for p in model.parameters()):,}")2. 训练流程
# 创建训练器
trainer = AdvancedTrainer(args)
# 训练模型
best_model_path = trainer.train_model(
model=model,
train_loader=train_loader,
val_loader=val_loader,
save_dir='./experiments'
)
print(f"最佳模型保存在: {best_model_path}")3. 性能评估
# 加载最佳模型
model.load_state_dict(torch.load(best_model_path))
# 评估跨说话人性能
evaluator = SpeakerIndependenceEvaluator(model, args)
results = evaluator.evaluate(test_loader, save_dir='./evaluation_results')
print("跨说话人性能评估完成！")
print(f"总体准确率: {results['overall_accuracy']:.4f}")
print(f"平均F1分数: {results['average_f1']:.4f}")
print(f"性能标准差: {results['performance_std']:.4f}")📈 预期改进效果
性能提升预期
| 指标 | 原始模型 | 增强模型 | 改进幅度 |
|---|---|---|---|
| 总体准确率 | 65-70% | 75-80% | +10-15% |
| 跨说话人F1 | 0.62-0.67 | 0.72-0.77 | +0.10-0.15 |
| 性能方差 | 0.08-0.12 | 0.04-0.08 | -50%↓ |
| 收敛速度 | 30-40轮 | 20-25轮 | 快25-50% |
技术优势
- 🎯 说话人无关性：AdaIN归一化 + 对抗训练显著减少说话人偏见
- 🚀 训练效率：动态学习率调度 + 早停机制加速收敛
- 💪 模型鲁棒性：多种正则化技术提升泛化能力
- 📊 全面监控：实时可视化训练过程和性能指标
🔧 故障排除
常见问题及解决方案
内存不足
# 减少批次大小 args.batch_size = 16 # 从32降到16 # 启用梯度累积 args.gradient_accumulation_steps = 2训练不稳定
# 降低学习率 args.learning_rate = 0.0001 # 增加梯度裁剪 args.max_grad_norm = 0.5过拟合严重
# 增加Dropout args.dropout = 0.5 # 增加L2正则化 args.l2_reg = 1e-4对抗训练不收敛
# 降低对抗权重 args.adversarial_weight = 0.01 # 延迟对抗训练开始时间 args.adversarial_start_epoch = 10
📚 参考文献
- AdaIN: Huang, X., & Belongie, S. (2017). Arbitrary style transfer in real-time with adaptive instance normalization.
- Gradient Reversal: Ganin, Y., & Lempitsky, V. (2015). Unsupervised domain adaptation by backpropagation.
- Multi-Head Attention: Vaswani, A., et al. (2017). Attention is all you need.
- HuBERT: Hsu, W. N., et al. (2021). HuBERT: Self-supervised speech representation learning by masked prediction.
📝 文档版本: v2.0 | 更新日期: 2024-09-26 | 作者: AI Assistant
IEMOCAP语音情感识别系统深度源码解析
目录
1. 项目整体架构与模块划分
1.1 系统架构概览
该IEMOCAP语音情感识别系统采用端到端的深度学习架构，实现从原始音频信号到情感类别的直接映射。整体数据流遵循现代语音处理的最佳实践：
原始音频 → 预处理标准化 → HuBERT特征编码 → 双向GRU序列建模 → 注意力机制增强 → 全局池化 → 分类输出这种设计充分利用了自监督预训练模型的强大特征提取能力，结合循环神经网络对时序信息的精确建模，最终通过注意力机制实现对情感关键信息的动态聚焦。
1.2 核心模块划分
数据预处理模块 (Data_prepocessing.py)
- 功能职责：负责IEMOCAP数据集的标准化处理，包括音频长度统一、采样率标准化、情感标签映射
- 核心价值：确保模型输入的一致性，为后续特征提取提供标准化的数据基础
- 技术特点：采用固定3秒时长策略，平衡信息保留与计算效率
模型架构模块 (models/GRU.py)
- SpeechRecognitionModel：主模型容器，整合HuBERT特征提取器与GRU序列建模器
- GRUModel：序列建模核心，负责时序特征的深度学习与情感分类
- MatchingAttention：注意力机制实现，提供动态特征加权能力
训练与验证模块 (train.py)
- 交叉验证策略：采用5折交叉验证，确保模型泛化能力的可靠评估
- 优化策略：使用AdamW优化器，结合适当的学习率调度
- 性能评估：多指标综合评估，包括准确率、召回率、F1分数
推理与应用模块 (DEMO.py, GUI情感识别2.py)
- 单样本推理：提供简洁的模型测试接口
- 实时音频处理：支持麦克风实时录音与情感识别
- 用户界面：完整的PyQt5图形界面，提供直观的交互体验
2. 核心组件功能深度解析
2.1 HubertModel语音特征编码器
2.1.1 模型选择的深层考量
self.feature_extractor = HubertModel.from_pretrained("facebook/hubert-base-ls960")HuBERT (Hidden-Unit BERT) 的选择体现了对语音表示学习前沿技术的深刻理解：
自监督学习优势：
- HuBERT通过掩码预测任务在大规模无标注语音数据上预训练，学习到了丰富的语音表示
- 相比传统的MFCC、Mel频谱等手工特征，HuBERT能够自动发现语音中的层次化模式
- 预训练在960小时LibriSpeech数据上进行，涵盖了多样化的语音模式和声学环境
分层特征表示：
- 底层：捕获音素级别的声学特征，如共振峰、基频变化
- 中层：建模音节和词汇级别的语音模式
- 高层：编码语义和韵律信息，这些信息对情感识别至关重要
768维特征向量的信息密度：
- 每个时间步输出768维密集向量，相比传统特征（如39维MFCC）具有更强的表达能力
- 高维特征空间能够更精细地区分不同情感状态下的语音变化
2.1.2 特征提取的技术实现
def forward(self, input_waveform):
features = self.feature_extractor(input_waveform).last_hidden_state # [batch, seq_len, 768]
logits = self.Utterance_net(features)
return logits, features处理流程的技术细节：
卷积特征提取：
- HuBERT首先通过7层1D卷积网络处理原始波形
- 每层卷积逐步降低时间分辨率，提高特征抽象层次
- 卷积核设计考虑了语音信号的时频特性
Transformer编码：
- 12层Transformer编码器进行序列建模
- 自注意力机制捕获长距离依赖关系
- 位置编码保持时序信息的完整性
特征选择策略：
last_hidden_state提供最高层的语义表示- 这一层特征最适合下游分类任务，平衡了特征抽象程度与任务相关性
2.1.3 音频预处理的工程考量
def process_wav_file(wav_file, time_seconds):
waveform, sample_rate = torchaudio.load(wav_file)
target_length = int(time_seconds * sample_rate)
if waveform.size(1) > target_length:
waveform = waveform[:, :target_length] # 时间裁剪
else:
padding_length = target_length - waveform.size(1)
waveform = torch.nn.functional.pad(waveform, (0, padding_length)) # 零填充
return waveform, sample_rate3秒固定长度的设计rationale：
- 计算效率：固定长度便于批处理，提高GPU利用率
- 信息充分性：3秒足以包含完整的情感表达，涵盖词汇、韵律、语调变化
- 内存管理：避免变长序列带来的内存碎片化问题
- 模型一致性：确保训练和推理阶段的输入格式完全一致
零填充 vs 重复填充的选择：
- 零填充避免了人工引入的周期性模式
- 保持了原始语音的自然边界特性
- 与HuBERT预训练时的处理方式保持一致
2.2 GRUModel双向序列建模器
2.2.1 架构设计的深层逻辑
class GRUModel(nn.Module):
def __init__(self, input_size, hidden_size, output_size, args):
self.bigru = nn.GRU(input_size, hidden_size, batch_first=True,
num_layers=self.num_layers, bidirectional=True)
self.input2hidden = nn.Linear(512, hidden_size * 2)
self.hidden2label = nn.Linear(hidden_size * 2, output_size)双向GRU的理论基础：
- 前向信息流：捕获从语音开始到当前时刻的情感发展轨迹
- 后向信息流：利用未来信息为当前时刻提供上下文约束
- 信息融合：前后向隐状态的拼接提供了更完整的时序表示
多层设计的必要性：
- 层次化抽象：底层捕获局部时序模式，高层建模全局情感动态
- 非线性增强：多层结构增加模型的非线性表达能力
- 梯度流优化：适当的层数平衡了表达能力与梯度传播效率
2.2.2 前向传播的精密设计
def forward(self, U):
U = self.dropout(U) # 输入正则化
emotions, hidden = self.bigru(U) # [batch, seq, 512]
# 注意力机制增强
if self.attention:
att_emotions = []
for t in emotions:
att_em, alpha_ = self.matchatt(emotions, t, mask=None)
att_emotions.append(att_em.unsqueeze(0))
att_emotions = torch.cat(att_emotions, dim=0)
emotions = att_emotions
# 全局特征聚合
gru_out = torch.transpose(emotions, 1, 2) # [batch, 512, seq]
gru_out = F.tanh(gru_out)
gru_out = F.max_pool1d(gru_out, gru_out.size(2)).squeeze(2) # 全局最大池化
# 分类映射
Out_in = self.relu(gru_out)
Out_in = self.dropout(Out_in)
Out_out = self.hidden2label(Out_in) # [batch, num_classes]
return Out_out关键处理步骤的技术分析：
输入Dropout：
- 在特征层面引入随机性，增强模型泛化能力
- 防止模型过度依赖HuBERT特征的特定维度
双向GRU处理：
- 输出维度为512（256×2），融合前后向信息
batch_first=True设计便于后续处理和调试
注意力增强（可选）：
- 为每个时间步计算全局注意力权重
- 动态调整不同时刻特征的重要性
- 缓解长序列信息衰减问题
全局最大池化：
- 提取序列中的最显著特征
- 实现从变长序列到固定长度表示的转换
- 保留最强的情感激活信号
分类头映射：
- 线性变换将512维特征映射到4类情感输出
- 无偏置设计简化模型，减少过拟合风险
2.3 MatchingAttention注意力机制
2.3.1 注意力设计的理论基础
class MatchingAttention(nn.Module):
def __init__(self, mem_dim, cand_dim, alpha_dim=None, att_type='general'):
if att_type=='general':
self.transform = nn.Linear(cand_dim, mem_dim, bias=False)注意力机制的核心思想：
- 查询-键-值模式：将当前时刻作为查询，整个序列作为键和值
- 相似度计算：通过学习到的变换矩阵计算查询与键的匹配程度
- 动态权重分配：根据相似度为不同时刻分配注意力权重
General Attention的优势：
- 维度灵活性：通过线性变换处理不同维度的输入
- 参数效率：相比concat attention参数更少，训练更稳定
- 计算效率：矩阵乘法操作便于GPU并行加速
2.3.2 注意力计算的数学实现
def forward(self, M, x, mask=None):
# M: [seq_len, batch, mem_dim] - 记忆序列（所有时刻的隐状态）
# x: [batch, cand_dim] - 查询向量（当前时刻的隐状态）
if self.att_type=='general':
M_ = M.permute(1,2,0) # [batch, mem_dim, seq_len]
x_ = self.transform(x).unsqueeze(1) # [batch, 1, mem_dim]
alpha = F.softmax(torch.bmm(x_, M_), dim=2) # [batch, 1, seq_len]
attn_pool = torch.bmm(alpha, M.transpose(0,1))[:,0,:] # [batch, mem_dim]
return attn_pool, alpha计算流程的深层解析：
查询变换：
x_ = self.transform(x).unsqueeze(1) # [batch, 1, mem_dim]- 将当前时刻特征变换到记忆空间
- 学习查询与记忆之间的最优匹配关系
相似度计算：
alpha = F.softmax(torch.bmm(x_, M_), dim=2) # [batch, 1, seq_len]- 批量矩阵乘法计算所有时刻的相似度分数
- Softmax归一化确保权重和为1
加权聚合：
attn_pool = torch.bmm(alpha, M.transpose(0,1))[:,0,:] # [batch, mem_dim]- 根据注意力权重对所有时刻特征进行加权平均
- 生成融合全局信息的上下文向量
2.3.3 注意力在情感识别中的作用机制
if self.attention:
att_emotions = []
alpha = []
for t in emotions: # 对序列中每个时间步
att_em, alpha_ = self.matchatt(emotions, t, mask=None)
att_emotions.append(att_em.unsqueeze(0))
alpha.append(alpha_[:, 0, :])
att_emotions = torch.cat(att_emotions, dim=0)
emotions = att_emotions注意力增强的情感建模价值：
关键时刻识别：
- 自动识别语音中情感表达最强烈的时间段
- 例如：语调变化剧烈的词汇、停顿前后的重音
上下文整合：
- 为每个时刻提供全序列的上下文信息
- 避免局部特征的误导，提高分类稳定性
长距离依赖建模：
- 缓解GRU在长序列上的信息衰减问题
- 保持序列开始和结束部分信息的有效传递
可解释性增强：
- 注意力权重提供模型决策的可视化依据
- 帮助理解模型关注的语音特征模式
2.4 分类头与激活函数的精心设计
2.4.1 分类头的架构选择
self.hidden2label = nn.Linear(hidden_size * 2, output_size) # 512 -> 4线性分类头的设计考量：
- 简洁性原则：避免过度复杂的分类器，防止过拟合
- 特征充分性：512维GRU输出已包含丰富的情感判别信息
- 计算效率：线性变换计算简单，便于实时应用
2.4.2 激活函数的层次化应用
gru_out = F.tanh(gru_out) # 序列特征激活
Out_in = self.relu(gru_out) # 分类前激活
# 分类层无激活，输出原始logits激活函数选择的深层逻辑：
Tanh激活：
- 将序列特征压缩到[-1,1]区间
- 增强特征的对比度，突出显著变化
- 对称性质适合双向GRU的输出特征
LeakyReLU激活：
- 保持梯度流动，避免死神经元问题
- 负斜率参数允许负值信息的部分保留
- 在分类前提供非线性变换能力
无激活输出：
- 分类层输出原始logits，便于交叉熵损失计算
- 保持数值稳定性，避免梯度消失
3. 完整数据流路径分析
3.1 训练阶段数据流
训练流程的关键环节分析：
数据预处理阶段：
- IEMOCAP数据集包含多种情感类别，需要标准化映射
- 音频长度不一致问题通过3秒固定长度策略解决
- 采样率统一为16kHz，匹配HuBERT预训练配置
特征提取阶段：
- HuBERT模型冻结参数，仅用于特征提取
- 768维特征向量包含丰富的语音语义信息
- 批处理方式提高特征提取效率
模型训练阶段：
- 5折交叉验证确保结果的统计显著性
- 批次大小32平衡内存占用与梯度估计质量
- AdamW优化器结合权重衰减，防止过拟合
模型保存阶段：
- 保存完整的state_dict，便于后续加载
- 模型文件包含所有可训练参数
3.2 推理阶段数据流
推理流程的技术细节：
输入处理多样性：
- 支持WAV文件和实时麦克风两种输入模式
- 统一的预处理流程确保输入格式一致性
特征提取一致性：
- 使用与训练时相同的processor和预处理参数
- 确保特征分布的一致性
模型推理优化：
torch.no_grad()上下文管理器减少内存占用- 批处理维度的动态调整适应不同输入格式
结果后处理：
- Softmax提供概率分布，增强结果可信度
- 置信度计算帮助评估预测质量
3.3 GUI实时处理流
实时处理的工程挑战与解决方案：
线程安全设计：
- AudioRecorder独立线程避免UI阻塞
- 信号-槽机制确保线程间安全通信
音频缓冲管理：
- 滑动窗口机制保持最新5秒音频
- 自动内存管理避免缓冲区溢出
实时性能优化：
- 模型预加载减少推理延迟
- 异步处理提高响应速度
用户体验设计：
- 实时反馈提供即时情感识别结果
- 历史记录功能支持结果回顾
4. 关键参数含义与性能影响
4.1 模型结构参数深度分析
| 参数名 | 默认值 | 参数含义 | 性能影响机制 | 调优建议 |
|---|---|---|---|---|
hidden_size |
256 | GRU隐状态维度 | 表达能力：更大维度提供更强特征表达 计算复杂度：线性影响参数量和计算时间 过拟合风险：过大可能导致训练过拟合 |
128-512范围内调优 结合dropout防过拟合 |
dia_layers |
2 | GRU堆叠层数 | 抽象层次：多层提供更深层次的特征抽象 梯度传播：过深可能导致梯度消失 训练稳定性：层数适中保证训练稳定 |
1-4层为宜 配合梯度裁剪使用 |
utt_insize |
768 | HuBERT输出维度 | 特征丰富度：固定值，由预训练模型决定 匹配要求：必须与HuBERT输出维度一致 |
不可调整 由预训练模型决定 |
out_class |
4 | 情感类别数量 | 任务复杂度：类别数直接影响分类难度 数据平衡：需要各类别样本相对平衡 |
根据具体任务确定 考虑类别平衡策略 |
4.2 训练超参数深度分析
| 参数名 | 默认值 | 参数含义 | 性能影响机制 | 调优策略 |
|---|---|---|---|---|
learning_rate |
1e-5 | 学习率 | 收敛速度：过大易震荡，过小收敛慢 最终性能：影响模型收敛到的局部最优解 训练稳定性：适当学习率保证训练稳定 |
1e-6到1e-4范围 使用学习率调度 |
dropout |
0.2 | 随机失活概率 | 正则化强度：防止过拟合的关键参数 模型容量：过大影响模型表达能力 泛化能力：适当dropout提升泛化性能 |
0.1-0.5范围调优 根据数据集大小调整 |
batch_size |
32 | 批次大小 | 梯度估计：影响梯度估计的准确性 内存占用：直接影响GPU内存需求 训练速度：影响每个epoch的训练时间 |
16-64根据显存调整 考虑梯度累积 |
attention |
True | 注意力机制开关 | 长序列建模：提升长距离依赖捕获能力 计算开销：增加约20%的计算时间 模型复杂度：增加模型参数量 |
根据序列长度决定 短序列可关闭 |
4.3 数据处理参数深度分析
| 参数名 | 默认值 | 参数含义 | 性能影响机制 | 设计考量 |
|---|---|---|---|---|
time_seconds |
3 | 音频固定长度 | 信息完整性：时长影响情感信息的完整性 计算效率：长度直接影响计算复杂度 内存占用：影响批处理的内存需求 |
2-5秒范围内 平衡信息与效率 |
sample_rate |
16000 | 音频采样率 | 频率分辨率：影响高频信息的保留 兼容性：需匹配预训练模型要求 数据大小：影响音频数据的存储空间 |
固定16kHz 匹配HuBERT要求 |
num_folds |
5 | 交叉验证折数 | 评估可靠性：折数越多评估越可靠 计算成本：折数影响总训练时间 统计显著性：影响结果的统计意义 |
5-10折为宜 平衡可靠性与成本 |
4.4 参数调优的系统性方法
层次化调优策略：
- 架构参数：先确定hidden_size和dia_layers
- 训练参数：再调优learning_rate和dropout
- 数据参数：最后优化batch_size和time_seconds
性能监控指标：
- 训练指标：损失函数收敛曲线、梯度范数
- 验证指标：准确率、F1分数、混淆矩阵
- 效率指标：训练时间、内存占用、推理速度
5. 模型工作机制深入理解
5.1 自监督预训练的深层价值
HuBERT模型的预训练机制体现了现代语音处理的核心思想：
掩码预测任务的设计智慧：
# HuBERT预训练伪代码示例
masked_features = mask_features(input_features, mask_prob=0.15)
predicted_features = hubert_model(masked_features)
loss = mse_loss(predicted_features, target_features)多层次特征学习机制：
- 声学层面：底层Transformer层学习音素、音调、语速等基础声学特征
- 语言层面：中层学习词汇边界、语法结构、语义关系
- 韵律层面：高层捕获节奏、重音、语调变化，这些特征与情感表达密切相关
迁移学习的有效性：
- 预训练特征包含丰富的语音通用表示
- 在情感识别任务上微调时，模型能快速适应特定领域特征
- 相比从零训练，显著减少了所需的标注数据量
5.2 序列建模的时序依赖机制
双向GRU的门控机制实现了对时序信息的精确控制：
门控机制的数学表达：
# GRU门控机制伪代码
reset_gate = sigmoid(W_r @ [h_prev, x_t])
update_gate = sigmoid(W_u @ [h_prev, x_t])
candidate_h = tanh(W_h @ [reset_gate * h_prev, x_t])
h_t = (1 - update_gate) * h_prev + update_gate * candidate_h双向信息融合的优势：
- 前向流：捕获从语音开始到当前位置的情感发展趋势
- 后向流：利用未来信息为当前判断提供上下文约束
- 信息互补：前后向信息的结合提供了更全面的时序表示
情感时序模式的建模：
- 情感起伏：GRU能够记忆情感的变化轨迹
- 关键转折：门控机制自动识别情感表达的重要时刻
- 上下文依赖：双向设计确保每个时刻都能获得充分的上下文信息
5.3 注意力机制的动态聚焦原理
注意力机制实现了对序列信息的智能选择：
注意力权重的学习机制：
# 注意力权重计算的核心逻辑
similarity_scores = query @ keys.T # 计算相似度
attention_weights = softmax(similarity_scores) # 归一化权重
attended_features = attention_weights @ values # 加权聚合动态聚焦的实现原理：
- 查询驱动：每个时间步作为查询，动态关注整个序列
- 相似度匹配：学习到的变换矩阵捕获查询与键的匹配模式
- 自适应权重：不同情感类别下的注意力模式自动分化
情感关键信息的识别：
- 韵律重点：自动关注语调变化剧烈的时间段
- 语义关键词：聚焦于带有强情感色彩的词汇
- 停顿模式：识别情感表达中的停顿和节奏变化
5.4 全局池化的信息聚合策略
最大池化操作实现了从序列到全局特征的转换：
最大池化的选择rationale：
# 最大池化 vs 平均池化的对比
max_pooled = F.max_pool1d(features, kernel_size=seq_len) # 保留最强信号
avg_pooled = F.avg_pool1d(features, kernel_size=seq_len) # 平均所有信号情感识别中的优势：
- 显著性保留：最大池化保留最强的情感激活信号
- 噪声抑制：忽略弱激活的噪声信息
- 不变性：对序列长度变化具有一定的鲁棒性
6. 系统优势与技术创新
6.1 端到端学习范式的技术突破
传统方法的局限性：
- 手工特征设计依赖领域专家知识
- 特征提取与分类器分离训练，无法实现全局优化
- 特征表达能力受限于人工设计的想象力
端到端学习的优势：
- 自动特征学习：模型自动发现最优的特征表示
- 全局优化：从原始输入到最终输出的联合优化
- 适应性强：能够适应不同的数据分布和任务需求
6.2 多层次特征融合的创新设计
特征融合的层次结构：
HuBERT特征(768维) → GRU时序建模(512维) → 注意力增强 → 全局池化 → 分类输出融合机制的技术创新：
- 语义-时序融合：HuBERT的语义特征与GRU的时序建模相结合
- 局部-全局融合：注意力机制实现局部特征与全局上下文的融合
- 静态-动态融合：静态的预训练特征与动态的序列建模相结合
6.3 注意力增强机制的原创性应用
注意力机制在语音情感识别中的创新应用：
- 时序注意力：针对语音的时序特性设计的注意力机制
- 情感聚焦：自动识别情感表达的关键时间段
- 可解释性：注意力权重提供模型决策的可视化解释
6.4 工程化部署的全面考虑
系统工程化的完整性：
- 模块化设计：清晰的代码结构便于维护和扩展
- 实时处理能力：支持麦克风实时录音和情感识别
- 用户友好界面：完整的PyQt5图形界面
- 跨平台兼容：支持不同操作系统的部署
部署优化的技术细节：
- 模型压缩：通过量化等技术减少模型大小
- 推理加速：GPU加速和批处理优化
- 内存管理：高效的音频缓冲和特征缓存机制
6.5 评估方法的科学性
5折交叉验证的统计严谨性：
- 确保结果的统计显著性和可重现性
- 避免数据划分偶然性对结果的影响
- 提供模型泛化能力的可靠估计
多指标评估的全面性：
- 准确率、召回率、F1分数的综合评估
- 混淆矩阵分析各类别的识别性能
- 统计检验确保结果的科学性
总结
该IEMOCAP语音情感识别系统展现了现代深度学习在语音处理领域的先进技术应用。通过HuBERT预训练模型的强大特征提取能力、双向GRU的精确时序建模、注意力机制的智能聚焦，以及全局池化的有效信息聚合，系统实现了从原始音频到情感类别的端到端学习。
系统的技术创新体现在多个方面：自监督预训练与下游任务的有效结合、多层次特征的深度融合、注意力机制的原创性应用，以及工程化部署的全面考虑。这些设计不仅保证了模型的高性能，也为实际应用提供了坚实的技术基础。
通过深入的源码分析，我们可以看到该系统不仅是一个技术实现，更是对语音情感识别领域前沿技术的系统性整合和创新性应用。它为相关研究和应用开发提供了宝贵的参考和借鉴价值。
基于GRU的语音情感分析识别
