Tensorflow 学习笔记本———代码实践

基于tensorflow的不同网络的搭建与实现

自编码网络TensorFlow实现

# _*_coding:utf-8_*_
'''
TensorFlow的自编码网络实现(无监督学习)
'''
import tensorflow as tf
import matplotlib.pyplot as plt
import numpy as np
import tensorflow.examples.tutorials.mnist.input_data as input_data
mnist = input_data.read_data_sets("MNIST_data/",one_hot=True)
trX, trY = mnist.train.images, mnist.train.labels
teX, teY = mnist.test.images, mnist.test.labels
# _*_coding:utf-8_*_

# 设置训练超参数
learning_rate = 0.01  # 学习率
training_epochs = 20  # 训练的轮数
batch_size = 256  # 每次训练的数据多少
display_step = 1  # 每隔多少轮显示一次训练结果

# 下面参数表示从测试集中选择10张图片去验证自编码器的结果
examples_to_show = 10

# 下面初始化权重和定义网络结构，我们设计这个自动编码网络含有两个隐含层
# 第一个隐含层神经元为256个，第二个隐藏层神经元为128个
# 定义网络参数如下：
n_hidden_1 = 256  # 第一个隐藏层神经元个数，也是特征值个数
n_hidden_2 = 128  # 第二个隐藏层神经元个数，也是特征值个数
n_input = 784  # 输入数据的特征值个数，28*28=784

# 定义输入数据，这里是无监督学习，所以只需要输入图片数据，不需要标记数据
X = tf.placeholder('float', [None, n_input])

# 初始化每一层的权重和偏置，如下：
weights = {
     
    'encoder_h1': tf.Variable(tf.random_normal([n_input, n_hidden_1])),
    'encoder_h2': tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2])),
    'decoder_h1': tf.Variable(tf.random_normal([n_hidden_2, n_hidden_1])),
    'decoder_h2': tf.Variable(tf.random_normal([n_hidden_1, n_input])),
}
biases = {
     
    'encoder_b1': tf.Variable(tf.random_normal([n_hidden_1])),
    'encoder_b2': tf.Variable(tf.random_normal([n_hidden_2])),
    'decoder_b1': tf.Variable(tf.random_normal([n_hidden_1])),
    'decoder_b2': tf.Variable(tf.random_normal([n_input])),
}


# 定义自动编码模型的网络结构，包括压缩和解压两个过程
# 定义压缩函数
def encoder(x):
    # encoder hidden layer with sigmoid activation #1
    layer_1 = tf.nn.sigmoid(tf.add(tf.matmul(x, weights['encoder_h1']),
                                   biases['encoder_b1']))
    # decoder hidden layer with sigmoid activation #2
    layer_2 = tf.nn.sigmoid(tf.add(tf.matmul(layer_1, weights['encoder_h2']),
                                   biases['encoder_b2']))
    return layer_2


# 定义解压函数
def decoder(x):
    # encoder hidden layer with sigmoid activation #1
    layer_1 = tf.nn.sigmoid(tf.add(tf.matmul(x, weights['decoder_h1']),
                                   biases['decoder_b1']))
    # decoder hidden layer with sigmoid activation #2
    layer_2 = tf.nn.sigmoid(tf.add(tf.matmul(layer_1, weights['decoder_h2']),
                                   biases['decoder_b2']))
    return layer_2

# 构建模型
encoder_op = encoder(X)
decoder_op = decoder(encoder_op)

# 下面构建损失函数和优化器
# 这里损失函数采用“最小二乘法” 对原始数据集合输出的数据集进行平方差并取均值运算
# 优化器采用RMSPropOptimizer
y_pred = decoder_op  # 得出预测值
y_true = X  # 得出真实值，即输入值

# 定义损失函数和优化器
cost = tf.reduce_mean(tf.pow(y_true - y_pred, 2))
optimizer = tf.train.RMSPropOptimizer(learning_rate).minimize(cost)

# 在一个会话中启动图，开始训练和评估
with tf.Session() as sess:
    tf.global_variables_initializer().run()
    total_batch = int(mnist.train.num_examples / batch_size)
    # 开始训练
    for epoch in range(training_epochs):
        for i in range(200):
            batch_xs, batch_ys = mnist.train.next_batch(batch_size)
            # run optimization op(backprop) and cost op(to get loss value)
            _, c = sess.run([optimizer, cost], feed_dict={
     X: batch_xs})
        # 每一轮，打印出一次损失值
        if epoch % display_step == 0:
            print("Epoch: ", "%04d" % (epoch + 1), "cost=", "{:.9f}".format(c))
    print("Optimization Finished!")

    # 对测试集应用训练好的自动编码网络
    encode_decode = sess.run(y_pred, feed_dict={
     X: mnist.test.images[:examples_to_show]})
    # 比较测试集原始图片和自动编码网络的重建结果
    f, a = plt.subplots(2, 10, figsize=(10, 2))
    for i in range(examples_to_show):
        a[0][i].imshow(np.reshape(mnist.test.images[i], (28, 28)))  # 测试集
        a[1][i].imshow(np.reshape(encode_decode[i], (28, 28)))  # 重建结果
    f.show()
    plt.draw()
    plt.waitforbuttonpress()

最浅神经网络tensorflow实现

# _*_coding:utf-8_*_
"""
这个demo 可以算作是一个没有隐含层的最浅的神经网络tensorflow实现
"""
import tensorflow as tf
import numpy as np
import tensorflow.examples.tutorials.mnist.input_data as input_data
#从指定路径读取数据集
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

#创建一个新的InteractiveSession ，使用这个命令会将这个session注册为默认的session，之后的运算也默认跑在这个session里，不同session之间的数据和运算应该都是相互独立的
sess = tf.InteractiveSession()
#创建一个 placeholder，即输入数据的地方
x = tf.placeholder(tf.float32, [None, 784])
#给Softmax Regression模型中的 weights和 biases 创建  Variable 对象，Variable是用来存储模型参数的，不同于存储数据的 tensor 一旦使用掉就会消失，Variable 在模型训练迭代中是持久的，它可以长期存在并且在每轮迭代中被更新。
W = tf.Variable(tf.zeros([784, 10]))
b = tf.Variable(tf.zeros([10]))
#实现 Softmax Regression 算法
y = tf.nn.softmax(tf.matmul(x, W) + b)
#为了计算交叉熵，我们首先需要添加一个新的占位符用于输入正确值
y_ = tf.placeholder(tf.float32, [None, 10])
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y),
                                              reduction_indices=[1]))
#选择的优化算法来不断地修改变量以降低成本
train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)

tf.global_variables_initializer().run()
#开始训练模型，让模型训练训练1000次
for i in range(1000):
    batch_xs, batch_ys = mnist.train.next_batch(100)
    train_step.run({
     x: batch_xs, y_:batch_ys})
#用 tf.equal 来检测我们的预测是否与真实标签匹配，返回的是一个布尔数组correct_prediction
correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))
#用cast将布尔值转换为浮点数来代表对，错，然后取平均值，即分类的准确率
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
#计算模型在测试集上的分类的准确率。
print(accuracy.eval(feed_dict={
     x: mnist.test.images, y_: mnist.test.labels}))

tensorflow实现传统神经网络

# _*_coding:utf-8_*_
"""
tensorflow实现传统的神经网络
"""
import tensorflow as tf
import tensorflow.examples.tutorials.mnist.input_data as input_data

BATCH_SIZE = 100  # 训练批次
INPUT_NODE = 784  # 784=28*28 输入节点
OUTPUT_NODE = 10  # 输出节点
LAYER1_NODE = 784  # 层级节点
TRAIN_STEP = 10000  # 训练步数
LEARNING_RATE = 0.01 #学习率
L2NORM_RATE = 0.001


def train(mnist):
    # define input placeholder
    # None表示此张量的第一个维度可以是任何长度的
    input_x = tf.placeholder(tf.float32, [None, INPUT_NODE], name='input_x')
    input_y = tf.placeholder(tf.float32, [None, OUTPUT_NODE], name='input_y')

    # define weights and biases
    w1 = tf.Variable(tf.truncated_normal(shape=[INPUT_NODE, LAYER1_NODE], stddev=0.1))
    b1 = tf.Variable(tf.constant(0.1, shape=[LAYER1_NODE]))

    w2 = tf.Variable(tf.truncated_normal(shape=[LAYER1_NODE, OUTPUT_NODE], stddev=0.1))
    b2 = tf.Variable(tf.constant(0.1, shape=[OUTPUT_NODE]))

    layer1 = tf.nn.relu(tf.nn.xw_plus_b(input_x, w1, b1))
    y_hat = tf.nn.xw_plus_b(layer1, w2, b2)
    print("1 step ok!")

    # define loss
    cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits=y_hat, labels=input_y)
    cross_entropy_mean = tf.reduce_mean(cross_entropy)
    regularization = tf.nn.l2_loss(w1) + tf.nn.l2_loss(w2) + tf.nn.l2_loss(b1) + tf.nn.l2_loss(b2)
    loss = cross_entropy_mean + L2NORM_RATE * regularization
    print("2 step ok")

    # define accuracy
    correct_predictions = tf.equal(tf.argmax(y_hat, 1), tf.argmax(input_y, 1))
    accuracy = tf.reduce_mean(tf.cast(correct_predictions, tf.float32))
    print("3 step ok")

    # train operation
    global_step = tf.Variable(0, trainable=False)
    train_op = tf.train.AdamOptimizer(LEARNING_RATE).minimize(loss, global_step=global_step)
    print("4 step ok ")

    with tf.Session() as sess:
        tf.global_variables_initializer().run()  # 初始化创建的变量
        print("5 step OK")

        # 开始训练模型
        for i in range(TRAIN_STEP):
            xs, ys = mnist.train.next_batch(BATCH_SIZE)
            feed_dict = {
     
                input_x: xs,
                input_y: ys,
            }
            _, step, train_loss, train_acc = sess.run([train_op, global_step, loss, accuracy], feed_dict=feed_dict)
            if (i % 100 == 0):
                print("After %d steps, in train data, loss is %g, accuracy is %g." % (step, train_loss, train_acc))

        test_feed = {
     input_x: mnist.test.images, input_y: mnist.test.labels}
        test_acc = sess.run(accuracy, feed_dict=test_feed)
        print("After %d steps, in test data, accuracy is %g." % (TRAIN_STEP, test_acc))

if __name__ == '__main__':
    # 从指定路径读取数据集
    mnist = input_data.read_data_sets(
        "MNIST_data/",
        one_hot=True)
    print("0 step ok!")
    train(mnist)

TensorFlow实现训练神经网络

# _*_coding:utf-8_*_
'''
TensorFlow实现训练神经网络（监督学习）
'''
import tensorflow as tf
import matplotlib.pyplot as plt
import numpy as np
import tensorflow.examples.tutorials.mnist.input_data as input_data

# MNIST 数据集相关的常数
# 输入层的节点数，对于MNIST数据集，这个就等于图片的像素
INPUT_NODE = 784
# 输出层的节点数，这个等于类别的数目，因为在MNIST数据集中需要区分的
# 是0-9这个10个数字，所以这里输出层的节点数为10
OUTPUT_NODE = 10

# 配置神经网络的参数
# 隐藏层节点数，这里使用只有一个隐藏层的网络结构作为样例
# 这个隐藏层有500个节点
LAYER1_NODE = 500
# 一个训练batch中的训练数据个数，数字越小时，训练过程越接近随机梯度下降
# 数字越大时，训练越接近梯度下降
BATCH_SIZE = 100

# 基础的学习率
LEARNING_RATE_BASE = 0.8
# 学习率的衰减率
LEARNING_RATE_DECAT = 0.99
# 描述模型复杂度的正则化项在损失函数中的系数
REGULARIZATION_RATE = 0.0001
# 训练轮数
TRAINING_STEPS = 30000
# 滑动平均衰减率
MOVING_AVERAGE_DECAY = 0.99

# 一个辅助函数，给定神经网络的输入和所有参数，计算神经网络的前向传播结果
# 在这里定义了一个使用ReLU激活函数的三层全连接神经网络
# 通过加入隐藏层实现了多层网络结构，通过ReLU激活函数实现了去线性化
# 在这个函数中也支持传入用于计算参数平均值的类，这样方便在测试时使用滑动平均模型
def inference(input_tensor, avg_class, weights1, biases1, weights2, biases2):
    # 当没有提供滑动平均类时，直接使用参数当前的取值
    if avg_class == None:
        # 计算隐藏层的前向传播结果，这里使用了ReLU激活函数
        layer1 = tf.nn.relu(tf.matmul(input_tensor, weights1) + biases1)

        # 计算输出层的前向传播结果，因为在计算损失函数时会一并计算softmax函数
        # 所以这里不需要加入激活函数，而且不加入softmax不会影响预测结果
        # 因为预测时使用的是不同类型对应节点输出值的相对大小，
        # 有没有softmax层对最后分类的结果没有影响
        # 于是在计算整个神经网络的前向传播时可以不加入最后的softmax层
        return tf.matmul(layer1, weights2) + biases2
    else:
        # 首先使用avg_class.average 函数来计算得出变量的滑动平均值
        # 然后再计算相应的神经网络前向传播结果
        layer1 = tf.nn.relu(
            tf.matmul(input_tensor, avg_class.average(weights1)) +
            avg_class.average(biases1)
        )
        return tf.matmul(layer1, avg_class.average(weights2)) + avg_class.average(biases2)


# 训练模型的过程
def train(mnist):
    x = tf.placeholder(tf.float32, [None, INPUT_NODE], name='x-input')
    y_ = tf.placeholder(tf.float32, [None, OUTPUT_NODE], name='y-input')

    # 生成隐藏层的参数
    weights1 = tf.Variable(
        tf.truncated_normal([INPUT_NODE, LAYER1_NODE], stddev=0.1))
    biases1 = tf.Variable(tf.constant(0.1, shape=[LAYER1_NODE]))

    # 生成输出层的参数
    weights2 = tf.Variable(
        tf.truncated_normal([LAYER1_NODE, OUTPUT_NODE], stddev=0.1))
    biases2 = tf.Variable(tf.constant(0.1, shape=[OUTPUT_NODE]))

    # 计算在当前参数下神经网络前向传播的结果。这里给出的用于计算滑动平均的类为None
    # 所以函数不会使用参数的滑动平均值
    y = inference(x, None, weights1, biases1, weights2, biases2)

    # 定义存储训练轮数的变量，这个变量不需要计算滑动平均值
    # 这里指定这个变量为不可训练的变量（trainable=False）
    # 在使用TensorFlow训练神经网络时，一般会将代表训练轮数的变量指定为不可训练的参数
    global_step = tf.Variable(0, trainable=False)

    # 给定滑动平均衰减率和训练轮数的变量，初始化滑动平均类。
    # 当给定训练轮数的变量可以加快训练早期变量的更新速度
    varibale_averages = tf.train.ExponentialMovingAverage(
        MOVING_AVERAGE_DECAY, global_step
    )

    # 在所有代表神经网络参数的变量上使用滑动平均。
    # 其他辅助变量（比如global_step)就不需要了
    # tf.trainable_variables 返回的就是图上集合GraphKeys.TRAINABLE_VARIABLES中的元素
    # 这个集合的元素就是所有没有指定trainable=False 的参数
    varibale_averages_op = varibale_averages.apply(tf.trainable_variables())

    # 计算使用了滑动平均之后的前向传播结果。因为滑动平均不会改变变量本身的额取值
    # 而是会委会一个影子变量来记录其滑动平均值，所以当需要使用这个滑动平均值时，需要明确调用average函数
    average_y = inference(x, varibale_averages, weights1, biases1, weights2, biases2)

    # 计算交叉熵作为刻画预测值和真实值之间差距的损失函数，这里使用了TensorFlow中提供的
    # sparse_softmax_cross_entropy_with_logits函数来计算交叉熵
    # 当分类问题中只有一个正确答案时，可以使用这个函数来加速交叉熵的计算
    # MNIST问题的图片中只包含了一个0-9中的一个数字，所以可以使用这个函数来计算交叉熵损失
    # 这个函数的第一个参数是神经网络不包含softmax层的前向传播结果，第二个是训练数据的正确答案
    # 因为标准答案是一个长度为10的一位数组，而该函数需要提供了一个正确的答案数字
    # 所以需要使用 tf.argmax函数来得到正确答案对应的类别编号
    cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_, 1))
    # 计算在当前batch中所有样例的交叉熵平均值
    cross_entropy_mean = tf.reduce_mean(cross_entropy)

    # 计算L2正则化损失函数
    regularizer = tf.contrib.layers.l2_regularizer(REGULARIZATION_RATE)
    # 计算模型的正则化损失，一般只计算神经网络边上权重的正则化损失，而不使用偏置项
    regularization = regularizer(weights1) + regularizer(weights2)
    # 总损失等于交叉熵损失和正则化损失的和
    loss = cross_entropy_mean + regularization
    # 设置指数衰减的学习率
    learning_rate = tf.train.exponential_decay(
        LEARNING_RATE_BASE,  # 基础的学习率，随着迭代的进行，更新变量时使用的
        # 学习率在这个基础上递减
        global_step,  # 学习率在这个基础上递减
        mnist.train.num_examples / BATCH_SIZE,  # 过完所有的训练数据需要的迭代次数
        LEARNING_RATE_DECAT,  # 学习率衰减速度
        staircase=True
    )
    # 使用tf.train.GradientDescentOptimizer优化算法来优化损失函数
    # 注意这里损失函数包含了交叉熵损失和L2正则化损失
    train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_step)

    # 在训练神经网络模型时，没过一遍数据即需要通过反向传播来更新神经网络中的参数
    # 又要更新每一个参数的滑动平均值，为了一次完成多个操作，西面两行程序和下面代码是等价的
    # train_op = tf.group(train_step, varibale_averages_op)
    with tf.control_dependencies([train_step, varibale_averages_op]):
        train_op = tf.no_op(name='train')

    # 检验使用了滑动平均模型的神经网络前向传播结果是否正确。tf.argmax(average_y, 1)
    # 计算每一个样例的预测答案，其中average_y 是一个 batch_size*10的二维数组，
    # 每一行表示一个样例的前向传播结果。tf.argmax的第二个参数“1”表示选取最大值的的操作
    # 仅在第一个维度中进行，也即是说，只有每一行选取最大值对应的下标
    # 于是得到的结果是一个长度为batch的一维数组，这个一维数组中的值就表示了
    # 每一个样例对应的数字识别结果
    # tf.rqual 判断两个张量的每一维是否相等，如果相等返回True，否则返回False。
    correct_prediction = tf.equal(tf.argmax(average_y, 1), tf.argmax(y_, 1))
    # 这个运算首选将一个布尔型的数值转换为实数型，然后计算平均值，这个平均值
    # 就是模型在这一组数据上的正确率
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

    # 初始化会话并开始训练过程
    with tf.Session() as sess:
        tf.global_variables_initializer().run()
        # 准备验证数据，一般在神经网络的训练过程中会通过验证数据来判断
        # 大致判断停止的条件和评判训练的效果
        validate_feed = {
     x: mnist.validation.images,
                         y_: mnist.validation.labels}
        # 准备测试数据，在真实的应用中，这部分数据在训练时是不可见的
        # 下面数据只是作为模型优劣的最后评价标准
        test_feed = {
     x: mnist.test.images, y_: mnist.test.labels}

        # 迭代地训练神经网络
        for i in range(TRAINING_STEPS):
            # 每1000轮输出一次在验证数据集上的测试结果
            if i % 1000 == 0:
                # 计算滑动平均模型在验证数据上的结果，因为MNIST数据集比较小，
                # 所以一次可以处理所有的验证数据
                # 当神经网络模型比较复杂或者验证数据比较大，太大的batch会导致计算时间过长
                # 甚至发生内存溢出的错误
                validate_acc = sess.run(accuracy, feed_dict=validate_feed)
                print('After %d training step(s), validation accuracy using average model is %g' % (i, validate_acc))
            # 产生这一轮使用的一个batch的训练数据，并运行训练过程
            xs, ys = mnist.train.next_batch(BATCH_SIZE)
            sess.run(train_op, feed_dict={
     x: xs, y_: ys})
        # 在训练结束后，在测试数据集上检测神经网络模型的最终正确率
        test_acc = sess.run(accuracy, feed_dict=test_feed)
        print('After %d training step(s), test accuracy using average model is %g' % (TRAINING_STEPS, test_acc))

# 主程序入口
def main(argv=None):
    # 声明处理MNIST数据集的类，这个类在初始化的时候会自动下载数据
    mnist = input_data.read_data_sets(
        "MNIST_data/",
        one_hot=True)
    train(mnist)

# Tensorflow 提供的一个主程序入口，tf.app.run会调用上面定义的main函数
if __name__ == '__main__':
    # tf.app.run(main=None)
    main()

tensorflow实现卷积神经网络

# _*_coding:utf-8_*_
"""
tensorflow实现 卷积神经网络-CNN训练
"""
import tensorflow as tf
import numpy as np
import tensorflow.examples.tutorials.mnist.input_data as input_data
#定义输入数据并预处理数据。读取数据MNIST，并分别得到训练集的图片和标记的矩阵，以及测试集的图片和标记的矩阵。
mnist = input_data.read_data_sets(
        "MNIST_data/",
        one_hot=True)

trX, trY = mnist.train.images, mnist.train.labels
teX, teY = mnist.test.images, mnist.test.labels
'''
trX.shape: (55000, 784)
trY.shape: (55000, 10)
teX.shape: (10000, 784)
teY.shape: (10000, 10)
'''
#标签0将表示成([1,0,0,0,0,0,0,0,0,0,0,...,59999])
#标签1将表示成([0,1,0,0,0,0,0,0,0,0,0,...,59999])
#标签2将表示成([0,0,1,0,0,0,0,0,0,0,0,...,59999])

#把上面 trX 和 teX 的形状变为 [-1, 28, 28, 1],  -1表示不考虑输入图片的数量，28*28表示图片的长和宽的像素数，1是通道（channel）数量，
# 因为MNIST的图片是黑白的，所以通道为1，如果是RGB彩色图像，则通道为3
trX = trX.reshape(-1, 28, 28, 1)  # 28*28*1  input image
teX = teX.reshape(-1, 28, 28, 1)  # 28*28*1  input image

X = tf.placeholder('float', [None, 28, 28, 1])
Y = tf.placeholder('float', [None, 10])
#初始化权重与定义网络结构。这里，我们将要构建一个拥有3个卷积和3个池化层，随后一个全连接层，再接一个输出层的卷积神经网络。
#首先定义初始化权重的函数：
def init_weights(shape):
    return tf.Variable(tf.random_normal(shape, stddev=0.01))
# 初始化权重方法如下，我们设置卷积核的大小为3*3
w = init_weights([3, 3, 1, 32])  # patch大小为3*3，输入维度为1，输出维度为32
w2 = init_weights([3, 3, 32, 64])  # patch大小为3*3，输入维度为32，输出维度为64
w3 = init_weights([3, 3, 64, 128])  # patch大小为3*3，输入维度为64，输出维度为128
# 全连接层，输入维度为128*4*4，是上一层的输出数据由三维的转变成一维，输出维度为625
w4 = init_weights([128 * 4 * 4, 625])
# 输出层，输入维度为625  输出维度为10， 代表10类
w_o = init_weights([625, 10])

#定义一个模型函数，代码如下：
# 神经网络模型的构建函数，传入以下参数
# X：输入数据
# w：每一层的权重
# p_keep_conv , p_keep_hidden, dropout 要保留的神经元比例

def model(X, w, w2, w3, w4, w_o, p_keep_conv, p_keep_hidden):
    # 第一组卷积层以及池化层，最后dropout一些神经元
    l1a = tf.nn.relu(tf.nn.conv2d(X, w, strides=[1, 1, 1, 1], padding='SAME'))
    # l1a  shape=(?, 28, 28, 32)
    l1 = tf.nn.max_pool(l1a, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
    # l1 shape=(?, 14, 14, 32)
    l1 = tf.nn.dropout(l1, p_keep_conv)

    # 第二组卷积层以及池化层，最后dropout一些神经元
    l2a = tf.nn.relu(tf.nn.conv2d(l1, w2, strides=[1, 1, 1, 1], padding='SAME'))
    # l2a  shape=(?, 14, 14, 64)
    l2 = tf.nn.max_pool(l2a, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
    # l2  shape=(?, 7, 7, 64)
    l2 = tf.nn.dropout(l2, p_keep_conv)

    # 第三组卷积层以及池化层，最后dropout一些神经元
    l3a = tf.nn.relu(tf.nn.conv2d(l2, w3, strides=[1, 1, 1, 1], padding='SAME'))
    # l3a  shape=(?, 7, 7, 128)
    l3 = tf.nn.max_pool(l3a, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
    # l3  shape=(?, 4, 4, 128)
    l3 = tf.reshape(l3, [-1, w4.get_shape().as_list()[0]])  # reshape to (?, 2048)
    l3 = tf.nn.dropout(l3, p_keep_conv)

    # 全连接层，最后dropout一些神经元
    l4 = tf.nn.relu(tf.matmul(l3, w4))
    l4 = tf.nn.dropout(l4, p_keep_hidden)

    # 输出层
    pyx = tf.matmul(l4, w_o)
    return pyx  # 返回预测值

p_keep_conv = tf.placeholder('float')
p_keep_hidden = tf.placeholder('float')
# 得到预测值
py_x = model(X, w, w2, w3, w4, w_o, p_keep_conv, p_keep_hidden)

#定义损失函数
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=py_x, labels=Y))
train_op = tf.train.RMSPropOptimizer(0.001, 0.9).minimize(cost)
predict_op = tf.argmax(py_x, 1)
#定义训练时的批次大小和评估时的批次大小
batch_size = 128
test_size = 256
# 在一个会话中启动图，开始训练和评估
# Launch the graph in a session
with tf.Session() as sess:
    # you need to initilaize all variables
    tf.global_variables_initializer().run()
    echo = 2
#ab=zip(a,b)
#ab=[(0, 0), (1, 2), (2, 4), (3, 6), (4, 8), (5, 10), (6, 12), (7, 14), (8, 16), (9, 18)]
    for i in range(echo):
        training_batch = zip(range(0, len(trX), batch_size),
                             range(batch_size, len(trX) + 1, batch_size))
        for start, end in training_batch:
            sess.run(train_op, feed_dict={
     
                X: trX[start:end], Y: trY[start:end],
                p_keep_conv: 0.8,
                p_keep_hidden: 0.5
            })
        print('第%d次测试,'%(i+1))
        print('测试精度为:',np.mean(np.argmax(teY[test_size*(i):test_size*(i+1)], axis=1) ==
                         sess.run(predict_op, feed_dict={
     X: teX[test_size*(i):test_size*(i+1)],p_keep_conv: 1.0, p_keep_hidden: 1.0})))

原理概述

自编码器

• 自编码器
  1. 介绍：自编码器可以模仿输入，并在输出处生成确切的信息。简而言之，自动编码器是旨在将其输入复制到其输出的神经网络。他们通过将输入压缩为一个潜在空间表示，然后从该表示重构输出来进行工作。
  2. 结构：两部分，编码器和解码器，编码器将输入转换为隐藏空间，解码器将输入信息重建为输出。
     编码器：这是网络中将输入压缩为潜在空间表示的部分。它可以由编码函数h = f（x）表示。
     解码器：这部分旨在从潜在空间表示中重建输入。它可以由解码函数r = g（h）表示。
• 类型：
  1. 不完整的自编码器：隐藏的尺寸小于输入的尺寸。优点是可捕获最突出的特征，即降维。缺点是需要大量数据，否则会过拟合。
  2. 正则化自编码器：不限制尺寸和隐藏层大小，有损失函数
     稀疏自编码器：允许表示信息瓶颈，无需减小隐藏层的大小。取而代之的是基于损失函数对层内的激活进行惩罚。
  3. 去噪自编码器：学习通用的encode和decode。它灵敏到能重新生成原始输入，但不过拟合。方法是将未损坏数据和特定噪声一起作为输入。
  4. 压缩自编码器：如果输入相似，那么该编码器的输出也相似。方法是强制重建特征抵抗特征的微小变化，而收缩式自编码器抵抗输入扰动。
  5. 变分自编码器：为每个隐藏特征生成一个概率分布。

卷积神经网络

• 综述
  卷积神经网络与普通神经网络的区别在于，卷积神经网络包含了一个由卷积层和子采样层构成的特征抽取器。卷积网络在本质上是一种输入到输出的映射，它能够学习大量的输入与输出之间的映射关系，而不需要任何输入和输出之间的精确的数学表达式，只要用已知的模式对卷积网络加以训练，网络就具有输入输出对之间的映射能力。卷积神经网络CNN主要用来识别位移、缩放及其他形式扭曲不变性的二维图形。由于CNN的特征检测层通过训练数据进行学习，所以在使用CNN时，避免了显式的特征抽取，而隐式地从训练数据中进行学习；再者由于同一特征映射面上的神经元权值相同，所以网络可以并行学习，这也是卷积网络相对于神经元彼此相连网络的一大优势。卷积神经网络以其局部权值共享的特殊结构在语音识别和图像处理方面有着独特的优越性，其布局更接近于实际的生物神经网络，权值共享降低了网络的复杂性，特别是多维输入向量的图像可以直接输入网络这一特点避免了特征提取和分类过程中数据重建的复杂度。
• 卷积层
  在卷积神经网络的卷积层中，一个神经元只与部分邻层神经元连接。在CNN的一个卷积层中，通常包含若干个特征平面(featureMap)，每个特征平面由一些矩形排列的的神经元组成，同一特征平面的神经元共享权值，这里共享的权值就是卷积核。卷积核一般以随机小数矩阵的形式初始化，在网络的训练过程中卷积核将学习得到合理的权值。共享权值（卷积核）带来的直接好处是减少网络各层之间的连接，同时又降低了过拟合的风险。
• 池化层（pooling）
  子采样也叫做池化，通常有均值子采样（mean pooling）和最大值子采样（max pooling）两种形式。子采样可以看作一种特殊的卷积过程。卷积和子采样大大简化了模型复杂度，减少了模型的参数。
• 激活函数 （Activation function）
  常用的激活函数有sigmoid、tanh、relu等等，前两者sigmoid/tanh比较常见于全连接层，后者ReLU常见于卷积层。激活函数的作用是用来加入非线性因素，把卷积层输出结果做非线性映射。
• 全连接层(Fully connected layers)
  全连接层在整个卷积神经网络中起到“分类器”的作用，即通过卷积、激活函数、池化等深度网络后，再经过全连接层对结果进行识别分类。

应用领域

• 图像检索
• 图像检测
• 语音识别
• 不同场景下的图像识别