TensorFlow框架-验证码识别以及分布式

一.验证码识别实战

1.验证码写入tfrecord

import tensorflow as tf
import os
# tensorflow 日志级别，1（默认级别）打印所有日志，2显示warning和error，3只显示error
os.environ['TF_CPP_MIN_LOG_LEVEl'] = '2'

FLAGS = tf.app.flags.FLAGS
tf.app.flags.DEFINE_string("tfrecords_dir","./tfrecords/","验证码tfrecords文件")
tf.app.flags.DEFINE_string("captcha_dir","../captcha_data/","验证码图片路径")
tf.app.flags.DEFINE_string("letter","ABCDEFGHIJKLMNOPQRSTUVWXYZ","验证码字符的种类")

def dealwithlabel(label_str):
    # 构建字符索引 {0：'A', 1:'B'......}
    num_letter = dict(enumerate(list(FLAGS.letter)))
    print(num_letter)
    # 键值对反转 {'A':0, 'B':1......}, 映射函数方式来构造字典,zip函数
    letter_num = dict(zip(num_letter.values(),num_letter.keys()))
    print(letter_num)
    # 构建标签的列表
    array = []

    # 给标签数据进行处理[[b"NZPP"]......]
    for string in label_str:
        letter_list = []
        # 修改编码，b'FVQJ'到字符串，并且循环找到每张验证码的字符对应的数字标记
        for letter in string.decode('utf-8'):
            letter_list.append(letter_num[letter])
        array.append(letter_list)
    # [[13, 25, 15, 15], [22, 10, 7, 10], [22, 15, 18, 9], [16, 6, 13, 10], [1, 0, 8, 17], [0, 9, 24, 14].....]
    print(array)

    # 将array转换成tensor类型
    label = tf.constant(array)

    return label


def get_captcha_image():
    """
    获取验证码图片数据
    :param file_list: 路径+文件名列表
    :return: image
    """
    # 构造文件名
    filename = []

    for i in range(6000):
        string = str(i)+".jpg"
        filename.append(string)

    # 构造路径+文件
    file_list = [os.path.join(FLAGS.captcha_dir,file) for file in filename]

    # 构造文件队列
    file_queue = tf.train.string_input_producer(file_list,shuffle=False)

    # 构造阅读器
    reader = tf.WholeFileReader()

    # 读取图片数据内容
    key,value = reader.read(file_queue)

    # 解码图片数据
    image = tf.image.decode_jpeg(value)

    image.set_shape([20,80,3])

    # 批处理数据 [6000, 20, 80, 3]
    image_batch = tf.train.batch([image],batch_size=6000,num_threads=1,capacity=1)

    return image_batch

def get_captcha_label():
    """
    读取验证码图片标签数据
    :return: label
    """
    file_queue = tf.train.string_input_producer(["../data/Genpics/labels.csv"],shuffle=False)
    reader = tf.TextLineReader()
    key,value = reader.read(file_queue)
    records = [[1],["None"]]
    number,label = tf.decode_csv(value,record_defaults=records)
    # 批量读取数据
    label_batch = tf.tain.batch([label],batch_size=6000,num_threads=1,capacity=6000)

    return label_batch

def write_to_tfrecords(image_batch,label_batch):
    """
    将图片内容和标签写入到tfrecords文件当中
    :param image_batch: 特征值
    :param label_batch: 标签纸
    :return: None
    """
    # 转换类型
    label_batch = tf.cast(label_batch,tf.int8)
    print(label_batch)

    # 建立TFRecords 存储器
    writer = tf.python_io.TFRecordWriter(FLAGS.tfrecords_dir)

    for i in range(6000):
        # 取出第i个图片数据，转换相应类型,图片的特征值要转换成字符串形式
        image_string = image_batch[i].eval().tostring()
        # 标签值，转换成整型
        label_string = label_batch[i].eval().tostring()

        # 构造协议块
        example = tf.train.Example(features=tf.train.Features(feature={
            "image":tf.train.Feature(bytes_list=tf.train.BytesList(value=[image_string])),
            "label":tf.train.Feature(bytes_list=tf.train.BytesList(value=[label_string]))
        }))
        writer.write(example.SerializeToString())
    writer.close()

    return None
if __name__ == "__main__":
    # 获取验证码文件当中的图片
    image_batch = get_captcha_image()
    # 获取验证码文件当中的标签数据
    label = get_captcha_label()

    print(image_batch,label)

    with tf.Session() as sess:
        coord = tf.train.Coordinator()
        threads = tf.train.start_queue_runners(sess=sess,coord=coord)

        # [b'NZPP' b'WKHK' b'WPSJ' ..., b'FVQJ' b'BQYA' b'BCHR']
        label_str = sess.run(label)

        print(label_str)

        # 处理字符串标签到数字张量
        label_batch = dealwithlabel(label_str)

        print(label_batch)

        #  将图片数据和内容写入到tfrecords文件当中
        write_to_tfrecords(image_batch, label_batch)

        coord.request_stop()

        coord.join(threads)     

2.验证码训练

import tensorflow as tf

FLAGS = tf.app.flags.FLAGS

tf.app.flags.DEFINE_string("captcha_dir","./tfrecords/captcha.tfrecords","验证码数据的路径")
tf.app.flags.DEFINE_integer("batch_size",100,"每批次训练的样本数")
tf.app.flags.DEFINE_integer("label_num",4,"每个样本的目标值数量")
tf.app.flags.DEFINE_integer("letter_num",26,"每个目标值取的字母的可能性个数")


# 定义一个初始化权重的函数
def weight_variable(shape):
    w = tf.Variable(tf.random_normal(shape=shape,mean=0.0,stddev=1.0))
    return w


# 定义一个初始化偏置的函数
def bias_variable(shape):
    b = tf.Variable(tf.constant(0.0,shape=shape))
    return b


def read_and_decode():
    """
    读取验证码数据API
    :return: image_batch, label_batch
    """
    # 1、构建文件队列
    file_queue = tf.train.string_input_producer([FLAGS.captcha_dir])

    # 2、构建阅读器，读取文件内容，默认一个样本
    reader = tf.TFRecordReader()
    # 读取内容
    key,value = reader.read(file_queue)

    # tfrecords格式example,需要解析
    features = tf.parse_single_example(value,features={
        "image":tf.FixedLenFeature([],tf.string),
        "label":tf.FixedLenFeature([],tf.string)
    })
    # 解码内容，字符串内容
    # 1、先解析图片的特征值
    image = tf.decode_raw(features["image"],tf.uint8)
    # 2、再解析图片的目标值
    label = tf.decode_raw(features["label"],tf.uint8)

    # 改变形状
    image_reshape = tf.reshape(image,[20,80,3])
    label_reshape = tf.reshape(label,[4])

    print(image_reshape,label_reshape)
    # 进行批处理,每批次读取的样本数 100, 也就是每次训练时候的样本
    image_batch,label_batch = tf.train.batch([image_reshape,label_reshape],batch_size=FLAGS.batch_size,num_threads=1,capacity=FLAGS.batch_size)

    print(image_batch,label_batch)

    return image_batch,label_batch

def fc_model(image):
    """
    进行预测结果
    :param image: 100图片特征值[100, 20, 80, 3]
    :return: y_predict预测值[100, 4 * 26]
    """
    with tf.variable_scope("model"):
        # 将图片数据形状转换成二维的形状
        image_reshape = tf.reshape(image,[-1,20*80*3])

        # 1、随机初始化权重偏置
        # matrix[100, 20 * 80 * 3] * [20 * 80 * 3, 4 * 26] + [104] = [100, 4 * 26]
        weights = weight_variable([20*80*3,4*26])
        bias = weight_variable([4*26])

        y_predict = tf.matmul(tf.cast(image_reshape,tf.float32),weights) + bias

    return y_predict


def predict_to_onehot(label):
    """
    将读取文件当中的目标值转换成one-hot编码
    :param label: [100, 4]      [[13, 25, 15, 15], [19, 23, 20, 16]......]
    :return: one-hot
    """
    # 进行one_hot编码转换，提供给交叉熵损失计算，准确率计算[100, 4, 26]
    # one-hot类型数据长度为depth位

    label_onehot = tf.one_hot(label,depth=FLAGS.letter_num,on_value=1.0,axis=2)
    print(label_onehot)
    return label_onehot

def captcharec():
    """
    验证码识别程序
    :return:
    """
    # 1、读取验证码的数据文件 label_btch [100 ,4]
    image_batch,label_batch = read_and_decode()
    # 2、通过输入图片特征数据，建立模型，得出预测结果
    # 一层，全连接神经网络进行预测
    # matrix [100, 20 * 80 * 3] * [20 * 80 * 3, 4 * 26] + [104] = [100, 4 * 26]
    y_predict = fc_model(image_batch)
    #  [100, 4 * 26]
    print(y_predict)

    # 3、先把目标值转换成one-hot编码 [100, 4, 26]
    y_true = predict_to_onehot(label_batch)

    # 4、softmax计算, 交叉熵损失计算
    with tf.variable_scope("soft_cross"):
        # 求平均交叉熵损失 ,y_true [100, 4, 26]--->[100, 4*26]
        loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
            labels = tf.reshape(y_true,[FLAGS.batch_size,FLAGS.label_num*FLAGS.letter_num]),
            logits = y_predict
        ))
    # 5、梯度下降优化损失
    with tf.variable_scope("optimizer"):
        train_op = tf.train.GradientDescentOptimizer(0.01).minimize(loss)
        
    # 6、求出样本的每批次预测的准确率是多少 三维比较
    with tf.variable_scope("acc"):
        # 比较每个预测值和目标值是否位置(4)一样    y_predict [100, 4 * 26]---->[100, 4, 26]
        equal_list = tf.equal(tf.argmax(y_true,2),tf.argmax(tf.reshape(y_predict,[FLAGS.batch_size,FLAGS.label_num,FLAGS.letter_num]),2))
        # equal_list  100个样本   [1, 0, 1, 0, 1, 1,..........]
        accuracy = tf.reduce_mean(tf.cast(equal_list,tf.float32))

    # 定义一个初始化变量的op
    init_op = tf.global_variables_initializer()

    with tf.Session() as sess:
        sess.run(init_op)

        # 定义线程协调器和开启线程（有数据在文件当中读取提供给模型）
        coord = tf.train.Coordinator()

        # 开启线程去运行读取文件操作
        threads = tf.train.start_queue_runners(sess,coord=coord)

        # 训练识别程序
        for i in range(5000):
            sess.run(train_op)

            print("第%d批次的准确率为：%f" % (i, accuracy.eval()))

        # 回收线程
        coord.request_stop()

        coord.join(threads)
        return None

if __name__ == "__main__":
    captcharec()

二.分布式

1.分布式会话函数

MonitoredTrainingSession(master=‘’,is_chief=True,checkpoint_dir=None,hooks=None,save_checkpoint_secs=600,save_summaries_steps=USE_DEFAULT,save_summaries_secs=USE_DEFAULT,config=None)

分布式会话函数
master:指定运行会话协议IP和端口（用于分布式）“grpc://192.168.0.1:2000”
is_chief:是否为主worker（用于分布式）如果True，它将负责初始化和恢复基础的TensorFlow会话。如果False，它将等待一位负责人初始化或恢复TensorFlow会话。
checkpoint_dir:检查点文件目录，同时也是events目录
config:会话运行的配置项, tf.ConfigProto(log_device_placement=True)
hooks:可选SessionRunHook对象列表
should_stop():是否异常停止
run():跟session一样可以运行op

2.hooks函数

tf.train.SessionRunHook
Hook to extend calls to MonitoredSession.run()
(1)、begin():在会话之前，做初始化工作
(2)、before_run(run_context):在每次调用run()之前调用，以添加run()中的参数。
参数：
run_context：一个SessionRunContext对象，包含会话运行信息
return：一个SessionRunArgs对象，例如：tf.train.SessionRunArgs(loss)
(3)、after_run(run_context,run_values) :在每次调用run()后调用，一般用于运行之后的结果处理
该run_values参数包含所请求的操作/张量的结果 before_run()。
该run_context参数是相同的一个发送到before_run呼叫。
参数：
run_context：一个SessionRunContext对象
run_values一个SessionRunValues对象, run_values.results

3.常用hooks

tf.train.StopAtStepHook(last_step=5000):指定执行的训练轮数也就是max_step，超过了就会抛出异常
tf.train.NanTensorHook(loss):判断指定Tensor是否为NaN，为NaN则结束。
注：在使用钩子的时候需要定义一个全局步数：global_step = tf.contrib.framework.get_or_create_global_step()

4.分布式tensorflow

分布式Tensorflow是由高性能的gRPC框架作为底层技术来支持的。这是一个通信框架gRPC(google remote procedure call)，是一个高性能、跨平台的RPC框架。RPC协议，即远程过程调用协议，是指通过网络从远程计算机程序上请求服务。

5.分布式api

（1）、创建一个tf.train.ClusterSpec，用于对集群中的所有任务进行描述，该描述内容对所有任务应该是相同的
（2）、创建一个tf.train.Server，用于创建一个任务(ps,worker)，并运行相应作业上的计算任务。

6.分布式tensorflow流程

（1）、创建集群
cluster = tf.train.ClusterSpec({“ps”: ps_spec, “worker”: worker_spec})
cluster = tf.train.ClusterSpec(
{
“worker”: [“worker0.example.com:2222”, /job:worker/task:0 “worker1.example.com:2222”, /job:worker/task:1 “worker2.example.com:2222”, /job:worker/task:2 ]
“ps”: [“ps0.example.com:2222”, /job:ps/task:0 “ps1.example.com:2222” /job:ps/task:1]
})
（2）、创建服务
tf.train.Server(server_or_cluster_def, job_name=None, task_index=None, protocol=None, config=None, start=True)
创建服务(ps,worker)
server_or_cluster_def: 集群描述
job_name: 任务类型名称
task_index: 任务数
attribute：target
返回tf.Session连接到此服务器的目标
method：join()
参数服务器端，直到服务器等待接受参数任务关闭
（3）、工作节点指定设备运行
tf.device(device_name_or_function) 选择指定设备或者设备函数
if device_name: 指定设备
例如："/job:worker/task:0/cpu:0”
if function:
tf.train.replica_device_setter(worker_device=worker_device,cluster=cluster)
作用：通过此函数协调不同设备上的初始化操作
worker_device:为指定设备, “/job:worker/task:0/cpu:0” or “/job:worker/task:0/gpu:0”
cluster:集群描述对象

import tensorflow as tf

FLAGS = tf.app.flags.FLAGS

tf.app.flags.DEFINE_string("job_name"," ","启动服务的类型ps or worker")
tf.app.flags.DEFINE_integer("task_name",0,"指定ps或者worker当中的哪一台服务器")


def main(argv):
    # 定义全集计数的op ，给钩子列表当中的训练步数使用
    global_step = tf.contrib.framework.get_or_create_global_step()

    # 指定集群描述对象， ps , worker
    cluster = tf.train.ClusterSpec({"ps":["10.211.55.3:2223"],"worker":["192.168.65.44:2222"]})

    # 创建不同的服务, ps, worker
    server = tf.train.Server(cluster,job_name=FLAGS.job_name,task_index=FLAGS.task_index)

    # 根据不同服务做不同的事情 ps:去更新保存参数 worker:指定设备去运行模型计算
    if FLAGS.job_name=="ps":
        # 参数服务器什么都不用干，是需要等待worker传递参数
        server.join()
    else:
        worker_device = "/job:worker/task:0/cpu:0/"

        # 可以指定设备取运行
        with tf.device(tf.train.replica_device_setter(
            worker_device=worker_device,
            cluster=cluster
        )):
            # 简单做一个矩阵乘法运算
            x = tf.Variable([[1,2,3,4]])
            w = tf.Variable([[2],[2],[2],[2]])
            mat = tf.matmul(x,w)
        # 创建分布式会话
        with tf.train.MonitoredTrainingSession(
            master = "grpc://192.168.65.44:2222",# 指定主worker
            is_chief = (FLAGS.task_index == 0),# 判断是否是主worker
            config = tf.ConfigProto(log_device_placement=True),# 打印设备信息
            hooks = [tf.train.StopAtStepHook(last_step=200)]
        ) as mon_sess:
            while not mon_sess.should_stop():
                print(mon_sess.run(mat))
if __name__=="__main__":
    tf.app.run()