• 深度学习（2）：图片文字识别

    目的：基于深度学习算法DenseNet对图片进行文字识别，即OCR转换为文字，并将图片进行可视化输出。

    一、 DenseNet算法

    算法具体参考DenseNet算法详解_@浪里小白龙的博客-CSDN博客_densenet算法详解

    二、模型训练

    1.导入库

    !pip install tensorflow==1.15.0 -i https://pypi.tuna.tsinghua.edu.cn/simple

    1. import os
    2. import json
    3. import threading
    4. from keras import losses
    5. from keras.utils import plot_model
    6. from keras.preprocessing import image
    7. from keras.preprocessing.sequence import pad_sequences
    8.  
    9. from keras.layers.recurrent import GRU, LSTM
    10. from keras.layers.wrappers import Bidirectional, TimeDistributed
    11. from keras.layers.normalization import BatchNormalization
    12. from keras.layers.convolutional import Conv2D, MaxPooling2D, ZeroPadding2D,Conv2DTranspose
    13. from keras.optimizers import SGD, Adam
    14.  
    15. import numpy as np
    16. from PIL import Image
    17. import tensorflow.compat.v1 as tf
    18. tf.disable_v2_behavior()
    19.  
    20. from keras import backend as K
    21. from keras.layers import Input, Dense, Flatten
    22. from keras.layers.core import Reshape, Masking, Lambda, Permute, Activation,Dropout
    23. from keras.models import Model
    24. from keras.callbacks import EarlyStopping, ModelCheckpoint, LearningRateScheduler, TensorBoard
    25. from imp import reload
    26.  
    27. from keras.layers.pooling import AveragePooling2D, GlobalAveragePooling2D
    28. from keras.layers.merge import concatenate
    29. from keras.layers.normalization import BatchNormalization
    30. from keras.regularizers import l2
    31. from keras.layers.wrappers import TimeDistributed

     

    2.准备数据

    1. #准备数据，从OSS中获取数据并解压到当前目录：
    2.  
    3. import oss2
    4. access_key_id = os.getenv('OSS_TEST_ACCESS_KEY_ID', 'LTAI4G1MuHTUeNrKdQEPnbph')
    5. access_key_secret = os.getenv('OSS_TEST_ACCESS_KEY_SECRET', 'm1ILSoVqcPUxFFDqer4tKDxDkoP1ji')
    6. bucket_name = os.getenv('OSS_TEST_BUCKET', 'mldemo')
    7. endpoint = os.getenv('OSS_TEST_ENDPOINT', 'https://oss-cn-shanghai.aliyuncs.com')
    8. # 创建Bucket对象，所有Object相关的接口都可以通过Bucket对象来进行
    9. bucket = oss2.Bucket(oss2.Auth(access_key_id, access_key_secret), endpoint, bucket_name)
    10. # 下载到本地文件
    11. bucket.get_object_to_file('data/c12/image_ocr_data.zip', 'image_ocr_data.zip')

     

    1. #解压缩文件
    2. !unzip -o -q image_ocr_data.zip

     

     

     3.定义工具函数

    1. # 获取Tensorflow中Session
    2. def get_session(gpu_fraction=1.0):
    3.  
    4.     num_threads = os.environ.get('OMP_NUM_THREADS')
    5.     gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=gpu_fraction)
    6.  
    7.     if num_threads:
    8.         return tf.Session(config=tf.ConfigProto(
    9.             gpu_options=gpu_options, intra_op_parallelism_threads=num_threads))
    10.     else:
    11.         return tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))
    12.  
    13. # 读取文件方法
    14. def readfile(filename):
    15.     res = []
    16.     with open(filename, 'r') as f:
    17.         lines = f.readlines()
    18.         for i in lines:
    19.             res.append(i.strip())
    20.     dic = {}
    21.     for i in res:
    22.         p = i.split(' ')
    23.         dic[p[0]] = p[1:]
    24.     return dic
    25.  
    26. # 随机化选择图片
    27. class random_uniform_num():
    28.     """
    29.     均匀随机，确保每轮每个只出现一次
    30.     """
    31.     def __init__(self, total):
    32.         self.total = total
    33.         self.range = [i for i in range(total)]
    34.         np.random.shuffle(self.range)
    35.         self.index = 0
    36.     def get(self, batchsize):
    37.         r_n=[]
    38.         if(self.index + batchsize > self.total):
    39.             r_n_1 = self.range[self.index:self.total]
    40.             np.random.shuffle(self.range)
    41.             self.index = (self.index + batchsize) - self.total
    42.             r_n_2 = self.range[0:self.index]
    43.             r_n.extend(r_n_1)
    44.             r_n.extend(r_n_2)
    45.         else:
    46.             r_n = self.range[self.index : self.index + batchsize]
    47.             self.index = self.index + batchsize
    48.  
    49.         return r_n

    4.训练图片探索

    1. import os
    2. import numpy as np
    3. import matplotlib.pyplot as plt
    4. import random
    5. %matplotlib inline
    6.  
    7. # 从训练图片集中随机选择18张图片的说明
    8. directory = "./image_ocr_data/train_imgs/samples_images/"
    9. images = random.choices(os.listdir(directory), k=18)
    10.  
    11. fig = plt.figure(figsize=(60, 10))
    12. # 3列
    13. columns = 6
    14. # 3行
    15. rows = 3
    16.  
    17. # 显示18张图片及对应图片说明
    18. for x, i in enumerate(images):
    19.     path =  os.path.join(directory,i)
    20.     img = plt.imread(path)
    21.     fig.add_subplot(rows, columns, x+1)
    22.     plt.imshow(img)
    23.     
    24.     
    25. plt.show()

    5.数据生成器

    1. # 训练数据生成器，用于读取训练、测试集样本
    2. def gen(data_file, image_path, batchsize=128, maxlabellength=10, imagesize=(32, 280)):
    3.     image_label = readfile(data_file)
    4.     _imagefile = [i for i, j in image_label.items()]
    5.     x = np.zeros((batchsize, imagesize[0], imagesize[1], 1), dtype=np.float)
    6.     labels = np.ones([batchsize, maxlabellength]) * 10000
    7.     input_length = np.zeros([batchsize, 1])
    8.     label_length = np.zeros([batchsize, 1])
    9.  
    10.     r_n = random_uniform_num(len(_imagefile))
    11.     _imagefile = np.array(_imagefile)
    12.     while 1:
    13.         shufimagefile = _imagefile[r_n.get(batchsize)]
    14.         for i, j in enumerate(shufimagefile):
    15.             img1 = Image.open(os.path.join(image_path, j)).convert('L')
    16.             # 图片归一化处理
    17.             img = np.array(img1, 'f') / 255.0 - 0.5
    18.  
    19.             x[i] = np.expand_dims(img, axis=2)
    20.             str = image_label[j]
    21.             label_length[i] = len(str)
    22.  
    23.             input_length[i] = imagesize[1] // 8
    24.             labels[i, :len(str)] = [int(k) for k in str]
    25.         
    26.         inputs = {'the_input': x,
    27.                 'the_labels': labels,
    28.                 'input_length': input_length,
    29.                 'label_length': label_length,
    30.                 }
    31.         outputs = {'ctc': np.zeros([batchsize])}
    32.         #输出已经构建好的样本输入和输出
    33.         yield (inputs, outputs)

     6.DenseNet网络结构定义

    1. # 定义卷积块
    2. def conv_block(input, growth_rate, dropout_rate=None, weight_decay=1e-4):
    3.     x = BatchNormalization(axis=-1, epsilon=1.1e-5)(input)
    4.     x = Activation('relu')(x)
    5.     x = Conv2D(growth_rate, (3,3), kernel_initializer='he_normal', padding='same')(x)
    6.     if(dropout_rate):
    7.         x = Dropout(dropout_rate)(x)
    8.     return x
    9.  
    10. # 定义dense块
    11. def dense_block(x, nb_layers, nb_filter, growth_rate, droput_rate=0.2, weight_decay=1e-4):
    12.     # 定义dense块中多个卷积层
    13.     for i in range(nb_layers):
    14.         cb = conv_block(x, growth_rate, droput_rate, weight_decay)
    15.         # 连接卷积层
    16.         x = concatenate([x, cb], axis=-1)
    17.         nb_filter += growth_rate
    18.     return x, nb_filter
    19.  
    20. # 定义块直连
    21. def transition_block(input, nb_filter, dropout_rate=None, pooltype=1, weight_decay=1e-4):
    22.     x = BatchNormalization(axis=-1, epsilon=1.1e-5)(input)
    23.     x = Activation('relu')(x)
    24.     x = Conv2D(nb_filter, (1, 1), kernel_initializer='he_normal', padding='same', use_bias=False,
    25.                kernel_regularizer=l2(weight_decay))(x)
    26.  
    27.     if(dropout_rate):
    28.         x = Dropout(dropout_rate)(x)
    29.  
    30.     if(pooltype == 2):
    31.         x = AveragePooling2D((2, 2), strides=(2, 2))(x)
    32.     elif(pooltype == 1):
    33.         x = ZeroPadding2D(padding = (0, 1))(x)
    34.         x = AveragePooling2D((2, 2), strides=(2, 1))(x)
    35.     elif(pooltype == 3):
    36.         x = AveragePooling2D((2, 2), strides=(2, 1))(x)
    37.     return x, nb_filter
    38.  
    39. # 定义densenet网络
    40. def dense_cnn(input, nclass):
    41.  
    42.     _dropout_rate = 0.2
    43.     _weight_decay = 1e-4
    44.  
    45.     _nb_filter = 64
    46.     # conv 64 5*5 s=2
    47.     x = Conv2D(_nb_filter, (5, 5), strides=(2, 2), kernel_initializer='he_normal', padding='same',
    48.                use_bias=False, kernel_regularizer=l2(_weight_decay))(input)
    49.    
    50.     # 64 + 8 * 8 = 128
    51.     x, _nb_filter = dense_block(x, 8, _nb_filter, 8, None, _weight_decay)
    52.     # 128
    53.     x, _nb_filter = transition_block(x, 128, _dropout_rate, 2, _weight_decay)
    54.  
    55.     # 128 + 8 * 8 = 192
    56.     x, _nb_filter = dense_block(x, 8, _nb_filter, 8, None, _weight_decay)
    57.     # 192 -> 128
    58.     x, _nb_filter = transition_block(x, 128, _dropout_rate, 2, _weight_decay)
    59.  
    60.     # 128 + 8 * 8 = 192
    61.     x, _nb_filter = dense_block(x, 8, _nb_filter, 8, None, _weight_decay)
    62.  
    63.     x = BatchNormalization(axis=-1, epsilon=1.1e-5)(x)
    64.     x = Activation('relu')(x)
    65.  
    66.     x = Permute((2, 1, 3), name='permute')(x)
    67.     x = TimeDistributed(Flatten(), name='flatten')(x)
    68.     y_pred = Dense(nclass, name='out', activation='softmax')(x)
    69.  
    70.     return y_pred

    7.损失函数

    模型的损失函数采用ctc（Connectionist Temporal Classification），其定义代码如下：

    1. # 损失函数定义
    2. def ctc_lambda_func(args):
    3.     y_pred, labels, input_length, label_length = args
    4.     return K.ctc_batch_cost(labels, y_pred, input_length, label_length)

    8.模型定义 

    1. # 模型定义
    2. def get_model(img_h, nclass):
    3.     input = Input(shape=(img_h, None, 1), name='the_input')
    4.     
    5.     # 网络结构定义
    6.     y_pred = dense_cnn(input, nclass)
    7.  
    8.     # 输入层定义
    9.     labels = Input(name='the_labels', shape=[None], dtype='float32')
    10.     input_length = Input(name='input_length', shape=[1], dtype='int64')
    11.     label_length = Input(name='label_length', shape=[1], dtype='int64')
    12.  
    13.     # 损失函数定义
    14.     loss_out = Lambda(ctc_lambda_func, output_shape=(1,), name='ctc')([y_pred, labels, input_length, label_length])
    15.  
    16.     # 模型定义
    17.     model = Model(inputs=[input, labels, input_length, label_length], outputs=loss_out)
    18.     # 模型编译
    19.     model.compile(loss={'ctc': lambda y_true, y_pred: y_pred}, optimizer='adam', metrics=['accuracy'])
    20.  
    21.     return model

    9. 模型训练方法定义

    1. def start_train(train_index_file_path,train_img_root_dir,test_index_file_path,test_img_root_dir,model_output_dir="./image_ocr_data/models",train_epochs=10):
    2.     #图片大小定义
    3.     img_height = 32
    4.     img_width = 200
    5.     
    6.     #训练批大小定义
    7.     batch_size = 32
    8.  
    9.     #输出标签类别
    10.     char_set = open('./image_ocr_data/labels.txt', 'r', encoding='utf-8').readlines()
    11.     char_set = ''.join([ch.strip('\n') for ch in char_set][1:] + ['卍'])
    12.     num_class = len(char_set) + 2
    13.  
    14.     # 加载定义模型
    15.     K.set_session(get_session())
    16.     model = get_model(img_height, num_class)
    17.     model.summary()
    18.     
    19.     # 如果有预训练模型，提前加载
    20.     modelPath = './image_ocr_data/models/pretrain_model.h5'
    21.     if os.path.exists(modelPath):
    22.         print("Loaded pretrained model weights...")
    23.         model.load_weights(modelPath)
    24.     
    25.     # 训练数据读取器
    26.     train_loader = gen(train_index_file_path, train_img_root_dir, batchsize=batch_size, maxlabellength=num_class,
    27.                        imagesize=(img_height, img_width))
    28.     # 测试数据加载器
    29.     test_loader = gen(test_index_file_path, test_img_root_dir, batchsize=batch_size, maxlabellength=num_class,
    30.                       imagesize=(img_height, img_width))
    31.     # 定义模型保存位置
    32.     model_save_path = os.path.join(model_output_dir,'weights_model-{epoch:02d}-{val_loss:.2f}.h5')
    33.     checkpoint = ModelCheckpoint(filepath=model_save_path, monitor='val_loss',
    34.                                  save_best_only=True, save_weights_only=True)
    35.     # 定义学习率更新策略
    36.     lr_schedule = lambda epoch: 0.005 * 0.1 ** epoch
    37.     learning_rate = np.array([lr_schedule(i) for i in range(20)])
    38.     changelr = LearningRateScheduler(lambda epoch: float(learning_rate[epoch]))
    39.     # 定义提前终止策略
    40.     earlystop = EarlyStopping(monitor='val_loss', patience=4, verbose=1)
    41.  
    42.     # 训练集样本数量
    43.     train_num_lines = sum(1 for line in open(train_index_file_path))
    44.     # 测试集样本数量
    45.     test_num_lines = sum(1 for line in open(test_index_file_path))
    46.  
    47.     #模型训练
    48.     model.fit_generator(train_loader,
    49.                         steps_per_epoch=train_num_lines // batch_size,
    50.                         epochs=int(train_epochs),
    51.                         initial_epoch=0,
    52.                         validation_data=test_loader,
    53.                         validation_steps=test_num_lines // batch_size,
    54.                         callbacks=[checkpoint, earlystop, changelr])

    10.模型训练

    MNIST 手写0-9数字图片识别
    rar 0星 超过10%的资源 11.06MB
    下载
    1. # 模型训练迭代次数1次
    2. # 模型训练结果保存在models目录下
    3. start_train("./image_ocr_data/data_3_train.txt","./image_ocr_data/train_imgs"
    4.             ,"./image_ocr_data/data_3_test.txt","./image_ocr_data/test_imgs","./image_ocr_data/models",1)

     

     

     

     

     

     

     

     

     

    三、模型使用

    1.导入库

    1. import os
    2. import numpy as np
    3. from imp import reload
    4. from PIL import Image, ImageOps
    5. import matplotlib.pyplot as plt
    6.  
    7. from keras.layers import Input
    8. from keras.models import Model
    9.  
    10. # import cv2
    11. import random
    12. from keras import backend as K
    13. from datetime import datetime
    14.  
    15. from tensorflow import Graph, Session
    16. from keras.models import load_model

    2.加载标签信息

    这些标签是识别结果的词典，即预测结果中总共的类别数量，代码如下：

    1. alphabet = u""" 0123456789.-ABCDEFGHIJKLMNOPQRSTUVWXYZ/"""
    2.  
    3. characters_abc = alphabet[:]
    4. characters_abc = characters_abc[1:] + u'卍'
    5. nclass_abc = len(characters_abc) + 2
    6. print("abc class count:", nclass_abc)
    pdf，图片文字识别软件，ocr
    rar 4星 超过85%的资源 36.48MB
    下载

     

     

    3.定义模型加载的方法

    使用Tensorflow中的Graph组件加载模型，并计算模型加载的总耗时长，代码如下：

    1. # 模型加载
    2. def model_abc():
    3.     graph2 = Graph()
    4.     with graph2.as_default():
    5.         session2 = Session(graph=graph2)
    6.         with session2.as_default():
    7.  
    8.             print('loading abc model...', datetime.now())
    9.             model_path = './image_ocr_data/models/pretrain_model.h5'
    10.  
    11.             # 定义模型输入
    12.             input = Input(shape=(32, None, 1), name='the_input')
    13.             y_pred = dense_cnn(input, nclass_abc)
    14.             basemodel = Model(inputs=input, outputs=y_pred)
    15.             
    16.             # 模型存放位置，如果存在则加载模型
    17.             modelPath = os.path.join(os.getcwd(), model_path)
    18.             if os.path.exists(modelPath):
    19.                 basemodel.load_weights(modelPath)
    20.             else:
    21.                 print("error: abc model not exists!")
    22.             print("load abc complete", datetime.now())
    23.  
    24.     return basemodel, session2, graph2
    1. # 将预测结果转化为文字内容
    2. def labels_to_text(labels):
    3.     ret = []
    4.     for c in labels:
    5.         if c == len(alphabet): 
    6.             ret.append("")
    7.         else:
    8.             ret.append(alphabet[c])
    9.     return "".join(ret)
    1. # 执行预测并将结果转化为文本内容
    2. def decode_predict_ctc(out, top_paths=1):
    3.     results = []
    4.     beam_width = 3
    5.     if beam_width < top_paths:
    6.         beam_width = top_paths
    7.     for i in range(top_paths):
    8.         lables = K.get_value(K.ctc_decode(out, input_length=np.ones(out.shape[0]) * out.shape[1],
    9.                                           greedy=False, beam_width=beam_width, top_paths=top_paths)[0][i])[0]
    10.         # 执行文字转化
    11.         text = self.labels_to_text(lables)
    12.         results.append(text)
    13.     return results
    14.  
    15. # 基于加载的模型进行图片文字识别
    16. def predict(model_abc,session_abc, graph_abc, imgX):
    17.     with graph_abc.as_default():
    18.         with session_abc.as_default():
    19.             y_pred = model_abc.predict(imgX)
    20.  
    21.     char_list = []
    22.     y_pred = y_pred[:, :, :]
    23.  
    24.     pred_text = y_pred.argmax(axis=2)[0]
    25.  
    26.     # 对识别结果进行后续处理
    27.     for i in range(len(pred_text)):
    28.         if pred_text[i] != nclass_abc - 1 and ((not (i > 0 and pred_text[i] == pred_text[i - 1])) or (i > 1 and pred_text[i] == pred_text[i - 2])):
    29.             char_list.append(characters_abc[pred_text[i] - 1])
    30.  
    31.     # 将结果合并
    32.     result = ''.join(char_list)
    33.     return result

    4.加载模型

    basemodel, session2, graph2 = model_abc()

     

     

    5.调用模型进行文字识别

    1. # 定义输入图片大小
    2. MAX_WIDTH = 200
    3. HEIGHT = 32
    4.  
    5. #从测试集中随选图识别
    6. directory = "./image_ocr_data/test_imgs/samples_images/"
    7. images = random.choices(os.listdir(directory), k=6)
    8.  
    9. # 构造多图显示
    10. fig = plt.figure(figsize=(30, 10))
    11. # 3列
    12. columns = 3
    13. # 2行
    14. rows = 2
    15.  
    16. for x, i in enumerate(images):
    17.     path =  os.path.join(directory,i)
    18.     img = plt.imread(path)
    19.  
    20.     fig.add_subplot(rows, columns, x+1)
    21.     
    22.     # 图片预处理
    23.     image = np.array(Image.open(path).convert('RGB'))
    24.     image = Image.fromarray(image).convert('L')
    25.     # 图片归一化
    26.     img_array = np.array(image).astype(np.float32) / 255.0 - 0.5
    27.  
    28.     # 图片大小转化
    29.     imgX = img_array.reshape([1, HEIGHT, MAX_WIDTH, 1])
    30.  
    31.     # 模型识别文字
    32.     text = predict(basemodel, session2, graph2,imgX)
    33.     
    34.     # 识别结果可视化
    35.     plt.title(text)
    36.     plt.imshow(img)

     

     

  • 相关阅读:
    R语言glm函数构建二分类logistic回归模型（family参数为binomial）、使用AIC函数比较两个模型的AIC值的差异（简单模型和复杂模型）
    ZooKeeper的ZAB协议？
    ​Qt for Python 入门¶​
    springboot+安全在线学习平台 毕业设计-附源码131019
    [附源码]java毕业设计校园拓展活动管理系统
    一些面试总结123
    SVN学习
    CSS餐厅练习链接及答案
    聚焦酷开科技智能大屏OS Coolita，打造智能推荐服务能力全景
    vue3 使用axios
  • 原文地址：https://blog.csdn.net/liuyingshudian/article/details/125960659