文档章节

【AI实战】手把手教你文字识别(识别篇:LSTM+CTC, CRNN, chineseocr方法)

雪饼
 雪饼
发布于 07/07 16:01
字数 6958
阅读 3989
收藏 154
CTC

文字识别是AI的一个重要应用场景,文字识别过程一般由图像输入、预处理、文本检测、文本识别、结果输出等环节组成。
 
其中,文本检测、文本识别是最核心的环节。文本检测方面,在前面的文章中已介绍过了多种基于深度学习的方法,可针对各种场景实现对文字的检测,详见以下文章:

【AI实战】手把手教你文字识别(检测篇:MSER、CTPN、SegLink、EAST等方法)

 

【AI实战】手把手教你文字识别(检测篇:AdvancedEAST、PixelLink方法)
 


而本文主要就是介绍在“文本识别”方面的实战方法,只要掌握了这些方法,那么跟前面介绍的文本检测方法结合起来,就可以轻松应对各种文字识别的任务了。话不多说,马上来学习“文本识别”的方法。

文字识别可根据待识别的文字特点采用不同的识别方法,一般分为定长文字、不定长文字两大类别。

  • 定长文字(例如验证码),由于字符数量固定,采用的网络结构相对简单,识别也比较容易;
  • 不定长文字(例如印刷文字、广告牌文字等),由于字符数量是不固定的,因此需要采用比较复杂的网络结构和后处理环节,识别也具有一定的难度。

下面按照定长文字、不定长文字分别介绍识别方法。

一、定长文字识别
定长文字的识别相对简单,应用场景也比较局限,最典型的场景就是验证码的识别了。由于字符数量是已知的、固定的,因此,网络结构比较简单,一般构建3层卷积层,2层全连接层便能满足“定长文字”的识别。
具体方法在之前介绍验证码识别的文章中已详细介绍,在此不再赘述。详见文章:

【AI实战】文字识别(验证码识别)


 
二、不定长文字识别
不定长文字在现实中大量存在,例如印刷文字、广告牌文字等,由于字符数量不固定、不可预知,因此,识别的难度也较大,这也是目前研究文字识别的主要方向。下面介绍不定长文字识别的常用方法:LSTM+CTC、CRNN、chinsesocr。
1、LSTM+CTC 方法
(1)什么是LSTM
为了实现对不定长文字的识别,就需要有一种能力更强的模型,该模型具有一定的记忆能力,能够按时序依次处理任意长度的信息,这种模型就是“循环神经网络”(Recurrent Neural Networks,简称RNN)。
LSTM(Long Short Term Memory,长短期记忆网络)是一种特殊结构的RNN(循环神经网络),用于解决RNN的长期依赖问题,也即随着输入RNN网络的信息的时间间隔不断增大,普通RNN就会出现“梯度消失”或“梯度爆炸”的现象,这就是RNN的长期依赖问题,而引入LSTM即可以解决这个问题。LSTM单元由输入门(Input Gate)、遗忘门(Forget Gate)和输出门(Output Gate)组成,具体的技术原理的工作过程详见之前的文章(文章:白话循环神经网络(RNN)),LSTM的结构如下图所示。
 
(2)什么是CTC
CTC(Connectionist Temporal Classifier,联接时间分类器),主要用于解决输入特征与输出标签的对齐问题。例如下图,由于文字的不同间隔或变形等问题,导致同个文字有不同的表现形式,但实际上都是同一个文字。在识别时会将输入图像分块后再去识别,得出每块属于某个字符的概率(无法识别的标记为特殊字符”-”),如下图:
 
由于字符变形等原因,导致对输入图像分块识别时,相邻块可能会识别为同个结果,字符重复出现。因此,通过CTC来解决对齐问题,模型训练后,对结果中去掉间隔字符、去掉重复字符(如果同个字符连续出现,则表示只有1个字符,如果中间有间隔字符,则表示该字符出现多次),如下图所示
 
(3)LSTM+CTC实现:常量定义
定义一些常量,在模型训练和预测中使用,定义如下:

# 数据集,可根据需要增加英文或其它字符
DIGITS = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']

# 分类数量
num_classes = len(DIGITS) + 1     # 数据集字符数+特殊标识符

# 图片大小,32 x 256
OUTPUT_SHAPE = (32, 256)

# 学习率
INITIAL_LEARNING_RATE = 1e-3
DECAY_STEPS = 5000
REPORT_STEPS = 100
LEARNING_RATE_DECAY_FACTOR = 0.9
MOMENTUM = 0.9

# LSTM网络层次
num_hidden = 128
num_layers = 2

# 训练轮次、批量大小
num_epochs = 50000
BATCHES = 10
BATCH_SIZE = 32
TRAIN_SIZE = BATCHES * BATCH_SIZE

# 数据集目录、模型目录
data_dir = '/tmp/lstm_ctc_data/'
model_dir = '/tmp/lstm_ctc_model/'

(4)LSTM+CTC实现:随机生成不定长图片数据
为了训练和测试LSTM+CTC识别模型,先要准备好基础数据,可根据需要准备好已标注的文本图片集。在这里,为了方便训练和测试模型,随机生成10000张不定长的图片数据集。通过使用Pillow生成图片和绘上文字,并对图片随机叠加椒盐噪声,以更加贴近现实场景。核心代码如下:

# 生成椒盐噪声
def img_salt_pepper_noise(src,percetage):
    NoiseImg=src
    NoiseNum=int(percetage*src.shape[0]*src.shape[1])
    for i in range(NoiseNum):
        randX=random.randint(0,src.shape[0]-1)
        randY=random.randint(0,src.shape[1]-1)
        if random.randint(0,1)==0:
            NoiseImg[randX,randY]=0
        else:
            NoiseImg[randX,randY]=255
    return NoiseImg

# 随机生成不定长图片集
def gen_text(cnt):
    # 设置文字字体和大小
    font_path = '/data/work/tensorflow/fonts/arial.ttf'
    font_size = 30
    font=ImageFont.truetype(font_path,font_size)

for i in range(cnt):
        # 随机生成1到10位的不定长数字
        rnd = random.randint(1, 10)
        text = ''
        for j in range(rnd):
            text = text + DIGITS[random.randint(0, len(DIGITS) - 1)]

# 生成图片并绘上文字
        img=Image.new("RGB",(256,32))
        draw=ImageDraw.Draw(img)
        draw.text((1,1),text,font=font,fill='white')
        img=np.array(img)

# 随机叠加椒盐噪声并保存图像
        img = img_salt_pepper_noise(img, float(random.randint(1,10)/100.0))
        cv2.imwrite(data_dir + text + '_' + str(i+1) + '.jpg',img)

随机生成的不定长数据效果如下:
 
执行 gen_text(10000) 后生成的图片集如下,文件名由序号和文字标签组成:

(5)LSTM+CTC实现:标签向量化(稀疏矩阵)
由于文字是不定长的,因此,如果读取图片并获取标签,然后将标签存放在一个紧密矩阵中进行向量化,那将会出现大量的零元素,很浪费空间。因此,使用稀疏矩阵对标签进行向量化。所谓“稀疏矩阵”就是矩阵中的零元素远远多于非零元素,采用这种方式存储可有效节约空间。
稀疏矩阵有3个属性,分别是:

  • indices:二维矩阵,代表非零的坐标点
  • values:二维tensor,代表indice位置的数据值
  • dense_shape:一维,代表稀疏矩阵的大小(取行数和列的最大长度)


例如读取了以下图片和相应的标签,那么存储为稀疏矩阵的结果如下:
 
将标签转为稀疏矩阵,对标签进行向量化,核心代码如下:

# 序列转为稀疏矩阵
# 输入:序列
# 输出:indices非零坐标点,values数据值,shape稀疏矩阵大小
def sparse_tuple_from(sequences, dtype=np.int32):
    indices = []
    values = []

for n, seq in enumerate(sequences):
        indices.extend(zip([n] * len(seq), range(len(seq))))
        values.extend(seq)

indices = np.asarray(indices, dtype=np.int64)
    values = np.asarray(values, dtype=dtype)
    shape = np.asarray([len(sequences), np.asarray(indices).max(0)[1] + 1], dtype=np.int64)

return indices, values, shape

将稀疏矩阵转为标签,用于输出结果,核心代码如下:

# 稀疏矩阵转为序列
# 输入:稀疏矩阵
# 输出:序列
def decode_sparse_tensor(sparse_tensor):
    decoded_indexes = list()
    current_i = 0
    current_seq = []

for offset, i_and_index in enumerate(sparse_tensor[0]):
        i = i_and_index[0]
        if i != current_i:
            decoded_indexes.append(current_seq)
            current_i = i
            current_seq = list()
        current_seq.append(offset)
    decoded_indexes.append(current_seq)

result = []
    for index in decoded_indexes:
        result.append(decode_a_seq(index, sparse_tensor))
    return result

# 序列编码转换
def decode_a_seq(indexes, spars_tensor):
    decoded = []
    for m in indexes:
        str = DIGITS[spars_tensor[1][m]]
        decoded.append(str)
    return decoded

(6)LSTM+CTC实现:读取数据
读取图像数据以及进行标签向量化,以便于输入到模型进行训练,核心代码如下:

# 将文件和标签读到内存,减少磁盘IO
def get_file_text_array():
    file_name_array=[]
    text_array=[]

for parent, dirnames, filenames in os.walk(data_dir):
        file_name_array=filenames

for f in file_name_array:
        text = f.split('_')[0]
        text_array.append(text)

return file_name_array,text_array

# 获取训练的批量数据
def get_next_batch(file_name_array,text_array,batch_size=64):
    inputs = np.zeros([batch_size, OUTPUT_SHAPE[1], OUTPUT_SHAPE[0]])
    codes = []

# 获取训练样本
    for i in range(batch_size):
        index = random.randint(0, len(file_name_array) - 1)
        image = cv2.imread(data_dir + file_name_array[index])
        image = cv2.resize(image, (OUTPUT_SHAPE[1], OUTPUT_SHAPE[0]), 3)
        image = cv2.cvtColor(image,cv2.COLOR_RGB2GRAY)
        text = text_array[index]

# 矩阵转置
        inputs[i, :] = np.transpose(image.reshape((OUTPUT_SHAPE[0], OUTPUT_SHAPE[1])))
        # 标签转成列表
        codes.append(list(text))

# 标签转成稀疏矩阵
    targets = [np.asarray(i) for i in codes]
    sparse_targets = sparse_tuple_from(targets)
    seq_len = np.ones(inputs.shape[0]) * OUTPUT_SHAPE[1]

return inputs, sparse_targets, seq_len

(7)LSTM+CTC实现:构建网络
利用tensorflow内置的LSTM单元构建网络,核心代码如下:

def get_train_model():
    # 输入
    inputs = tf.placeholder(tf.float32, [None, None, OUTPUT_SHAPE[0]]) 

# 稀疏矩阵
    targets = tf.sparse_placeholder(tf.int32)

# 序列长度 [batch_size,]
    seq_len = tf.placeholder(tf.int32, [None])

# 定义LSTM网络
    cell = tf.contrib.rnn.LSTMCell(num_hidden, state_is_tuple=True)
    stack = tf.contrib.rnn.MultiRNNCell([cell] * num_layers, state_is_tuple=True)      # old
    outputs, _ = tf.nn.dynamic_rnn(cell, inputs, seq_len, dtype=tf.float32)
    shape = tf.shape(inputs)
    batch_s, max_timesteps = shape[0], shape[1]

outputs = tf.reshape(outputs, [-1, num_hidden])
    W = tf.Variable(tf.truncated_normal([num_hidden,
                                         num_classes],
                                        stddev=0.1), name="W")
    b = tf.Variable(tf.constant(0., shape=[num_classes]), name="b")
    logits = tf.matmul(outputs, W) + b
    logits = tf.reshape(logits, [batch_s, -1, num_classes])

# 转置矩阵
    logits = tf.transpose(logits, (1, 0, 2))

return logits, inputs, targets, seq_len, W, b 

(8)LSTM+CTC实现:模型训练
在训练之前,先定义好准确率评估方法,以便于在训练过程中不断评估模型的准确性,核心代码如下:

# 准确性评估
# 输入:预测结果序列 decoded_list ,目标序列 test_targets
# 返回:准确率
def report_accuracy(decoded_list, test_targets):
    original_list = decode_sparse_tensor(test_targets)
    detected_list = decode_sparse_tensor(decoded_list)

# 正确数量
    true_numer = 0

# 预测序列与目标序列的维度不一致,说明有些预测失败,直接返回
    if len(original_list) != len(detected_list):
        print("len(original_list)", len(original_list), "len(detected_list)", len(detected_list),
              " test and detect length desn't match")
        return

# 比较预测序列与结果序列是否一致,并统计准确率        
    print("T/F: original(length) <-------> detectcted(length)")
    for idx, number in enumerate(original_list):
        detect_number = detected_list[idx]
        hit = (number == detect_number)
        print(hit, number, "(", len(number), ") <-------> ", detect_number, "(", len(detect_number), ")")
        if hit:
            true_numer = true_numer + 1
    accuracy = true_numer * 1.0 / len(original_list)
    print("Test Accuracy:", accuracy)

return accuracy

接着开始对模型进行训练,核心代码如下:

def train():
    # 获取训练样本数据
    file_name_array, text_array = get_file_text_array()

# 定义学习率
    global_step = tf.Variable(0, trainable=False)
    learning_rate = tf.train.exponential_decay(INITIAL_LEARNING_RATE,
                                               global_step,
                                               DECAY_STEPS,
                                               LEARNING_RATE_DECAY_FACTOR,
                                               staircase=True)
    # 获取网络结构
    logits, inputs, targets, seq_len, W, b = get_train_model()

# 设置损失函数
    loss = tf.nn.ctc_loss(labels=targets, inputs=logits, sequence_length=seq_len)
    cost = tf.reduce_mean(loss)

# 设置优化器
    optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(loss, global_step=global_step)
    decoded, log_prob = tf.nn.ctc_beam_search_decoder(logits, seq_len, merge_repeated=False)
    acc = tf.reduce_mean(tf.edit_distance(tf.cast(decoded[0], tf.int32), targets))

init = tf.global_variables_initializer()
    config = tf.ConfigProto()
    config.gpu_options.allow_growth = True

with tf.Session() as session:
        session.run(init)
        saver = tf.train.Saver(tf.global_variables(), max_to_keep=10)

for curr_epoch in range(num_epochs):
            train_cost = 0
            train_ler = 0
            for batch in range(BATCHES):
                # 训练模型
                train_inputs, train_targets, train_seq_len = get_next_batch(file_name_array, text_array, BATCH_SIZE)
                feed = {inputs: train_inputs, targets: train_targets, seq_len: train_seq_len}
                b_loss, b_targets, b_logits, b_seq_len, b_cost, steps, _ = session.run(
                    [loss, targets, logits, seq_len, cost, global_step, optimizer], feed)

# 评估模型
                if steps > 0 and steps % REPORT_STEPS == 0:
                    test_inputs, test_targets, test_seq_len = get_next_batch(file_name_array, text_array, BATCH_SIZE)
                    test_feed = {inputs: test_inputs,targets: test_targets,seq_len: test_seq_len}
                    dd, log_probs, accuracy = session.run([decoded[0], log_prob, acc], test_feed)
                    report_accuracy(dd, test_targets)

# 保存识别模型
                    save_path = saver.save(session, model_dir + "lstm_ctc_model.ctpk",global_step=steps)

c = b_cost
                train_cost += c * BATCH_SIZE

train_cost /= TRAIN_SIZE
            # 计算 loss
            train_inputs, train_targets, train_seq_len = get_next_batch(file_name_array, text_array, BATCH_SIZE)
            val_feed = {inputs: train_inputs,targets: train_targets,seq_len: train_seq_len}
            val_cost, val_ler, lr, steps = session.run([cost, acc, learning_rate, global_step], feed_dict=val_feed)

log = "{} Epoch {}/{}, steps = {}, train_cost = {:.3f}, val_cost = {:.3f}"
            print(log.format(curr_epoch + 1, num_epochs, steps, train_cost, val_cost))

经过一段时间的训练,执行了600多步后,评估的准确性已全部预测正确,如下图:

(8)LSTM+CTC实现:能力封装
为了方便其它程序调用LSTM+CTC的识别能力,对识别能力进行封装,只需要输入一张图片,即可识别后返回结果。核心代码如下:

# LSTM+CTC 文字识别能力封装
# 输入:图片
# 输出:识别结果文字
def predict(image):

# 获取网络结构
    logits, inputs, targets, seq_len, W, b = get_train_model()
    decoded, log_prob = tf.nn.ctc_beam_search_decoder(logits, seq_len, merge_repeated=False)

saver = tf.train.Saver()
    with tf.Session() as sess:
        # 加载模型
        saver.restore(sess, tf.train.latest_checkpoint(model_dir))
        # 图像预处理
        image = cv2.resize(image, (OUTPUT_SHAPE[1], OUTPUT_SHAPE[0]), 3)
        image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
        pred_inputs = np.zeros([1, OUTPUT_SHAPE[1], OUTPUT_SHAPE[0]])
        pred_inputs[0, :] = np.transpose(image.reshape((OUTPUT_SHAPE[0], OUTPUT_SHAPE[1])))
        pred_seq_len = np.ones(1) * OUTPUT_SHAPE[1]
        # 模型预测
        pred_feed = {inputs: pred_inputs,seq_len: pred_seq_len}
        dd, log_probs = sess.run([decoded[0], log_prob], pred_feed)
        # 识别结果转换
        detected_list = decode_sparse_tensor(dd)[0]
        detected_text = ''
        for d in detected_list:
            detected_text = detected_text + d

return detected_text

 

2、CRNN 方法
CRNN(Convolutional Recurrent Neural Network,卷积循环神经网络)是目前比较流行的文字识别模型,不需要对样本数据进行字符分割,可识别任意长度的文本序列,模型速度快、性能好。网络结构如下图所示,主要由卷积层、循环层、转录层3部分组成,具体技术原理请详见之前的文章(文章:大话文本识别经典模型 CRNN
 
那么该如何使用CRNN训练和识别呢?
github上实现CRNN的代码有很多,这里面选择一个相对简单的CRNN源代码进行研究。
(1)下载源代码
 
首先,在github上下载CRNN源代码(https://github.com/Belval/CRNN),可直接下载成zip压缩包或者git克隆

git clone https://github.com/Belval/CRNN.git

(2)准备基础数据
使用第1节LSTM+CTC介绍的方法随机生成10000张不定长图片+椒盐噪声作为基础数据集,具体详见第1节的生成基础数据代码,在此不再重复。注意,由于该CRNN源代码在读取图片时默认文件名第1位为标签(以下划线 ”_” 隔开),于是注意按照文件命名规则生成图片。

(3)训练模型
参考CRNN/run.py里面的代码,编写模型训练的调用代码如下:

# 模型训练
def train():

# 设置基本属性
    batch_size=32    # 批量大小
    max_image_width=400   # 最大图片宽度
    train_test_ratio=0.75    # 训练集、测试集划分比例
    restore=True    # 是否恢复加载模型,可用于多次加载训练
    iteration_count=1000    # 迭代次数
    # 初始化调用CRNN
    crnn = CRNN(
        batch_size,
        model_dir,
        data_dir,
        max_image_width,
        train_test_ratio,
        restore
    )
    # 模型训练
    crnn.train(iteration_count)

经过了5个小时左右,迭代训练了263次,使得loss(损失值)已降低至接近1,模型也已基本上可用。
 
CRNN的训练过程很长,本案例随机生成的文字还是比较简单的,但每步的迭代就已耗时很长。如果是实际应用中,需要使用背景更加复杂、文字形态更加多样的数据集,对训练loss的要求也更高,这时会使得整个训练过程更长。因此,一般会采用“迁移学习”的方式来提升训练效率和模型效果(详见文章:了解什么是“迁移学习”),“迁移学习”的实现方式后面会再单独进行介绍。

(4)模型测试
参考CRNN/run.py里面的代码,编写模型测试的代码,可输出测试结果,代码如下:

# 模型测试
def test():

# 设置基本属性
    batch_size=32
    max_image_width=400
    restore=True
    # 初始化CRNN
    crnn = CRNN(
        batch_size,
        model_dir,
        data_dir,
        max_image_width,
        0,
        restore
    )
    # 测试模型
    crnn.test()

测试的结果如下,程序会批量读入数据后,输入原始结果(第一行)和预测结果(第二行),便于比较两者是否一致。
 
作者提供的这种测试方式太考验人眼了,我们可将CRNN里面的test函数进行个小修改,自动计算准确率,将会方便很多。修改的代码如下:

def test(self):
with self.__session.as_default():
    print('Testing')
    for batch_y, _, batch_x in self.__data_manager.test_batches:
        decoded = self.__session.run(
            self.__decoded,
            feed_dict={
                self.__inputs: batch_x,
                self.__seq_len: [self.__max_char_count] * self.__data_manager.batch_size
            }
        )

        # 修改,统计准确率
        true_cnt = 0
        for i, y in enumerate(batch_y):
            if batch_y[i] == ground_truth_to_word(decoded[i]):
                true_cnt = true_cnt + 1
            else:                  
                # 预测结果不一致的,才显示出来
                print('target:',batch_y[i])
                print('predict:',ground_truth_to_word(decoded[i]))
        print('acc:',float(true_cnt)/float(len(batch_y)))
return None

(5)能力封装
为了方便将CRNN识别能力提供给其它程序调用,在CRNN/crnn.py代码的基础上进行修改,对CRNN识别能力进行封装,即只需输入指定的图片,即可返回识别结果。
首先是重写crnn.py里面加载CRNN网络结构的方式,由于原先的代码在初始化时只支持批量的图片进行训练和测试,为了实现对指定的某张图片进行识别,对网络模型的初始化和调用方式进行修改,核心代码如下:

# CRNN 网络结构
def crnn_network(max_width, batch_size):
    # 双向RNN
    def BidirectionnalRNN(inputs, seq_len):
        # rnn-1
        with tf.variable_scope(None, default_name="bidirectional-rnn-1"):
            # Forward
            lstm_fw_cell_1 = rnn.BasicLSTMCell(256)
            # Backward
            lstm_bw_cell_1 = rnn.BasicLSTMCell(256)
            inter_output, _ = tf.nn.bidirectional_dynamic_rnn(lstm_fw_cell_1, lstm_bw_cell_1, inputs, seq_len, dtype=tf.float32)
            inter_output = tf.concat(inter_output, 2)
        # rnn-2
        with tf.variable_scope(None, default_name="bidirectional-rnn-2"):
            # Forward
            lstm_fw_cell_2 = rnn.BasicLSTMCell(256)
            # Backward
            lstm_bw_cell_2 = rnn.BasicLSTMCell(256)
            outputs, _ = tf.nn.bidirectional_dynamic_rnn(lstm_fw_cell_2, lstm_bw_cell_2, inter_output, seq_len, dtype=tf.float32)
            outputs = tf.concat(outputs, 2)
        return outputs
    # CNN,用于提取特征
    def CNN(inputs):
        # 64 / 3 x 3 / 1 / 1
        conv1 = tf.layers.conv2d(inputs=inputs, filters = 64, kernel_size = (3, 3), padding = "same", activation=tf.nn.relu)
        # 2 x 2 / 1
        pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)
        # 128 / 3 x 3 / 1 / 1
        conv2 = tf.layers.conv2d(inputs=pool1, filters = 128, kernel_size = (3, 3), padding = "same", activation=tf.nn.relu)
        # 2 x 2 / 1
        pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)
        # 256 / 3 x 3 / 1 / 1
        conv3 = tf.layers.conv2d(inputs=pool2, filters = 256, kernel_size = (3, 3), padding = "same", activation=tf.nn.relu)
        # Batch normalization layer
        bnorm1 = tf.layers.batch_normalization(conv3)
        # 256 / 3 x 3 / 1 / 1
        conv4 = tf.layers.conv2d(inputs=bnorm1, filters = 256, kernel_size = (3, 3), padding = "same", activation=tf.nn.relu)
        # 1 x 2 / 1
        pool3 = tf.layers.max_pooling2d(inputs=conv4, pool_size=[2, 2], strides=[1, 2], padding="same")
        # 512 / 3 x 3 / 1 / 1
        conv5 = tf.layers.conv2d(inputs=pool3, filters = 512, kernel_size = (3, 3), padding = "same", activation=tf.nn.relu)
        # Batch normalization layer
        bnorm2 = tf.layers.batch_normalization(conv5)
        # 512 / 3 x 3 / 1 / 1
        conv6 = tf.layers.conv2d(inputs=bnorm2, filters = 512, kernel_size = (3, 3), padding = "same", activation=tf.nn.relu)
        # 1 x 2 / 2
        pool4 = tf.layers.max_pooling2d(inputs=conv6, pool_size=[2, 2], strides=[1, 2], padding="same")
        # 512 / 2 x 2 / 1 / 0
        conv7 = tf.layers.conv2d(inputs=pool4, filters = 512, kernel_size = (2, 2), padding = "valid", activation=tf.nn.relu)
        return conv7

# 定义输入、输出、序列长度
    inputs = tf.placeholder(tf.float32, [batch_size, max_width, 32, 1])
    targets = tf.sparse_placeholder(tf.int32, name='targets')
    seq_len = tf.placeholder(tf.int32, [None], name='seq_len')

# 卷积层提取特征
    cnn_output = CNN(inputs)
    reshaped_cnn_output = tf.reshape(cnn_output, [batch_size, -1, 512])
    max_char_count = reshaped_cnn_output.get_shape().as_list()[1]

# 循环层处理序列
    crnn_model = BidirectionnalRNN(reshaped_cnn_output, seq_len)
    logits = tf.reshape(crnn_model, [-1, 512])

# 转录层预测结果
    W = tf.Variable(tf.truncated_normal([512, config.NUM_CLASSES], stddev=0.1), name="W")
    b = tf.Variable(tf.constant(0., shape=[config.NUM_CLASSES]), name="b")
    logits = tf.matmul(logits, W) + b
    logits = tf.reshape(logits, [batch_size, -1, config.NUM_CLASSES])
    logits = tf.transpose(logits, (1, 0, 2))

# 定义损失函数、优化器
    loss = tf.nn.ctc_loss(targets, logits, seq_len)
    cost = tf.reduce_mean(loss)
    optimizer = tf.train.AdamOptimizer(learning_rate=0.0001).minimize(cost)
    decoded, log_prob = tf.nn.ctc_beam_search_decoder(logits, seq_len, merge_repeated=False)
    dense_decoded = tf.sparse_tensor_to_dense(decoded[0], default_value=-1)
    acc = tf.reduce_mean(tf.edit_distance(tf.cast(decoded[0], tf.int32), targets))

# 初始化
    init = tf.global_variables_initializer()

return inputs, targets, seq_len, logits, dense_decoded, optimizer, acc, cost, max_char_count, init

# CRNN 识别文字
# 输入:图片路径
# 输出:识别文字结果
def predict(img_path):
    # 定义模型路径、最长图片宽度
    batch_size = 1
    model_path = '/tmp/crnn_model/'
    max_image_width = 400

# 创建会话
    __session = tf.Session()
    with __session.as_default():
        (
            __inputs,
            __targets,
            __seq_len,
            __logits,
            __decoded,
            __optimizer,
            __acc,
            __cost,
            __max_char_count,
            __init
        ) = crnn_network(max_image_width, batch_size)
        __init.run()

# 加载模型
    with __session.as_default():
        __saver = tf.train.Saver()
        ckpt = tf.train.latest_checkpoint(model_path)
        if ckpt:
            __saver.restore(__session, ckpt)

# 读取图片作为输入
    arr, initial_len = utils.resize_image(img_path,max_image_width)
    batch_x = np.reshape(
        np.array(arr),
        (-1, max_image_width, 32, 1)
    )

# 利用模型识别文字
    with __session.as_default():
        decoded = __session.run(
            __decoded,
            feed_dict={
                __inputs: batch_x,
                __seq_len: [__max_char_count] * batch_size
            }
        )
        pred_result = utils.ground_truth_to_word(decoded[0])

return pred_result

将CRNN能力封装后,便能很方便地进行调用识别,如下:

img_path = '/tmp/crnn_data/728591_532.jpg'
pred_result = predict(img_path)
print('predict result:',pred_result)

调用结果如下图

 

3、chineseocr项目
最后再介绍github上一个很不错的文字识别项目chineseocr,这个项目是基于yolo3(用于文字检测)、crnn(用于文字识别)的自然场景文字识别项目。该项目支持darknet / opencv dnn / keras 的文字检测,支持0、90、180、270度的方向检测,支持不定长的英文、中英文识别,同时支持通用OCR、身份证识别、火车票识别等多种场景。
该模型功能完善,使用简单,入手容易,非常适合于新手或者比较通用的场景使用。下面介绍如何使用chineseocr项目。

(1)下载源代码
 
首先,在github上下载chineseocr源代码(https://github.com/chineseocr/chineseocr),可直接下载成zip压缩包或者git克隆

git clone https://github.com/chineseocr/chineseocr.git

(2)下载darknet
 
chineseocr项目默认使用keras yolo3进行文字检测,该项目同时支持opencv dnn、darknet进行文字检测。
① 下载源代码
如果要使用darknet来进行文字检测,那么就需要再下载darknet源代码(如直接使用项目默认的keras yolo3检测方法,则跳过该步骤),在github上下载chineseocr源代码(https://github.com/pjreddie/darknet),可直接下载成zip压缩包或者git克隆

git clone https://github.com/pjreddie/darknet.git

② 放置目录
下载后,将darknet的源代码放到chineseocr项目中的darknet目录中。

mv darknet chineseocr/

③ 编译
然后修改Makefile,增加对GPU、cudnn的支持

#GPU=1
#CUDNN=1
#OPENCV=0
#OPENMP=0

执行 make 进行编译

④ 指定libdarknet.so路径
修改 darknet/python/darknet.py 的第48行,指定libdarknet.so所在的目录

lib = CDLL(root+"chineseocr/darknet/libdarknet.so", RTLD_GLOBAL)

其中root表示chineseocr所在的路径

(3)准备基础环境
在源代码文件中的setup.md中列举了该项目依赖的基础环境,如果是在cpu上运行则查看setup-cpu.md文件。
① 创建虚拟环境

# 创建虚拟环境
conda create -n chineseocr python=3.6 pip scipy numpy jupyter ipython
# 激活虚拟环境
source activate chineseocr


② 安装依赖包

git submodule init && git submodule update
pip install easydict opencv-contrib-python==4.0.0.21 Cython h5py lmdb mahotas pandas requests bs4 matplotlib lxml
pip install -U pillow
pip install keras==2.1.5 tensorflow==1.8 tensorflow-gpu==1.8
pip install web.py==0.40.dev0
conda install pytorch torchvision -c pytorch
pip install torch torchvision

(4)下载模型文件
在百度网盘上面下载预训练好的模型文件,并将所有文件复制到models目录中,下载地址为 https://pan.baidu.com/s/1gTW9gwJR6hlwTuyB6nCkzQ

(5)启动web服务
通过执行app.py启动web服务,启动后便能直接上传图片进行文字识别,执行命令为

ipython app.py 8080

其中,8080为端口号,可根据实际需要进行修改。

 


启动后的界面如下,界面中提供了是否进行文字方向检测、是否作单行文字识别,以及通用OCR(默认)、火车票、身份证的识别类型。
 
在chineseocr项目中的test目录里面自带了一些测试图片,通过上传一些图片测试识别效果,如下图:
 
从识别效果上看还不错,接下来试一下火车票、身份证类型的识别
 
从上图可看出,对火车票的识别结果进行了处理,将出发地点、到达地点、车次、时间、价格、姓名等信息提取了出来。
 
身份证的识别也是将姓名、性别、民族、出生年月、身份证号、住址这些信息提取了出来。
我们再比较一下,有使用文字方向检测和没有使用文字方向检测时的识别效果区别,如下图:
 
从识别的结果可以看出,对于一张颠倒的图片(或者具有一定的旋转角度),如果没有加上文字方向检测,则识别出来的结果文字会出现很大的偏差,而加上方向检测后则会正确地识别出来。

(6)识别能力封装
chineseocr项目支持多种方式的文字检测与识别,提供了多种模型可供选择,导致整个项目比较庞大。如果要将该项目的检测与识别能力抽离出来,提供给其它项目使用,则需根据实际业务场景进行简化,将识别能力进行封装。
例如我们选择keras yolo3进行文字检测,选择pytorch进行文字识别,去掉文字方向检测(假定输入的图片绝大多数是方向正确的),那么即可对chineseocr的源代码进行大幅精简。在model.py代码的基础上进行修改,去繁存简,对识别能力进行封装,方便提供给其它应用程序使用。修改后的核心代码如下:

# 文字检测
def text_detect(img,MAX_HORIZONTAL_GAP=30,MIN_V_OVERLAPS=0.6,MIN_SIZE_SIM=0.6,TEXT_PROPOSALS_MIN_SCORE=0.7,TEXT_PROPOSALS_NMS_THRESH=0.3,TEXT_LINE_NMS_THRESH=0.3,):
    boxes, scores = detect.text_detect(np.array(img))
    boxes = np.array(boxes, dtype=np.float32)
    scores = np.array(scores, dtype=np.float32)
    textdetector = TextDetector(MAX_HORIZONTAL_GAP, MIN_V_OVERLAPS, MIN_SIZE_SIM)
    shape = img.shape[:2]
    boxes = textdetector.detect(boxes,scores[:, np.newaxis],shape,TEXT_PROPOSALS_MIN_SCORE,TEXT_PROPOSALS_NMS_THRESH,TEXT_LINE_NMS_THRESH,)
    text_recs = get_boxes(boxes)
    newBox = []
    rx = 1
    ry = 1
    for box in text_recs:
        x1, y1 = (box[0], box[1])
        x2, y2 = (box[2], box[3])
        x3, y3 = (box[6], box[7])
        x4, y4 = (box[4], box[5])
        newBox.append([x1 * rx, y1 * ry, x2 * rx, y2 * ry, x3 * rx, y3 * ry, x4 * rx, y4 * ry])
    return newBox

# 文字识别
def crnnRec(im, boxes, leftAdjust=False, rightAdjust=False, alph=0.2, f=1.0):
    results = []
    im = Image.fromarray(im)
    for index, box in enumerate(boxes):
        degree, w, h, cx, cy = solve(box)
        partImg, newW, newH = rotate_cut_img(im, degree, box, w, h, leftAdjust, rightAdjust, alph)
        text = crnnOcr(partImg.convert('L'))
        if text.strip() != u'':
            results.append({'cx': cx * f, 'cy': cy * f, 'text': text, 'w': newW * f, 'h': newH * f,
                            'degree': degree * 180.0 / np.pi})
    return results

# 文字检测、文字识别的能力封装
def ocr_model(img, leftAdjust=True, rightAdjust=True, alph=0.02):
    img, f = letterbox_image(Image.fromarray(img), IMGSIZE)
    img = np.array(img)
    config = dict(MAX_HORIZONTAL_GAP=50,  ##字符之间的最大间隔,用于文本行的合并
                  MIN_V_OVERLAPS=0.6,
                  MIN_SIZE_SIM=0.6,
                  TEXT_PROPOSALS_MIN_SCORE=0.1,
                  TEXT_PROPOSALS_NMS_THRESH=0.3,
                  TEXT_LINE_NMS_THRESH=0.7,  ##文本行之间测iou值
                  )
    config['img'] = img
    text_recs = text_detect(**config)  ##文字检测
    newBox = sort_box(text_recs)  ##行文本识别
    result = crnnRec(np.array(img), newBox, leftAdjust, rightAdjust, alph, 1.0 / f)
    return result

经过以上重新改造封装后,只需要调用ocr_model函数,输入图片,即可调用chineseocr项目的检测与识别能力。调用结果如下图:

以上介绍的就是LSTM+CTC、CRNN、chineseocr三种文字识别方法的实战操作,在实际生产中一般会根据业务场景,对识别方法进行改造或增加预处理、后处理环节。如果有兴趣了解的,可私信我再进行交流。

 

欢迎关注本人的微信公众号“大数据与人工智能Lab”(BigdataAILab),获取 完整源代码

 

推荐相关阅读

1、AI 实战系列

2、大话深度学习系列

3、图解 AI 系列

4、AI 杂谈

5、大数据超详细系列

© 著作权归作者所有

雪饼

雪饼

粉丝 385
博文 61
码字总数 134328
作品 0
广州
私信 提问
加载中

评论(8)

jingshishengxu
jingshishengxu
👍
mymbrooks
mymbrooks
支持 难得看到把细节讲的很清楚的教程,修改后的源码最好能发布到 Github 方便测试
雪饼
雪饼 博主
恩,在整理,后面会放到 github 上。谢谢关注。欢迎关注微信公众号“大数据与人工智能Lab”(BigdataAILab),有更多好看的内容 :)
A
AIU_developer
写的特别好,good work
credit.common
cstrcteval
cstrct
sumitclub
jp.co.tis.kokuho
雪饼
雪饼 博主
感谢关注
1993571506
1993571506
写的 很详细
雪饼
雪饼 博主
谢谢支持,欢迎关注微信公众号“大数据与人工智能Lab”(BigdataAILab),获取更多信息 ~
我的名字叫李猜
我的名字叫李猜
前排吧。
【AI实战】手把手教你文字识别(检测篇二:AdvancedEAST、PixelLink方法)

自然场景下的文字检测是深度学习的重要应用,在之前的文章中已经介绍过了在简单场景、复杂场景下的文字检测方法,包括MSER+NMS、CTPN、SegLink、EAST等方法,详见文章: 【AI实战】手把手教你...

雪饼
06/24
0
8
【图解AI:动图】各种类型的卷积,你认全了吗?

卷积(convolution)是深度学习中非常有用的计算操作,主要用于提取图像的特征。在近几年来深度学习快速发展的过程中,卷积从标准卷积演变出了反卷积、可分离卷积、分组卷积等各种类型,以适...

雪饼
06/20
0
0
【AI实战】手把手教你深度学习文字识别(文字检测篇:基于MSER, CTPN, SegLink, EAST等方法)

文字检测是文字识别过程中的一个非常重要的环节,文字检测的主要目标是将图片中的文字区域位置检测出来,以便于进行后面的文字识别,只有找到了文本所在区域,才能对其内容进行识别。 文字检...

雪饼
05/27
0
6
NLP 之自然场景文字识别 2 CRNN tensorflow

这篇博客主要讨论CRNN 的工作原理, 主要讨论的论文是 An End-to-End Trainable Neural Network for Image-based Sequence Recognition and Its Application to Scene Text Recognition http......

涛涛江水向坡流
2018/08/01
0
0
【AI实战】手把手教你训练自己的目标检测模型(SSD篇)

目标检测是AI的一项重要应用,通过目标检测模型能在图像中把人、动物、汽车、飞机等目标物体检测出来,甚至还能将物体的轮廓描绘出来,就像下面这张图,是不是很酷炫呢,嘿嘿 在动手训练自己...

雪饼
2018/08/14
0
25

没有更多内容

加载失败,请刷新页面

加载更多

Linux输入法fcitx的安装问题

Fcitx 总共要安装的包如下 fcitxfcitx-binfcitx-config-commonfcitx-config-gtk | fcitx-config-gtk2fcitx-datafcitx-frontend-allfcitx-frontend-gtk2fcitx-frontend-gtk3......

CHONGCHEN
50分钟前
4
0
网络基础

前言: 最近整理一些以前的学习笔记(有部分缺失,会有些乱,日后再补)。 过去都是存储在本地,此次传到网络留待备用。 计算机网络的功能: 1.数据通信; 2.资源共享; 3.增加数据可靠性; 4....

迷失De挣扎
50分钟前
5
0
spring boot升级到spring cloud

1、先升级spring boot 版本到2.1.3 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-dependencies</artifactId> <version>2.1.3.RELEAS......

moon888
54分钟前
10
0
从蓝鲸视角谈DevOps

DevOps源于Development和Operations的组合 常见的定义 DevOps是一种重视“软件开发人员(Dev)”和“IT运维技术人员(Ops)”之间沟通合作的文化、运动或惯例。透过自动化“软件交付”和“架构变...

嘉为科技
56分钟前
1
0
微服务设计 笔记

微服务设计 一、微服务架构理论 1.六边形架构 1)六边形架构(Hexagonal Architecture),又称为端口和适配器架构风格;使用适配器与外界进行交互,外界通过应用层API与内部进行交互。 2)经典...

啃不动地大坚果
今天
3
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部