人工智能实践:Tensorflow笔记(三)：神经网络优化
1、1943年McCulloch Pitts神经元模型
引入的激活函数f可以有效避免仅使用
的线性组合，提高了模型的表达率，是模型具有更好的区分度。
常用的激活函数有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 yopt4_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()
