TensorFlow学习手册（二）——网络框架优化（解读）

TensorFlow学习手册汇总：

0.python的高级用法——列表推导式，生成式

1.神经网络框架

2.网络框架优化

后面开始会涉及一部分numpy,matplotlib之类的知识以及py的高级用法，这些东西在我的python学习手册上有更新，用的例子就是这里的例子，关于这一方面不清楚的请移至：[python学习手册](https://blog.csdn.net/qq_35307005/article/details/87384603)

然后呢，开始今天的更博！

今天是一个神经网络优化的代码笔记。将结合效果图进行解读。

1. 准备数据集

import numpy as np
import matplotlib.pyplot as plt

BATCH_SIZE = 30
seed = 2
# 基于seed产生随机数
rdm = np.random.RandomState(seed)
# 随机数返回300行2列的矩阵，表示300组坐标点（x0,x1）作为输入数据集
X = rdm.randn(300, 2)
# 从X这个300行2列的矩阵中取出一行,判断如果两个坐标的平方和小于2，给Y赋值1，其余赋值0
# 作为输入数据集的标签（正确答案）
Y_ = [int(x0 * x0 + x1 * x1 < 2) for (x0, x1) in X]
# 遍历Y中的每个元素，1赋值'red'其余赋值'blue'，这样可视化显示时人可以直观区分
Y_c = [['red' if y else 'blue'] for y in Y_]
# 对数据集X和标签Y进行shape整理，第一个元素为-1表示，随第二个参数计算得到，第二个元素表示多少列，把X整理为n行2列，把Y整理为n行1列
X = np.vstack(X).reshape(-1, 2)
Y_ = np.vstack(Y_).reshape(-1, 1)
print
X
print
Y_
print
Y_c
# 用plt.scatter画出数据集X各行中第0列元素和第1列元素的点即各行的（x0，x1），用各行Y_c对应的值表示颜色（c是color的缩写） 
plt.scatter(X[:, 0], X[:, 1], c=np.squeeze(Y_c))
plt.show()

1.首先是自己生成一个模拟的数据集，rdm是一个随机种子，X是通过这个随机种子随机出300个不同的值作为行数，（有300个数据集），后面的两列是两个变量，X1,X0。
2.Y_是一个正确答案，用于后面的监督学习。这里涉及PY行列式，可以看python学习手册进行学习。
3.Y_c给他标记颜色，标记颜色的用处是之后可以绘制可视化的图像使对比更明显，之后分别打印各个值。然后用plt.scatter（散点图绘制函数）绘制出原始随机图像。
c=np.squeeze(Y_c)的意思是用Y_c对每个点进行涂色
给大家看一下，这个出来的图的样子

2.搭建前向传播

# 定义神经网络的输入、参数和输出，定义前向传播过程
def get_weight(shape, regularizer):
    w = tf.Variable(tf.random_normal(shape), dtype=tf.float32)
    tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(regularizer)(w))
    return w


def get_bias(shape):
    b = tf.Variable(tf.constant(0.01, shape=shape))
    return b


x = tf.placeholder(tf.float32, shape=(None, 2))
y_ = tf.placeholder(tf.float32, shape=(None, 1))

w1 = get_weight([2, 11], 0.01)
b1 = get_bias([11])
y1 = tf.nn.relu(tf.matmul(x, w1) + b1)

w2 = get_weight([11, 1], 0.01)
b2 = get_bias([1])
y = tf.matmul(y1, w2) + b2

# 定义损失函数
loss_mse = tf.reduce_mean(tf.square(y - y_))
loss_total = loss_mse + tf.add_n(tf.get_collection('losses'))

# 定义反向传播方法：不含正则化
train_step = tf.train.AdamOptimizer(0.0001).minimize(loss_mse)

第一个函数是定义权重，第二个定义偏差，然后通过占位符给出前向传播里的x，y_,这里定义了两层的网络结构。这比较的简单，

3.运行

tf的运行是和搭建分开的

with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    STEPS = 40000
    for i in range(STEPS):
        start = (i * BATCH_SIZE) % 300
        end = start + BATCH_SIZE
        sess.run(train_step, feed_dict={x: X[start:end], y_: Y_[start:end]})
        if i % 2000 == 0:
            loss_mse_v = sess.run(loss_mse, feed_dict={x: X, y_: Y_})
            print("After %d steps, loss is: %f" % (i, loss_mse_v))
    # xx在-3到3之间以步长为0.01，yy在-3到3之间以步长0.01,生成二维网格坐标点
    xx, yy = np.mgrid[-3:3:.01, -3:3:.01]
    # 将xx , yy拉直，并合并成一个2列的矩阵，得到一个网格坐标点的集合
    grid = np.c_[xx.ravel(), yy.ravel()]
    # 将网格坐标点喂入神经网络 ，probs为输出
    probs = sess.run(y, feed_dict={x: grid})
    # probs的shape调整成xx的样子
    probs = probs.reshape(xx.shape)
    print
    "w1:\n", sess.run(w1)
    print
    "b1:\n", sess.run(b1)
    print
    "w2:\n", sess.run(w2)
    print
    "b2:\n", sess.run(b2)

plt.scatter(X[:, 0], X[:, 1], c=np.squeeze(Y_c))
plt.contour(xx, yy, probs, levels=[.5])
plt.show()

1.我们要初始化所有的权重

init_op = tf.global_variables_initializer()
    sess.run(init_op)

这就是初始化的代码块，意思是定义了一个初始化的函数，通过sess.run初始化所有变量

2.后面的意思是我们要分批次的将数据集喂入网络之中，

 if i % 2000 == 0:
            loss_mse_v = sess.run(loss_mse, feed_dict={x: X, y_: Y_})
            print("After %d steps, loss is: %f" % (i, loss_mse_v))

3.每隔2000轮，运行一次损失函数，并打印损失值
为什么已经运行了还要运行，因为它运行了只是有了结果和给出你想要的中间参数，之前并没有损失值的中间参数被保留下来。
出来的损失结果是这个样子的

4.后面那段代码就非常有意思，操作是**做出一个切割红蓝点的线**，做法是使用绘图的等高线+网格操作。

	xx, yy = np.mgrid[-3:3:.01, -3:3:.01]
    # 将xx , yy拉直，并合并成一个2列的矩阵，得到一个网格坐标点的集合
    grid = np.c_[xx.ravel(), yy.ravel()]
    # 将网格坐标点喂入神经网络 ，probs为输出
    probs = sess.run(y, feed_dict={x: grid})
    # probs的shape调整成xx的样子
    probs = probs.reshape(xx.shape)

定义了一个（-3，3）的网络步长为0.01,然后将网格喂入网络，因为网络的权重被更新以后能得到一个和判断相同的分割线来，这个样子就能得到分割两个部分的线了，后面在显示的时候，等高线是5，这样子就只会打印一条线，
打印出来的样子，如图所示：

和前一张图不一样的是，他将这个线也传了进去，于是图中就有了区别红蓝点的等高线。

4.拓展：加入正则化，对比结果

然后我们试试加入正则化惩罚项以后运行的结果

# 定义反向传播方法：包含正则化
train_step = tf.train.AdamOptimizer(0.0001).minimize(loss_total)

with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    STEPS = 40000
    for i in range(STEPS):
        start = (i * BATCH_SIZE) % 300
        end = start + BATCH_SIZE
        sess.run(train_step, feed_dict={x: X[start:end], y_: Y_[start:end]})
        if i % 2000 == 0:
            loss_v = sess.run(loss_total, feed_dict={x: X, y_: Y_})
            print("After %d steps, loss is: %f" % (i, loss_v))

    xx, yy = np.mgrid[-3:3:.01, -3:3:.01]
    grid = np.c_[xx.ravel(), yy.ravel()]
    probs = sess.run(y, feed_dict={x: grid})
    probs = probs.reshape(xx.shape)
    print
    "w1:\n", sess.run(w1)
    print
    "b1:\n", sess.run(b1)
    print
    "w2:\n", sess.run(w2)
    print
    "b2:\n", sess.run(b2)

plt.scatter(X[:, 0], X[:, 1], c=np.squeeze(Y_c))
plt.contour(xx, yy, probs, levels=[.5])
plt.show()

和前向传播类似，之后它会打印出损失值

运行的结果是这个样子的

对比一下没正则化，还是更加接近了的