人工智能实践:Tensorflow笔记(三)：神经网络优化

本文链接：https://blog.youkuaiyun.com/hxxjxw/article/details/89842897

1、1943年McCulloch Pitts神经元模型

引入的激活函数f可以有效避免仅使用 $\sum XW$ 的线性组合，提高了模型的表达率，是模型具有更好的区分度。

常用的激活函数有relu、sigmoid、tanh

softmax函数（归一化函数）

softmax用于多分类过程中，它将多个神经元的输出，映射到（0,1）区间内，可以看成概率来理解，从而来进行多分类！

softmax直白来说就是将原来输出是3,1,-3通过softmax函数一作用，就映射成为(0,1)的值，而这些值的累和为1（满足概率的性质），那么我们就可以将它理解成概率，在最后选取输出结点的时候，我们就可以选取概率最大（也就是值对应最大的）结点，作为我们的预测目标！

2、神经网络的复杂度

神经网络的复杂度多用神经网络层数和神经网络参数的个数表示

计算层数只计算具有运算能力的层（所以是不计入输入层的）

3、神经网络的优化

损失函数loss
学习率learning_rate
滑动平均ema
正则化regularization

损失函数（loss）：预测值（y）和已知答案（y_）的差距

y是前向传播计算出来的结果

神经网络优化目标：loss最小

神经网络的优化目标就是想找到某套参数，使得推算出来的结果y和已知标准答案y_ 无限接近

主流的loss计算有3种：

均方误差mse（Mean Squared Error）
自定义
交叉熵ce(Cross Entropy)

把这套自制的数据喂入神经网络，构建一个一层的神经网络，拟合预测酸奶日销量的函数

#导入模块，生成模拟数据集
 
import tensorflow as tf
import numpy as np
BATCH_SIZE = 8  
SEED = 23455  
 

rdm = np.random.RandomState(seed)
X = rng.rand(32,2)
#加上了随机噪声，-0.05~0.05之间
Y = [[x1+x2+(rdm.rand()/10-0.05)] for (x1,x2) in X]
 

#定义神经网络的输入、参数和输出，定义前向传播过程
x = tf.placeholder(tf.float32, shape = (None,2)) #输入特征是32位浮点型,每个x有2个元素，体积和重量
y_ = tf.placeholder(tf.float32, shape = (None,1)) #每个y有1个元素，合格与否
w1 = tf.Variable(tf.random_normal([2,1],stddev=1, seed=1))#使用正态分布生成
y = tf.matmul(x, w1)
 
 
#定义损失函数及反向传播方法
#定义损失函数为MSE,反向传播方法为梯度下降
loss_mse = tf.reduce_mean(tf.square(y_-y))
train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss_mse)
 
 
#生成会话，训练STEPS轮
with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    #输出目前（未经训练）的参数取值

    #训练模型
    STEPS = 20000
    for i in range(STEPS):
        start = (i*BATCH_SIZE)%32
        end = start + BATCH_SIZE
        sess.run(train_step, feed_dict={x: X[start:end],y_:Y[start:end]})#每轮从X的
        #数据集和Y的标签中，抽取相应的从start到end个特征和标签，汇入神经网络，
        #用sess.run()执行训练过程
        if i%500 ==0:
            print('After %d training step(s),w1 is: '%(i))
            print(sess.run(w1),"\n")
        
    #输出训练后的参数取值
    print('Final w1 is:\n', sess.run(w1))

拟合的结果是y=0.98x1+1.02x2，这和数据集生成公式y=x1+x2是一致的，说明预测酸奶日销量的公式拟合正确

#酸奶成本1元，酸奶利润9元
#预测少了损失大，故不要预测少，故生成的模型会预测多一些
#导入模块，生成模拟数据集
 
import tensorflow as tf
import numpy as np
BATCH_SIZE = 8  
SEED = 23455  
COST = 1
PROFIT = 9
 

rdm = np.random.RandomState(seed)
X = rng.rand(32,2)
#加上了随机噪声，-0.05~0.05之间
Y = [[x1+x2+(rdm.rand()/10-0.05)] for (x1,x2) in X]
 

#定义神经网络的输入、参数和输出，定义前向传播过程
x = tf.placeholder(tf.float32, shape = (None,2)) #输入特征是32位浮点型,每个x有2个元素，体积和重量
y_ = tf.placeholder(tf.float32, shape = (None,1)) #每个y有1个元素，合格与否
w1 = tf.Variable(tf.random_normal([2,1],stddev=1, seed=1))#使用正态分布生成
y = tf.matmul(x, w1)
 
 
#定义损失函数及反向传播方法
#定义损失函数为MSE,反向传播方法为梯度下降
loss = tf.reduce_sum(tf.where(tf.greater(y,y_),(y - y_)*COST, (y_-y)*PROFIT))

train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss)
 
 
#生成会话，训练STEPS轮
with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    #输出目前（未经训练）的参数取值

    #训练模型
    STEPS = 20000
    for i in range(STEPS):
        start = (i*BATCH_SIZE)%32
        end = start + BATCH_SIZE
        sess.run(train_step, feed_dict={x: X[start:end],y_:Y[start:end]})#每轮从X的
        #数据集和Y的标签中，抽取相应的从start到end个特征和标签，汇入神经网络，
        #用sess.run()执行训练过程
        if i%500 ==0:
            print('After %d training step(s),w1 is: '%(i))
            print(sess.run(w1),"\n")
        
    #输出训练后的参数取值
    print('Final w1 is:\n', sess.run(w1))

可以看出模型的确在尽量往高了预测

学习率 learning_rate: 每次参数更新的幅度

#设损失函数 loss=(w+1)^2 ，令w初值是常数5。 反向传播就是求最优化w，即求最小loss对应的w值

import tensorflow as tf
#定义待优化参数w的初值赋5
w = tf.Variable(tf.constant(5,dtype=tf.float32))
#定义损失函数loss
loss = tf.square(w+1)
#定义反向传播方法
train_step = tf.train.GradientDescentOptimizer(0.2).minimize(loss)
#生成会话，训练40轮
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for i in range(40):
        sess.run(train_step)
        w_val = sess.run(w)
        loss_val = sess.run(loss)
        print("After %s steps: w is %f,   loss is %f." %(i,w_val,loss_val))

成功找到了最优参数w=-1

#设损失函数 loss=(w+1)^2 ，令w初值是常数5。 反向传播就是求最优化w，即求最小loss对应的w值
#使用指数衰减学习率， 在迭代初期得到较高的下降速度，可以在较小的训练轮数下取得更有效的收敛度

import tensorflow as tf

LEARNING_RATE_BASE = 0.1  #最初学习率
LEARNING_RATE_DECAY = 0.99  #学习率衰减率
LEARNING_RATE_STEP = 1   #喂入多少轮BATCH_SIZE后，更新一次学习率，一般设为：总样本数/BATCH_SIZE

#运行了几轮BATCH_SIZE的计数器，初值给0，设为不被训练
global_step = tf.Variable(0,trainable = False)
#定义指数下降学习率
learning_rate = tf.train.exponential_decay(LEARNING_RATE_BASE, global_step, LEARNING_RATE_STEP, LEARNING_RATE_DECAY, staircase=True)
#定义待优化参数， 初值为10
w = tf.Variable(tf.constant(5,dtype=tf.float32))
#定义损失函数loss
loss = tf.square(w+1)
#定义反向传播方法
train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_step)


#生成会话，训练40轮
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for i in range(40):
        sess.run(train_step)
        learning_rate_val = sess.run(learning_rate)
        global_step_val = sess.run(global_step)
        w_val = sess.run(w)
        loss_val = sess.run(loss)
        print("After %s steps: global step is %f, w is %f,learning_rate is %f ,loss is %f." %(i,global_step_val,w_val,learning_rate_val,loss_val))

滑动平均

import tensorflow as tf

#1.定义变量及滑动平均类
#定义一个32位浮点变量，初始值为0.0  这个代码就是不断更新w1参数，优化w1参数，滑动平均做了个w1的影子

w1 = tf.Variable(0, dtype=tf.float32)
#定义num_updates(NN的迭代轮数)，初始值为0，不可被优化(训练)，这个参数不训练
global_step = tf.Variable(0,trainable=False)
#实例化滑动平均类，给删减率为0.09, 当前轮数global_step
MOVING_AVERAGE_DECAY = 0.99
ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)
#ema.apply后括号里是更新列表，每次运行sess.run(ema_op)时，对更新列表中的元素求华东平均值
#在实际应用中使用tf.trainable_variables()自动将所有待训练的参数汇总为列表
#ema_op = ema.apply([w1])
ema_op = ema.apply(tf.trainable_variables())

#2.查看不同迭代中变量取值的变化
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    
    #用ema.average(w1)获取w1滑动平均值 (要运行多个节点，作为列表中的元素列出，写在sess.run中)
    #打印出当前参数w1和w1的滑动平均值
    print(sess.run([w1,ema.average(w1)]))
        
    #参数w1赋值为1
    sess.run(tf.assign(w1,1))
    sess.run(ema_op)
    print(sess.run([w1,ema.average(w1)]))
    
    #更新step和w1的值，模拟出100轮迭代后，参数w1变为10
    sess.run(tf.assign(global_step,100))
    sess.run(tf.assign(w1,10))
    sess.run(ema_op)
    print(sess.run([w1, ema.average(w1)]))
        
    #每次sess.run会更新一次w1的滑动平均值
    sess.run(ema_op)
    print(sess.run([w1, ema.average(w1)]))
    
    sess.run(ema_op)
    print(sess.run([w1,ema.average(w1)]))
        
    sess.run(ema_op)
    print(sess.run([w1,ema.average(w1)]))
        
    sess.run(ema_op)
    print(sess.run([w1,ema.average(w1)]))
        
    sess.run(ema_op)
    print(sess.run([w1,ema.average(w1)]))
        
    sess.run(ema_op)
    print(sess.run([w1,ema.average(w1)]))

可以看出参数w1的滑动平均一直在向w1逼近

正则化：有效缓解过拟合

#coding:utf-8
#0导入模块 ，生成模拟数据集
import tensorflow as tf
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()


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

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()



#定义反向传播方法：包含正则化
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()

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

生成数据集 generateds.py

前向传播 forward.py

反向传播 backward.py

opt4_8_backward.py

# coding:utf-8
# 0导入模块 ，生成模拟数据集
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
import opt4_8_generateds
import opt4_8_forward

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


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

    X, Y_, Y_c = opt4_8_generateds.generateds()

    y = opt4_8_forward.forward(x, REGULARIZER)

    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):
            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)

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


if __name__ == '__main__':
    backward()

opt4_8_forward.py

#coding:utf-8
#0导入模块 ，生成模拟数据集
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], regularizer)	
	b1 = get_bias([11])
	y1 = tf.nn.relu(tf.matmul(x, w1) + b1)

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

opt4_8_generateds.py

#coding:utf-8
#0导入模块 ，生成模拟数据集
import numpy as np
import matplotlib.pyplot as plt
seed = 2 
def generateds():
	#基于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进行形状整理，第一个元素为-1表示跟随第二列计算，第二个元素表示多少列，可见X为两列，Y为1列
	X = np.vstack(X).reshape(-1,2)
	Y_ = np.vstack(Y_).reshape(-1,1)
	
	return X, Y_, Y_c
	
#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()