《人工智能实践：Tensorflow笔记》听课笔记18_4.5神经网络搭建八股

附：课程链接

第四讲.神经网络优化
4.5神经网络搭建八股
由于个人使用Win7系统，并未完全按照课程所讲，以下记录的也基本是我的结合课程做的Windows系统+PyCharm操作。且本人有python基础，故一些操作可能简略。并未完全按照网课。

记住编写代码时，除注释内容外，字符均使用英文格式。

三、神经网络搭建的八股
搭建模块化的神经网络八股：

前向传播就是搭建网络，设计网络结构(一般新建一个文件forward.py)
描述前向传播的过程需要定义3个函数：

"""
    完成网络结构的设计，给出从输入到输出的定义通路
    forward有两个参数，一个是输入x，一个是正则化权重regularizer
"""
def forward(x,regularizer):
    w = 
    b = 
    y = 
    return y

"""
    与参数w有关
    get_weight有两个参数，一个是w的形状shape，一个是正则化权重regularizer
"""
def get_weight(shape,regularizer):
    w = tf.Variable()   #给w赋初值，()里写赋初值的方法。这些方法在3.2中讲过
    tf.add_to_collection('losses',tf.contrib.layers.l2_regularizer(regularizer)(w)) #把每一个w的正则化损失加到总损失losses中
    return w

"""
    与参数b有关
    get_bias有一个参数，一个是b的形状shape，其实就是某层中b的个数
"""
def get_bias(shape):
    b = tf.Variable()   #给b赋初值，()里写赋初值的方法。这些方法在3.2中讲过
    return b

反向传播就是训练网络，优化网络参数（backward.py）:

def backward():
    x = tf.placeholder()    #给输入x占位
    y_ = tf.placeholder()   #给y_占位
    y = forward.forward(x,REGULARIZER)  #用forward模块复现前向传播设计的网络结构，计算求得的结果y
    global_step = tf.Variable(0,trainable=False)    #定义轮数计算器
    loss =  #定义损失函数loss

其中loss可以选用均方误差、自定义、交叉熵，表示计算的y与标准答案y_的差距。
若使用均方误差：

若使用交叉熵：

如果包含正则化：

如果使用指数衰减学习率，把以下代码加入，动态计算学习率：

如果使用滑动平均需加上以下代码，其global_step是和指数衰减学习率共用的：

除此之外，反向传播函数还要定义训练过程train_step：

train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss,global_step=global_step)

用with结构初始化所有参数：

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

用for循环迭代STEPS轮：

for i in range(STEPS):
    sess.run(train_step, feed_dict={x: , y_: })	#每轮会调用sess.run()执行训练过程
    if i % 轮数 == 0:	#此处有语法错误，讲解需要。每运行一定轮数，打印出当前的loss信息
        print()

python引入了if __name__ == '__main__':（注意是双下划线），来判断python运行的文件是否是主文件，如果是主文件则执行backward的函数：

"""
    ！！！注意是双下划线！！！
"""
if __name__ == '__main__':
    backward()

让我们使用模块化的方法实际感受下：
以4.4的例子为例改造，题目如下：

改造版的代码中将使用正则化以提高泛化性，使用指数衰减学习率加快优化效率。
代码将分为3个模块：

先看一下生成数据集的模块：

"""
    模块：生成数据集
"""
import numpy as np
import matplotlib.pyplot as plt #matplotlib帮助实现图形可视化
seed = 2
def generateds():
    rdm = np.random.RandomState(seed)  # 基于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列。
    # （np.vstack：按垂直方向（行顺序堆叠数组构成一个新的数组，文末有简书链接讲解））
    X = np.vstack(X).reshape(-1, 2)
    Y_ = np.vstack(Y_).reshape(-1, 1)

    return X,Y_,Y_c

再来看一下前向传播的模块：

"""
    模块：前向传播
"""
import tensorflow as tf

#定义神经网络的输入、参数和输出，定义前向传播过程
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

#设计了神经网络结构
def forward(x,regularizer):
    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   #输出层不过激活relu

    return y

最后看一下反向传播模块：

"""
    模块：反向传播
"""
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt #matplotlib帮助实现图形可视化
import lec4_5_generateds    #引入自定义模块
import lec4_5_forward   #引入自定义模块

STEPS = 40000
BATCH_SIZE = 30
LEARNING_RATE_BASE = 0.001
LEARNING_RATE_DECAY = 0.999
REGULAEIZER = 0.01

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

    X,Y_,Y_c = lec4_5_generateds.generateds()

    y = lec4_5_forward.forward(x,REGULAEIZER)   #复现神经网络结构

    global_step = tf.Variable(0,trainable=False)
    learning_rate = tf.train.exponential_decay(
        LEARNING_RATE_BASE,
        global_step,
        300/BATCH_SIZE,
        LEARNING_RATE_DECAY,
        staircase=True)

    #定义损失函数
    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(learning_rate).minimize(loss_total)

    with tf.Session() as sess:
        init_op = tf.global_variables_initializer() #初始化所有变量
        sess.run(init_op)
        for i in range(STEPS):#用for循环迭代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在-3到3之间以步长为0.01，yy在-3到3之间以步长为0.01，生成二维网络坐标点
        xx,yy = np.mgrid[-3:3:0.01,-3:3:0.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)

    plt.scatter(X[:,0],X[:,1],c = np.squeeze(Y_c))  #可视化数据点，给出x坐标和y坐标，并给出这个坐标点打算显示的颜色
    plt.contour(xx,yy,probs,levels = [.5])  #然后用plt.contour()函数把x坐标、y坐标、各点的高度，用levels把各点描上颜色
    plt.show()  #把图像散点画出来

if __name__ == '__main__':
    backward()

运行反向传播模块代码，得到结果：

运行过程如图：

第四讲至此结束。

附：助教的TensorFlow笔记4