Netrual Network

最新推荐文章于 2023-03-11 18:11:58 发布

南方的树～

最新推荐文章于 2023-03-11 18:11:58 发布

阅读量905

点赞数 1

分类专栏： python 文章标签：深度学习

本文链接：https://blog.csdn.net/weixin_42384085/article/details/95237965

版权

python 专栏收录该内容

20 篇文章 1 订阅

订阅专栏

神经网络

一、神经网络基础

感知机
- 在n个输入数据，通过权重与各数据之间的计算和，比较激活函数结果，得出输出
- 应用：很容易解决与、或问题
  - 与或问题：于：所有的输入为1，输出为1.或：只要有一个为1，输出就为1.异或：相同为0，不同为1.
- 感知机解决分类问题，下图为简单的感知机模型
- 单个感知机解决不了的问题，可以增加
- Rosenblatt在1957年，于Cornell航空实验室所发明的一种人工神经网络
- 神经网络的发展
  - 定义：在机器学习和认知科学领域，人工神经网络（artificial neural network，缩写ANN），简称神经网络（neural network，缩写NN）或类神经网络，是一种模仿生物神经网络的结构和功能的计算模型，用于对函数进行估计或近似。
  - 神经网络的种类：
    - 基础神经网络：单层感知机，线性神经网络，BP神经网络，Hopfield网络等
    - 进阶神经网络：玻尔兹曼机，受限玻尔兹曼机，递归神经网络等
    - 深度神经网络：深度置信网络，卷积神经网络，循环神经网络，LSTM网络等
- 神经网络的特点
  - 输入向量的维度和输入神经元的个数相同
  - 每个连接都有个权值
  - 同一层神经元之间没有连接
  - 由输入层，隐层，输出层组成
  - 第N层与第N-1层的所有神经元连接，也叫全连接
- 神经网络的组成
  - 结构（Architecture）例如：神经网络中权重，神经元等等
  - 激活函数（Activity Rule）
  - 学习规则（Learning Rule）学习规则指定了网络中的权重如何随着时间推进而调整。（反向传播算法）
- 神经网络API模块
  - 在使用tensorflow时候，tf.nn,tf.layers,tf.contrib模块有很多功能是重复的。
  - 1，tf.nn：提供神经网络相关操作的支持，包括卷积操作（conv）、池化操作（pooling）、归一化、loss、分类操作、embedding、RNN、Evaluation。
  - 2，tf.layers：主要提供的高层的神经网络，主要和卷积相关的，对tf.nn的进一步封装。
  - tf.contrib：tf.contrib.layers提供能够将计算图中的网络层、正则化、摘要操作、是构建计算图的高级操作，但是tf.contrib包不稳定以及一些实验代码。
- 浅层人工神经网络模型
  - SoftMax回归函数
    -
  - 交叉熵损失函数
  - 1，全连接-从输入直接到输出
  - 特征加权
    - tf.matmul(a,b,name=None) + bias
      - return:全连接结果，供交叉损失运算
      - 不需要激活函数（因为是最后的输出）
  - 2，SoftMax计算、交叉熵
    - tf.nn.softmax_cross_entropy_with_logits(labels=None,logits=None,name=None)----计算logits和labels之间的交叉损失熵
    - labels:标签值（真实值）
    - logits：样本加权之后的值
    - return：返回损失值列表
  - 3，损失值列表平均值计算
    - tf.reduce_mean(input_tensor)
    - 计算张量的尺寸的元素平均值
  - 4，其它方法–损失下降API
    - tf.train.GradientDescentOptimizer(learning_rate)—梯度下降优化
    - learning_rate:学习率，一般为
    - minimize(loss):最小化损失
    - return：梯度下降op
  - 5，获取数据
    - from tensorflow.examples.tutorials.mnist import input_data
    - mnist = input_data.read_data_sets(FLAGS.data_dir,one_hot=True)
  - 6，准确性计算
    - equal_list = tf.equal(tf.argmax(y,1),tf.argmax(y_label,1))
    - accuracy = tf.reduce_mean(tf.cast(equal_list,tf.float32))
  - Mnist数据集神经网络实现流程
    - 1，准备数据
    - 2，全连接结果计算
    - 3，损失优化
    - 4，模型评估（计算准确性）

二、卷积神经网络（CNN）

神经网络（neural networks）的基本组成包括输入层、隐藏层、输出层。二卷积神经网络的特点在于隐藏层分为卷积层和池化层（pooling layer，又叫下采样层）
- 卷积层：通过在原始图像上平移来提取特征
- 池化层：通过特征后稀疏参数来减少学习的参数，降低网络的复杂度，（最大池化和平均池化）
卷积神经网络的结构
- 1，卷积层过滤器
  - 个数
  - 大小（11，33，5*5）
  - 步长
  - 零填充
  - 卷积层输出深度、输出宽度
    - 深度由过滤器个数决定
    - 输出宽度
- 2，激活函数
- 3，池化层
- 4，全连接层
注：在大型网络当中会有一个droupout（减少过拟合）
- 卷积层过滤器的参数
  - 输入体积大小H1W1D1
  - 四个超参数：
    - Filter数量K
    - Filter大小F
    - 步长S
    - 零填充大小P
  - 输出体积大小H2W2D2
    - H2 = （H1-F+2P）/ S + 1
    - W2 = （W1-F+2P）/ S + 1
    - D2 = K
- 卷积层的零填充
  - 卷积核在提取特征映射时的动作称之为padding（零填充），由于移动步长不一定能整出整张图的像素宽度。其中有两种方式，SAME和VALID
    - 1，SAME：越过边缘取样，取样的面积和输入图像的像素宽度一致。
    - 2，VALID：不越过边缘取样，取样的面积小于输入人的图像的像素宽度
- 卷积网络API介绍
- 卷积层：
  - tf.nn.conv2d(input,filter,strides=,padding=,name=None)
  - 计算给定4-D input和filter张量的2维卷积
    - input：给定的输入张量，具有[batch,height,width,channel],类型为float32，64
    - filter：指定过滤器的大小，[filter_height,filter_width,in_channels,out_channels]
    - strides：strides = [1,stride,stride,1],步长
    - padding：“SAME”,“VALID”,使用的填充算法的类型，使用"SAME".其中"VALID"表示滑动超出部分舍弃，"SAME"表示填充，使得变化后height，width一样大。
- 激活函数：
- tf.nn.relu(features,name=None)
  - features:卷积后加上偏置的结果
  - return:结果
- 池化层（pooling）计算
  - Pooling层主要的作用是特征提取，通过去掉Feature Map中不重要的样本，进一步减少参数数量。Pooling的方法很多，最常用的是Max
  - Pooling。2*2，步长2
- 池化API：
- tf.nn.max_pool(value,ksize=,strides=,padding=,name=None)—输入上执行最大池数
  - value：4-D Tensor形状[batch,height,width,channels]
  - ksize：池化窗口大小，[1,ksize,ksize,1]
  - strides：步长大小，[1,strides,strides,1]
  - padding：“SAME”,“VALID”,使用的填充算法的类型，使用"SAME"
- Full Connected层
  - 分析：前面的卷积和池化相当于做特征工程，后面的全连接相当于做特征加权。最后的全连接层在整个卷积神经网络中起到“分类器”的作用。
- 卷积网络分析

三、分布式TensorFlow

分布式API
- 1，创建一个tf.train.ClusterSpec,用于对集群中的所有任务进行描述，该描述内容对所有任务应该是相同的。
- 2，创建一个tf.train.Server,用于创建一个任务(ps,worker)，并运行相应作业上的计算任务。
1，创建集群
- cluster = tf.train.CluterSpec({“ps”:ps_spec,“worker”:worker_spec})
- cluster = tf.train.ClusterSpec({“worker”:[“worker0.example.com:2222”,“worker1.example.com:2222”,“worker2.example.com:2222”],“ps”:[“ps0.example.com:2222”,“ps1.example.com:2222”]})
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:集群描述对象
- 注：使用with tf.device(),使不同工作节点工作在不同的设备上
4，分布式会话API
- tf.train.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
5，常用钩子
- 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()

code_1


import tensorflow as tf
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
from tensorflow.examples.tutorials.mnist import input_data

def full_connected():

    # 获取真实的数据
    mnist = input_data.read_data_sets("./data/mnist/input_data/",one_hot=True)

    # 1,建立数据的占位符  x [None,784]  y_true [None,10]
    with tf.variable_scope("data"):
        x = tf.placeholder(tf.float32,[None,784])

        y_true = tf.placeholder(tf.int32,[None,10])

    # 2，建立一个全连接层的神经网络 w [784,10]  b [10]
    with tf.variable_scope("fc_model"):
        # 随机初始化权重和偏置
        weight = tf.Variable(tf.random_normal([784,10],mean=0.0,stddev=1.0),name="w")

        bias = tf.Variable(tf.constant(0.0,shape=[10]))

        # 预测None个样本的输出结果matrix[None,784]*[784,10] + [10] = [None,10]
        y_predict = tf.matmul(x,weight) + bias

    # 3,求出所有样本的损失，然后求平均值
    with tf.variable_scope("soft_cross"):
        #  计算交叉熵损失API
        #  求平均交叉熵损失
        loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_true,logits=y_predict))

    # 4，梯度下降求出损失
    with tf.variable_scope("optimizer"):

        train_op = tf.train.GradientDescentOptimizer(0.1).minimize(loss)

    # 5,计算准确率
    with tf.variable_scope("acc"):

        equal_list = tf.equal(tf.argmax(y_true,1),tf.argmax(y_predict,1))

        accuracy = tf.reduce_mean(tf.cast(equal_list,tf.float32))

    # 收集变量，单个数字值收集
    tf.summary.scalar("losses",loss)
    tf.summary.scalar("acc",accuracy)

    # 高纬度变量收集
    tf.summary.histogram("weightes",weight)
    tf.summary.histogram("biases",bias)

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

    # 定义一个合并变量的op
    merged = tf.summary.merge_all()

    # 6,开启会话去训练
    with tf.Session() as sess:
        # 初始化变量
        sess.run(init_op)

        # 建立events文件，然后写入
        filewriter = tf.summary.FileWriter("./tmp/summary/test/",graph=sess.graph)

        # 迭代步数去训练，更新参数预测
        for i in range(5000):

            # 取出真实存在的特征值和目标值
            mnist_x,mnist_y = mnist.train.next_batch(100)

            # 运行train_op训练
            sess.run(train_op,feed_dict={x:mnist_x,y_true:mnist_y})

            # 写入每步训练的值
            summary = sess.run(merged,feed_dict={x:mnist_x,y_true:mnist_y})

            filewriter.add_summary(summary,i)

            print("训练第%d步，准确率为%f" % (i,sess.run(accuracy,feed_dict={x:mnist_x,y_true:mnist_y})))


    return None


if __name__ == '__main__':
    full_connected()

code_2

import tensorflow as tf
import os

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
from tensorflow.examples.tutorials.mnist import input_data

FLAGS = tf.app.flags.FLAGS
tf.app.flags.DEFINE_integer("is_train", 1, "指定程序是预测还是训练")


def full_connected():
    # 获取真实的数据
    mnist = input_data.read_data_sets("./data/mnist/input_data/", one_hot=True)

    # 1,建立数据的占位符  x [None,784]  y_true [None,10]
    with tf.variable_scope("data"):
        x = tf.placeholder(tf.float32, [None, 784])

        y_true = tf.placeholder(tf.int32, [None, 10])

    # 2，建立一个全连接层的神经网络 w [784,10]  b [10]
    with tf.variable_scope("fc_model"):
        # 随机初始化权重和偏置
        weight = tf.Variable(tf.random_normal([784, 10], mean=0.0, stddev=1.0), name="w")

        bias = tf.Variable(tf.constant(0.0, shape=[10]))

        # 预测None个样本的输出结果matrix[None,784]*[784,10] + [10] = [None,10]
        y_predict = tf.matmul(x, weight) + bias

    # 3,求出所有样本的损失，然后求平均值
    with tf.variable_scope("soft_cross"):
        #  计算交叉熵损失API
        #  求平均交叉熵损失
        loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_true, logits=y_predict))

    # 4，梯度下降求出损失
    with tf.variable_scope("optimizer"):

        train_op = tf.train.GradientDescentOptimizer(0.1).minimize(loss)

    # 5,计算准确率
    with tf.variable_scope("acc"):

        equal_list = tf.equal(tf.argmax(y_true, 1), tf.argmax(y_predict, 1))

        accuracy = tf.reduce_mean(tf.cast(equal_list, tf.float32))

    # 收集变量，单个数字值收集
    tf.summary.scalar("losses", loss)
    tf.summary.scalar("acc", accuracy)

    # 高纬度变量收集
    tf.summary.histogram("weightes", weight)
    tf.summary.histogram("biases", bias)

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

    # 定义一个合并变量的op
    merged = tf.summary.merge_all()

    # 创建一个saver
    saver = tf.train.Saver()

    # 6,开启会话去训练
    with tf.Session() as sess:
        # 初始化变量
        sess.run(init_op)

        # 建立events文件，然后写入
        filewriter = tf.summary.FileWriter("./tmp/summary/test/", graph=sess.graph)

        if FLAGS.is_train == 1:
            # 迭代步数去训练，更新参数预测
            for i in range(5000):
                # 取出真实存在的特征值和目标值
                mnist_x, mnist_y = mnist.train.next_batch(100)

                # 运行train_op训练
                sess.run(train_op, feed_dict={x: mnist_x, y_true: mnist_y})

                # 写入每步训练的值
                summary = sess.run(merged, feed_dict={x: mnist_x, y_true: mnist_y})

                filewriter.add_summary(summary, i)

                print("训练第%d步，准确率为%f" % (i, sess.run(accuracy, feed_dict={x: mnist_x, y_true: mnist_y})))

            # 保存模型
            saver.save(sess, "./tmp/ckpt/fc_model")
        else:
            # 加载模型
            saver.restore(sess, "./tmp/ckpt/fc_model")

            # 如果是0，做出预测
            for i in range(100):
                # 每次测试一张图片
                x_test, y_test = mnist.test.next_batch(1)

                print("第%d张图片，手写数字目标是：%d，预测结果是：%d" % (
                    i,
                    tf.argmax(y_test, 1).eval(),
                    tf.argmax(sess.run(y_predict, feed_dict={x: x_test, y_true: y_test}), 1).eval()
                ))

    return None


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


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


def model():
    """
    自定义的卷积模型
    :return:
    """
    # 1，准备数据的占位符 x [None,784] y_true [None,10]
    with tf.variable_scope("data"):
        x = tf.placeholder(tf.float32, [None, 784])

        y_true = tf.placeholder(tf.int32, [None, 10])

    # 2,一卷积层,卷积：5*5*1，32个，strides=1、激活:tf.nn.relu、池化
    with tf.variable_scope("conv1"):
        # 定义初始化权重,偏置[32]
        w_conv1 = weight_variables([5, 5, 1, 32])

        b_conv1 = bias_variables([32])
        # 对x进行形状的改变[None,784]---->[None,28,28,1]
        x_reshape = tf.reshape(x, [-1, 28, 28, 1])

        # [None,28,28,1]----->[None,28,28,32]
        x_relu1 = tf.nn.relu(tf.nn.conv2d(x_reshape, w_conv1, strides=[1, 1, 1, 1], padding="SAME") + b_conv1)

        # 池化 2*2，strides：2，[None,28,28,32]------>[None,14,14,32]
        x_pool1 = tf.nn.max_pool(x_relu1, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding="SAME")

    # 3，二卷积层,卷积：5*5*32，64个filter，strides=1、激活:tf.nn.relu、池化
    with tf.variable_scope("conv2"):
        # 定义初始化权重,权重：[5,5,32,64],偏置[64]
        w_conv2 = weight_variables([5, 5, 32, 64])

        b_conv2 = bias_variables([64])

        # 卷积，激活，池化计算
        # [None,14,14,32]------>[None,14,14,64]
        x_relu2 = tf.nn.relu(tf.nn.conv2d(x_pool1, w_conv2, strides=[1, 1, 1, 1], padding="SAME") + b_conv2)

        # 池化 2*2，strides 2，[None,14,14,64]------>[None,7,7,64]
        x_pool2 = tf.nn.max_pool(x_relu2, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding="SAME")

    # 4，全连接层 [None,7,7,64]----->[None,7*7*64]*[7*7*64,10] + [10] = [None,10]
    with tf.variable_scope("conv2"):
        # 随机初始化权重和偏置
        w_fc = weight_variables([7 * 7 * 64, 10])

        b_fc = bias_variables([10])

        # 修改形状[None,7,7,64]------>[None,7*7*64]
        x_fc_reshape = tf.reshape(x_pool2, [-1, 7 * 7 * 64])

        # 进行矩阵运算得出每个样本的10个结果
        y_predict = tf.matmul(x_fc_reshape, w_fc) + b_fc

    return x, y_true, y_predict


def conv_fc():
    # 获取真实的数据
    mnist = input_data.read_data_sets("./data/mnist/input_data/", one_hot=True)

    # 定义模型，得出输出
    x, y_true, y_predict = model()

    # 进行交叉熵损失计算
    # 3,求出所有样本的损失，然后求平均值
    with tf.variable_scope("soft_cross"):
        #  计算交叉熵损失API
        #  求平均交叉熵损失
        loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_true, logits=y_predict))

    # 4，梯度下降求出损失
    with tf.variable_scope("optimizer"):
        train_op = tf.train.GradientDescentOptimizer(0.0001).minimize(loss)

    # 5,计算准确率
    with tf.variable_scope("acc"):
        equal_list = tf.equal(tf.argmax(y_true, 1), tf.argmax(y_predict, 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)

        # 循环去训练
        for i in range(1000):
            # 取出真实存在的特征值和目标值
            mnist_x, mnist_y = mnist.train.next_batch(50)

            # 运行train_op训练
            sess.run(train_op, feed_dict={x: mnist_x, y_true: mnist_y})

            print("训练第%d步，准确率为%f" % (i, sess.run(accuracy, feed_dict={x: mnist_x, y_true: mnist_y})))

    return None


if __name__ == '__main__':
    # full_connected()
    conv_fc()

验证码识别

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_variables(shape):
    w = tf.Variable(tf.random_normal(shape=shape, mean=0.0, stddev=1.0))
    return w


# 定义一个初始化偏置的函数
def bias_variables(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)
    # 1、先解析图片的目标值
    label = tf.decode_raw(features["label"], tf.uint8)

    # print(image, label)

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

    label_reshape = tf.reshape(label, [4])

    print(image_reshape, label_reshape)

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

    print(image_batch, label_btach)
    return image_batch, label_btach


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_variables([20 * 80 * 3, 4 * 26])
        bias = bias_variables([4 * 26])

        # 进行全连接层计算[100, 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]
    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()

以上所需数据请前往https://github.com/MapleStoryBoy/spider/tree/master/deeplearn

南方的树～

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Netrual Network

神经网络一、神经网络基础感知机在n个输入数据，通过权重与各数据之间的计算和，比较激活函数结果，得出输出应用：很容易解决与、或问题与或问题：于：所有的输入为1，输出为1.或：只要有一个为1，输出就为1.异或：相同为0，不同为1.感知机解决分类问题，下图为简单的感知机模型单个感知机解决不了的问题，可以增加Rosenblatt在1957年，于Cornell...
复制链接

扫一扫