C-RNN文字识别论文导读

2019-03-27

An End-to-End Trainable Neural Network for Image-based Sequence Recognition

C-RNN结构文章之二，一篇OCR领域非常经典的文章，解决图像中的文字识别问题

这篇文章提出了一种端到端的文本识别算法，主要具有四个特性：

端到端训练
处理任意长度的序列，不涉及字符分割或水平尺度的归一化
不局限于任何预定义的词汇，在无词典和基于词典的场景下都取得了很好的效果
模型小而高效，应用潜力广泛

1. Introduction

略

2. Network Architecture

网络主要由三部分构成：

卷积层：特征提取
循环层：预测每一帧输入的label distribution
转录层：将循环层的输出变为最终的标签序列

在网络的底部，卷积层自动从每个输入图像中提取特征序列。在卷积网络之上，构建了一个循环网络，用于对卷积层输出的特征序列的每一帧进行预测。采用CRNN顶部的转录层将循环层的每帧预测转化为标签序列。虽然CRNN由不同类型的网络架构（如CNN和RNN）组成，但可以通过一个损失函数进行联合训练。

2.1 Feature Sequence Extraction

这部分的功能由CNN完成：由标准的CNN模型中的卷积层和最大池化层组成，自动提取出输入图像的特征序列。

训练之前，先把输入图像的高度缩放到同一尺寸（宽度等比例缩放），论文中使用的高度是32。

提取的特征序列中的向量是从特征图上从左到右按照顺序生成的，每个特征向量表示了图像上一定宽度上的特征，论文中使用的这个宽度是1,就是单个像素。

图像经过卷积操作之后每一列数据实际代表原始图像中的一块长方形区域，产生的特征序列将作为LSTM的输入。

2.2 Sequence Labeling

循环层由一个双向LSTM循环神经网络构成，LSTM的每个输出后接一个softmax，输出的是一个后验概率矩阵，预测每一帧输入的标签分布，

RNN具有捕获序列内上下文信息的能力，比独立处理某个字符更为稳定
RNN可将误差反向传播到输入层，从而实现CNN与RNN的联合训练
RNN能够对任意长度的序列进处理

2.3 Transcription

转录是将RNN所做的每帧预测转换成标签序列的过程。数学上，转录是根据每帧预测找到具有最高概率的标签序列。在实践中，存在两种转录模式，即无词典转录和基于词典的转录。词典是一组标签序列，预测受拼写检查字典约束。在无词典模式中，预测时没有任何词典。在基于词典的模式中，通过选择具有最高概率的标签序列进行预测。

转录层利用了CTC模型作为损失函数，CTC提出了一种不需要对齐的Loss的计算方法，最初应用于语音识别上。

CTC一般连接在RNN网络的最后一层用于序列学习和训练。对于一段长度为T的序列来说，每个样本点t（t远大于T）在RNN网络的最后一层都会输出一个softmax向量，表示该样本点的预测概率，所有样本点的这些概率传输给CTC模型后，输出最可能的标签，再经过去除空格（blank）和去重操作，就可以得到最终的序列标签。

关于CTC又是一个大话题了，在这里就不进行详述了。

3. Experiments

网络结构：

网络结构的keras定义(VGG做特征提取)：

def get_Model(training):
    input_shape = (img_w, img_h, 1)     # (128, 64, 1)

    # Make Networkw
    inputs = Input(name='the_input', shape=input_shape, dtype='float32')  # (None, 128, 64, 1)

    # Convolution layer (VGG)
    inner = Conv2D(64, (3, 3), padding='same', name='conv1', kernel_initializer='he_normal')(inputs)  # (None, 128, 64, 64)
    inner = BatchNormalization()(inner)
    inner = Activation('relu')(inner)
    inner = MaxPooling2D(pool_size=(2, 2), name='max1')(inner)  # (None,64, 32, 64)

    inner = Conv2D(128, (3, 3), padding='same', name='conv2', kernel_initializer='he_normal')(inner)  # (None, 64, 32, 128)
    inner = BatchNormalization()(inner)
    inner = Activation('relu')(inner)
    inner = MaxPooling2D(pool_size=(2, 2), name='max2')(inner)  # (None, 32, 16, 128)

    inner = Conv2D(256, (3, 3), padding='same', name='conv3', kernel_initializer='he_normal')(inner)  # (None, 32, 16, 256)
    inner = BatchNormalization()(inner)
    inner = Activation('relu')(inner)
    inner = Conv2D(256, (3, 3), padding='same', name='conv4', kernel_initializer='he_normal')(inner)  # (None, 32, 16, 256)
    inner = BatchNormalization()(inner)
    inner = Activation('relu')(inner)
    inner = MaxPooling2D(pool_size=(1, 2), name='max3')(inner)  # (None, 32, 8, 256)

    inner = Conv2D(512, (3, 3), padding='same', name='conv5', kernel_initializer='he_normal')(inner)  # (None, 32, 8, 512)
    inner = BatchNormalization()(inner)
    inner = Activation('relu')(inner)
    inner = Conv2D(512, (3, 3), padding='same', name='conv6')(inner)  # (None, 32, 8, 512)
    inner = BatchNormalization()(inner)
    inner = Activation('relu')(inner)
    inner = MaxPooling2D(pool_size=(1, 2), name='max4')(inner)  # (None, 32, 4, 512)

    inner = Conv2D(512, (2, 2), padding='same', kernel_initializer='he_normal', name='con7')(inner)  # (None, 32, 4, 512)
    inner = BatchNormalization()(inner)
    inner = Activation('relu')(inner)

    # CNN to RNN
    inner = Reshape(target_shape=((64, 1024)), name='reshape')(inner)  # (None, 32, 2048)
    inner = Dense(64, activation='relu', kernel_initializer='he_normal', name='dense1')(inner)  # (None, 32, 64)

    # RNN layer
    lstm_1 = LSTM(256, return_sequences=True, kernel_initializer='he_normal', name='lstm1')(inner)  # (None, 32, 512)
    lstm_1b = LSTM(256, return_sequences=True, go_backwards=True, kernel_initializer='he_normal', name='lstm1_b')(inner)
    lstm1_merged = add([lstm_1, lstm_1b])  # (None, 32, 512)
    lstm1_merged = BatchNormalization()(lstm1_merged)
    lstm_2 = LSTM(256, return_sequences=True, kernel_initializer='he_normal', name='lstm2')(lstm1_merged)
    lstm_2b = LSTM(256, return_sequences=True, go_backwards=True, kernel_initializer='he_normal', name='lstm2_b')(lstm1_merged)
    lstm2_merged = concatenate([lstm_2, lstm_2b])  # (None, 32, 1024)
    lstm_merged = BatchNormalization()(lstm2_merged)

    # transforms RNN output to character activations:
    inner = Dense(num_classes, kernel_initializer='he_normal',name='dense2')(lstm_merged) #(None, 32, 63)
    y_pred = Activation('softmax', name='softmax')(inner)

    labels = Input(name='the_labels', shape=[max_text_len], dtype='float32') # (None ,8)
    input_length = Input(name='input_length', shape=[1], dtype='int64')     # (None, 1)
    label_length = Input(name='label_length', shape=[1], dtype='int64')     # (None, 1)

    # Keras doesn't currently support loss funcs with extra parameters
    # so CTC loss is implemented in a lambda layer
    loss_out = Lambda(ctc_lambda_func, output_shape=(1,), name='ctc')([y_pred, labels, input_length, label_length]) #(None, 1)

    if training:
        return Model(inputs=[inputs, labels, input_length, label_length], outputs=loss_out)
    else:
        return Model(inputs=[inputs], outputs=y_pred)