1 第一个文件forward.py

放前向传播的函数，前向传播就是搭建网络结构，设计网络结构。一般需要包含三个函数

  1. # 定义前向传播过程
  2. def forward(x,regularizer):
  3.     w = 
  4.     b = 
  5.     y = 
  6.     return y
  7. # 给权重赋初值
  8. def get_weight(shape, regularizer):
  9.     w = tf.Variable(tf.random_normal(shape), dtype=tf.float32)
  10.     tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(regularizer)(w))
  11.     return w
  12. # 给偏置赋初值
  13. def get_bias(shape):  
  14.     b = tf.Variable(tf.constant(0.01, shape=shape)) 
  15.     return b

2 第二个文件backward.py

反向传播就是训练网络，优化网络参数，该文件可以包含损失函数、指数衰减学习率、滑动平均

  1. def backard():
  2.     x = tf.placeholder()
  3.     y = tf.placeholder()
  4.     y = forward.forward(x,REGULARIZER)
  5.     global_step = tf.Variable(0,trainable =False)
  6.     loss = 
  7. ## 损失函数
  8. #loss第一种是一般求差值的loss，一种是交叉熵的loss，另一种是正则化的loss
  9. #loss_mse = tf.reduce_mean(tf.square(y-y_))# 一般loss
  10. #loss_ce = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y,labels = tf.argmax(y_,1)))# 交叉熵
  11. #loss_total = loss_mse + tf.add_n(tf.get_collection('losses'))# 正则化的loss
  13. ## 指数衰减学习率
  14. learning_rate = tf.train.exponential_decay(
  15.         LEARNING_RATE_BASE,
  16.     global_step,
  17.     #数据集总样本数/Batch_size
  18.     LEARNING_RATE_DECAY,
  19.     staircase =True
  20. )
  22. #定义反向传播方法
  23. train_step = tf.train.AdamOptimizer(0.0001).minimize(loss，global_step =global_step)
  25. ## 滑动平均
  26. ema = tf.train.ExponentialMovingAverage(衰减率MOVING_AVERAGE_DECAY, 当前轮数global_step)#滑动平均
  27. ema_op = ema.apply(tf.trainable_variables())#每运行此句，所有待优化的参数求滑动平均
  28. # 通常我们把滑动平均与训练过程绑定在一起，使它们合成一个训练节点。如下所示
  29. with tf.control_dependencies([train_step,ema_op]):
  30.     train_op = tf.no_op(name='train')
  32. with tf.Session() as sess:
  33.     init_op = tf.global_variables_initializer()#初始化
  34.     sess.run(init_op)#初始化
  35.     STEPS = 3000 # 定义轮数
  36.     for i in range(STEPS):#三千轮
  37.         start = (i*BATCH_SIZE) % 32  #8个数据  为一个数据块输出
  38.         end = (i*BATCH_SIZE) % 32 + BATCH_SIZE  #[i:i+8]
  39.         sess.run(train_step, feed_dict={x: X[start:end], y_: Y[start:end]})#训练
  40. if __name__ = '__main__':
  41.     backward()

3 模块化设计网络举例

数据X[x0,x1]为正态分布随机点，标注Y当【北京大学】7 TensorFlow1.x的神经网络模块设计思想举例及实现 - 图1时y= 1(标记为红色)，其余y_=0(标记未蓝色)
（1）生成数据集generateds.by

  1. #coding:utf-8
  2. #生成模拟数据集
  3. import numpy as np
  4. import matplotlib.pyplot as plt
  5. seed = 2 
  6. def generateds():
  7.     #基于seed产生随机数
  8.     rdm = np.random.RandomState(seed)
  9.     #随机数返回300行2列的矩阵，表示300组坐标点（x0,x1）作为输入数据集
  10.     X = rdm.randn(300,2)
  11.     #从X这个300行2列的矩阵中取出一行,判断如果两个坐标的平方和小于2，给Y赋值1，其余赋值0
  12.     #作为输入数据集的标签（正确答案）
  13.     Y_ = [int(x0*x0 + x1*x1 <2) for (x0,x1) in X]
  14.     #遍历Y中的每个元素，1赋值'red'其余赋值'blue'，这样可视化显示时人可以直观区分
  15.     Y_c = [['red' if y else 'blue'] for y in Y_]#对应颜色Y_c
  16.     #对数据集X和标签Y进行形状整理，第一个元素为-1表示跟随第二列计算，第二个元素表示多少列，可见X为两列，Y为1列
  17.     X = np.vstack(X).reshape(-1,2)#整理形状
  18.     Y_ = np.vstack(Y_).reshape(-1,1)#整理形状
  20.     return X, Y_, Y_c
  22. #print X
  23. #print Y_
  24. #print Y_c
  25. #用plt.scatter画出数据集X各行中第0列元素和第1列元素的点即各行的（x0，x1），用各行Y_c对应的值表示颜色（c是color的缩写） 
  26. #plt.scatter(X[:,0], X[:,1], c=np.squeeze(Y_c)) 
  27. #plt.show()

（2）前向传播 forward.py，设计了神经网络结构

  1. #coding:utf-8
  2. #前向传播就是搭建网络
  3. import tensorflow as tf
  5. #定义神经网络的输入、参数和输出，定义前向传播过程 
  6. def get_weight(shape, regularizer):#（shape：W的形状，regularizer正则化）
  7.     w = tf.Variable(tf.random_normal(shape), dtype=tf.float32)#赋初值，正态分布权重
  8.     tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(regularizer)(w))#把正则化损失加到总损失losses中
  9.     return w#返回w
  10. #tf.add_to_collection(‘list_name’, element)：将元素element添加到列表list_name中
  12. def get_bias(shape):  #偏执b
  13.     b = tf.Variable(tf.constant(0.01, shape=shape)) #偏执b=0.01
  14.     return b#返回值
  16. def forward(x, regularizer):#前向传播
  18.     w1 = get_weight([2,11], regularizer)#设置权重    
  19.     b1 = get_bias([11])#设置偏执
  20.     y1 = tf.nn.relu(tf.matmul(x, w1) + b1)#计算图
  22.     w2 = get_weight([11,1], regularizer)#设置权重
  23.     b2 = get_bias([1])#设置偏执
  24.     y = tf.matmul(y1, w2) + b2 #计算图
  26.     return y#返回值

（3）反向传播 backward.py

  1. #coding:utf-8
  2. #0导入模块 ，生成模拟数据集
  3. import tensorflow as tf
  4. import numpy as np
  5. import matplotlib.pyplot as plt
  6. import opt4_8_generateds
  7. import opt4_8_forward
  9. STEPS = 40000
  10. BATCH_SIZE = 30 
  11. LEARNING_RATE_BASE = 0.001
  12. LEARNING_RATE_DECAY = 0.999
  13. REGULARIZER = 0.01#正则化
  15. def backward():#反向传播
  16.     x = tf.placeholder(tf.float32, shape=(None, 2))#占位
  17.     y_ = tf.placeholder(tf.float32, shape=(None, 1))#占位
  18.     #X：300行2列的矩阵。Y_:坐标的平方和小于2，给Y赋值1，其余赋值0
  19.     X, Y_, Y_c = opt4_8_generateds.generateds()
  21.     y = opt4_8_forward.forward(x, REGULARIZER)#前向传播计算后求得输出y
  23.     global_step = tf.Variable(0,trainable=False)#轮数计数器    
  24.     #指数衰减学习率
  25.     learning_rate = tf.train.exponential_decay(
  26.         LEARNING_RATE_BASE,#学习率
  27.         global_step,#计数
  28.         300/BATCH_SIZE,
  29.         LEARNING_RATE_DECAY,#学习衰减lü
  30.         staircase=True)#选择不同的衰减方式
  33.     #定义损失函数
  34.     loss_mse = tf.reduce_mean(tf.square(y-y_))#均方误差
  35.     loss_total = loss_mse + tf.add_n(tf.get_collection('losses'))#正则化
  37.     #定义反向传播方法：包含正则化
  38.     train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss_total)
  40.     with tf.Session() as sess:
  41.         init_op = tf.global_variables_initializer()#初始化
  42.         sess.run(init_op)#初始化
  43.         for i in range(STEPS):
  44.             start = (i*BATCH_SIZE) % 300
  45.             end = start + BATCH_SIZE#3000轮
  46.             sess.run(train_step, feed_dict={x: X[start:end], y_:Y_[start:end]})
  47.             if i % 2000 == 0:
  48.                 loss_v = sess.run(loss_total, feed_dict={x:X,y_:Y_})
  49.                 print("After %d steps, loss is: %f" %(i, loss_v))
  51.         xx, yy = np.mgrid[-3:3:.01, -3:3:.01]#网格坐标点
  52.         grid = np.c_[xx.ravel(), yy.ravel()]
  53.         probs = sess.run(y, feed_dict={x:grid})
  54.         probs = probs.reshape(xx.shape)
  56.     plt.scatter(X[:,0], X[:,1], c=np.squeeze(Y_c)) #画点
  57.     plt.contour(xx, yy, probs, levels=[.5])#画线
  58.     plt.show()#显示图像
  60. if __name__=='__main__':
  61.     backward()

截屏2020-12-19 下午9.45.17.png