ASR语音转文字模型—

模型：

PaddlePaddle-DeepSpeech

训练数据集：

Aishell：178小时，16khz，16bit，400人录制，涉及智能家居、无人驾驶、工业生产等11个领域的中文语音库。

Free ST-Chinese-Mandarin-Corpus：500小时，16khz，16bit，855人录制。安静的室内环境下，通过单个碳粒麦克风录取，文本选取网络聊天智能音箱控制等。

THCHS-30：30小时，16khz，30人录制，清华大学30小时中文语音库。安静的办公室环境下，通过单个碳粒麦克风录取，文本选取自大容量的新闻。

DeepSpeech-1300：1300小时中文语音库

效果：

训练集准确率94.5%，测试准确率约80%

注意事项：

1.仅能识别普通话，对于方言、非中文语言无法识别；

2.对于背景声音过大的音频，识别准确率较低，模型训练过程中提供了以下六个数据增强组件，用于缓解噪声干扰问题：音量扰动、速度扰动、移动扰动、在线贝叶斯归一化、噪声干扰（需要背景噪音的音频文件）、脉冲响应（需要脉冲音频文件）；

3.模型训练所使用的数据均为单条语句，平均长度在十秒以内，所以模型在测试时对于过长的音频识别准确率很低，但短视频的音频数据长度大多在100秒以上，所以在实际应用过程中，先提取视频音频，然后按30秒的时长对音频进行切割，分段转换成文本，然后在拼起来，输出最终的转换结果；

4.视频转音频所用到的工具是ffmpeg；

模型原理：

论文题目：

Deep Speech 2: End-to-End Speech Recognition in English and Mandarin

论文链接：

https://arxiv.org/pdf/1512.02595.pdf

模型结构：

DeepSpeech是完全End-toEnd的语音识别系统，输入是语音的频谱，输出是字符串，核心技术是CTC算法，核心结构实际上是一个RNN。

模型由5个隐藏层组成，可以分为三个部分：Conv layer， Recurrent layer and FC layer。

前三层为是全连接层，组成Conv layer，对于输入x，我们用 hl 表示第l层，h0 表示输入。对于第1层，在t时刻的输入不只是t时刻的特征xtxt，而且还包括它的前后C帧特征，共计2C+1帧，前三层公式如下：

第四层是Recurrent layer，是一个双向RNN，第五层会把这个双向RNN的两个输入加起来作为输入：

最后一层是FC layer，是一个全连接层，没有激活函数，用softmax吧输出变成对应每个字符的概率：

模型引入了Batch Normalization，使得模型训练更快更好：

核心代码：

核心代码在DeepSpeech.py中，很多代码都是为了支持多GPU训练的，以下是和网络结构定义相关部分的代码：

def BiRNN(batch_x, seq_length, dropout):# 输入 shape: [batch_size, n_steps, n_input + 2*n_input*n_context]batch_x_shape = tf.shape(batch_x)# 把 `batch_x` Reshape成 `[n_steps*batch_size, n_input + 2*n_input*n_context]`.# 因为第一层期望的输入的rank是2# 时间主序，这是warpCTC的要求。batch_x = tf.transpose(batch_x, [1, 0, 2])# 第一层期望的输入rank是2# (n_steps*batch_size, n_input + 2*n_input*n_context)batch_x = tf.reshape(batch_x, [-1, n_input + 2*n_input*n_context])# 输入首先经过3个隐层，激活函数是clipped的ReLU，并且使用dropout# 第一层b1 = variable_on_worker_level('b1', [n_hidden_1], tf.random_normal_initializer(stddev=FLAGS.b1_stddev))h1 = variable_on_worker_level('h1', [n_input + 2*n_input*n_context, n_hidden_1], tf.contrib.layers.xavier_initializer(uniform=False))layer_1 = tf.minimum(tf.nn.relu(tf.add(tf.matmul(batch_x, h1), b1)), FLAGS.relu_clip)layer_1 = tf.nn.dropout(layer_1, (1.0 - dropout[0]))# 第二层b2 = variable_on_worker_level('b2', [n_hidden_2], tf.random_normal_initializer(stddev=FLAGS.b2_stddev))h2 = variable_on_worker_level('h2', [n_hidden_1, n_hidden_2], tf.random_normal_initializer(stddev=FLAGS.h2_stddev))layer_2 = tf.minimum(tf.nn.relu(tf.add(tf.matmul(layer_1, h2), b2)), FLAGS.relu_clip)layer_2 = tf.nn.dropout(layer_2, (1.0 - dropout[1]))# 第三层b3 = variable_on_worker_level('b3', [n_hidden_3], tf.random_normal_initializer(stddev=FLAGS.b3_stddev))h3 = variable_on_worker_level('h3', [n_hidden_2, n_hidden_3], tf.random_normal_initializer(stddev=FLAGS.h3_stddev))layer_3 = tf.minimum(tf.nn.relu(tf.add(tf.matmul(layer_2, h3), b3)), FLAGS.relu_clip)layer_3 = tf.nn.dropout(layer_3, (1.0 - dropout[2]))# LSTM，隐单元是n_cell_dim，遗忘门的bias是1.0# 前向LSTM:lstm_fw_cell = tf.contrib.rnn.BasicLSTMCell(n_cell_dim, forget_bias=1.0, state_is_tuple=True,reuse=tf.get_variable_scope().reuse)lstm_fw_cell = tf.contrib.rnn.DropoutWrapper(lstm_fw_cell,input_keep_prob=1.0 - dropout[3],output_keep_prob=1.0 - dropout[3],seed=FLAGS.random_seed)# 反向LSTM:lstm_bw_cell = tf.contrib.rnn.BasicLSTMCell(n_cell_dim, forget_bias=1.0, state_is_tuple=True, reuse=tf.get_variable_scope().reuse)lstm_bw_cell = tf.contrib.rnn.DropoutWrapper(lstm_bw_cell,input_keep_prob=1.0 - dropout[4],output_keep_prob=1.0 - dropout[4],seed=FLAGS.random_seed)# 第三层的输出`layer_3` reshape成`[n_steps, batch_size, 2*n_cell_dim]`,# 因为后面期望的输入是`[max_time, batch_size, input_size]`.layer_3 = tf.reshape(layer_3, [-1, batch_x_shape[0], n_hidden_3])# 把第三层的输出传入双向LSTM outputs, output_states = tf.nn.bidirectional_dynamic_rnn(cell_fw=lstm_fw_cell,cell_bw=lstm_bw_cell,inputs=layer_3,dtype=tf.float32,time_major=True,sequence_length=seq_length)# LSTM的输出包括双向的结果，每一个方向的输出是[n_steps, batch_size, n_cell_dim]，# 我们把它拼接起来最后一个时刻的隐状态和最后reshape成[n_steps*batch_size, 2*n_cell_dim]outputs = tf.concat(outputs, 2)outputs = tf.reshape(outputs, [-1, 2*n_cell_dim])# 第五个隐层b5 = variable_on_worker_level('b5', [n_hidden_5], tf.random_normal_initializer(stddev=FLAGS.b5_stddev))h5 = variable_on_worker_level('h5', [(2 * n_cell_dim), n_hidden_5], tf.random_normal_initializer(stddev=FLAGS.h5_stddev))layer_5 = tf.minimum(tf.nn.relu(tf.add(tf.matmul(outputs, h5), b5)), FLAGS.relu_clip)layer_5 = tf.nn.dropout(layer_5, (1.0 - dropout[5]))# 第六层，没有激活函数，输出是logitsb6 = variable_on_worker_level('b6', [n_hidden_6], tf.random_normal_initializer(stddev=FLAGS.b6_stddev))h6 = variable_on_worker_level('h6', [n_hidden_5, n_hidden_6], tf.contrib.layers.xavier_initializer(uniform=False))layer_6 = tf.add(tf.matmul(layer_5, h6), b6)# 把logits 从 [n_steps*batch_size, n_hidden_6]# reshape [n_steps, batch_size, n_hidden_6].# 注意，它和输入是不同的，因为它是时间主序(而输入是batch主序)layer_6 = tf.reshape(layer_6, [-1, batch_x_shape[0], n_hidden_6], name="logits")# Output shape: [n_steps, batch_size, n_hidden_6]return layer_6

优化工作：

1. 数据并行化

为了利用GPU的计算能力，一次训练会计算较大的batch（通常上千）。此外DeepSpeech会同时用多个GPU计算一个batch的梯度，然后平均这些梯度来更新参数（使用了 synchronous SGD）。因为序列的长度是变长的，DeepSpeech会把长度类似的训练数据分成组，然后padding成一样的长度。

2. CTC loss function的GPU实现

由于计算CTC loss function 比前后向传播更为复杂，作者实现了一个GPU版本的CTC loss function，而这一实现，减少了10%~20%的训练时间。

3. 内存分配优化

使用动态内存分配给GPU和CPU内存，主要用于存储可变长度话语的激活数据和中间结果。

参考：

【1】https://arxiv.org/pdf/1512.02595.pdf

【2】http://fancyerii.github.io/books/deepspeech/

【3】https://zhuanlan.zhihu.com/p/92305041

【4】https://blog.csdn.net/Code_Mart/article/details/87291644

【5】https://github.com/mozilla/DeepSpeech