随着科研人员在使用神经网络训练时不断的尝试，为我们留下了很多有用的技巧，合理的运用这些技巧可以使自己的模型得到更好的拟合效果。

全连接网络虽然在拟合问题上比较强大，但太强大的拟合效果也带来了其它的麻烦，这就是过拟合问题。

首先我们看一个例子，这次将原有的4个异或带护具扩充成了上百个具有异或特征的数据集，然后通过全连接网络将它们进行分类。

实例描述：构建异或数据集模拟样本，在构建一个简单的多层神经网络来拟合其样本特征，观察其出现前泥河的现象，接着通过增大网络复杂性的方式来优化欠拟合问题，使其出现过拟合现象。

  1. \'\'\'
  2.     生成随机数据
  3.     \'\'\'
  4.     np.random.seed(10)
  5.     #特征个数
  6.     num_features = 2
  7.     #样本个数
  8.     num_samples = 320
  9.     #n返回长度为特征的数组 正太分布
  10.     mean = np.random.randn(num_features)
  11.     print(\'mean\',mean)
  12.     cov = np.eye(num_features)
  13.     print(\'cov\',cov)
  14.     X,Y = generate(num_samples,mean,cov,[[3.0,0.0],[3.0,3.0],[0.0,3.0]],num_classes=4)
  15.     #转换为二种类别
  16.     Y = Y % 2        
  17.     
  18.     xr = []
  19.     xb = []
  20.     
  21.     for (l,k) in zip(Y[:],X[:]):
  22.         if l == 0.0:
  23.             xr.append([k[0],k[1]])
  24.         else:
  25.             xb.append([k[0],k[1]])
  26.         
  27.     xr = np.array(xr)
  28.     xb = np.array(xb)
  29.     plt.scatter(xr[:,0],xr[:,1],c=\'r\',marker=\'+\')
  30.     plt.scatter(xb[:,0],xb[:,1],c=\'b\',marker=\'o\')

可以看到图上数据分为两类，左上和左下是一类，右上和右下是一类。

  1. \'\'\'
  2.     定义变量
  3.     \'\'\'
  4.     #学习率
  5.     learning_rate = 1e-4
  6.     #输入层节点个数
  7.     n_input = 2
  8.     #隐藏层节点个数
  9.     n_hidden = 2
  10.     #输出节点数
  11.     n_label = 1
  12.     
  13.     input_x = tf.placeholder(tf.float32,[None,n_input])
  14.     input_y = tf.placeholder(tf.float32,[None,n_label])
  15.     
  16.     \'\'\'
  17.     定义学习参数
  18.     
  19.     h1 代表隐藏层
  20.     h2 代表输出层
  21.     \'\'\'
  22.     weights = {
  23.             \'h1\':tf.Variable(tf.truncated_normal(shape=[n_input,n_hidden],stddev = 0.01)),     #方差0.1
  24.             \'h2\':tf.Variable(tf.truncated_normal(shape=[n_hidden,n_label],stddev=0.01))
  25.             }
  26.     
  27.     
  28.     biases = {
  29.             \'h1\':tf.Variable(tf.zeros([n_hidden])),    
  30.             \'h2\':tf.Variable(tf.zeros([n_label]))
  31.             }
  32.     
  33.     
  34.     \'\'\'
  35.     定义网络模型
  36.     \'\'\'
  37.     #隐藏层
  38.     layer_1 = tf.nn.relu(tf.add(tf.matmul(input_x,weights[\'h1\']),biases[\'h1\']))
  39.     
  40.     
  41.     #代价函数
  42.     y_pred = tf.nn.sigmoid(tf.add(tf.matmul(layer_1, weights[\'h2\']),biases[\'h2\'])) 
  43.     loss = tf.reduce_mean(tf.square(y_pred - input_y))
  44.     
  45.         
  46.     train = tf.train.AdamOptimizer(learning_rate).minimize(loss)
  1.   \'\'\'
  2.     开始训练
  3.     \'\'\'
  4.     training_epochs = 30000
  5.     sess = tf.InteractiveSession()
  6.     
  7.     #初始化
  8.     sess.run(tf.global_variables_initializer())
  9.     
  10.     for epoch in range(training_epochs):
  11.         _,lo = sess.run([train,loss],feed_dict={input_x:X,input_y:np.reshape(Y,[-1,1])})
  12.         if epoch % 1000 == 0:
  13.             print(\'Epoch {0}  loss {1}\'.format(epoch,lo))
  14.         
  15.         
  16.     \'\'\'
  17.     数据可视化
  18.     \'\'\'      
  19.     nb_of_xs = 200
  20.     xs1 = np.linspace(-1,8,num = nb_of_xs)
  21.     xs2 = np.linspace(-1,8,num = nb_of_xs)
  22.     
  23.     #创建网格
  24.     xx,yy = np.meshgrid(xs1,xs2)
  25.     
  26.     #初始化和填充 classfication plane
  27.     classfication_plane = np.zeros([nb_of_xs,nb_of_xs])
  28.     
  29.     for i in range(nb_of_xs):
  30.         for j in range(nb_of_xs):
  31.             #计算每个输入样本对应的分类标签
  32.             classfication_plane[i,j] = sess.run(y_pred,feed_dict={input_x:[[xx[i,j],yy[i,j]]]})
  33.             
  34.     #创建 color map用于显示
  35.     cmap = ListedColormap([
  36.                 colorConverter.to_rgba(\'r\',alpha = 0.30),
  37.                 colorConverter.to_rgba(\'b\',alpha = 0.30),      
  38.             ])
  39.     #显示各个样本边界
  40.     plt.contourf(xx,yy,classfication_plane,cmap = cmap)
  41.     plt.show()

　　

可以看到，模型在迭代训练20000次之后梯度更新就放缓了，而且loss值约等于16%并且准确率不高，所可视化的图片也没有将数据完全分开。

图上这种现象就叫做欠拟合，即没有完全拟合到想要得到的真实数据情况。

欠拟合的原因并不是模型不行，而是我们的学习方法无法更精准地学习到适合的模型参数。模型越薄弱，对训练的要求就越高。但是可以采用增加节点或者增加层的方式，让模型具有更高的拟合性，从而降低模型的训练难度。

将隐藏层的节点个数改为200，代码如下：

  1.     #隐藏层节点个数
  2.     n_hidden = 200

从图中可以看到强大的全连接网络，仅仅通过一个隐藏层，使用200个神经元就可以把数据划分的那么细致。而loss值也在逐渐变小，30000次之后已经变成了0.056.

那么对于上面的模型好不好呢？我们再取少量的数据放到模型中验证一下，然后用同样的方式在坐标系中可视化。

  1. \'\'\'
  2.     测试  可以看到测试集loss值和训练集loss差距较大 这是因为模型过拟合了 
  3.     \'\'\'
  4.     test_x,test_y = generate(12,mean,cov,[[3.0,0.0],[3.0,3.0],[0.0,3.0]],num_classes=4)
  5.     #转换为二种类别
  6.     test_y = test_y % 2      
  7.  
  8.  
  9.     
  10.     xr = []
  11.     xb = []
  12.     
  13.     for (l,k) in zip(test_y[:],test_x[:]):
  14.         if l == 0.0:
  15.             xr.append([k[0],k[1]])
  16.         else:
  17.             xb.append([k[0],k[1]])
  18.         
  19.     xr = np.array(xr)
  20.     xb = np.array(xb)
  21.     plt.figure()
  22.     plt.scatter(xr[:,0],xr[:,1],c=\'r\',marker=\'+\')
  23.     plt.scatter(xb[:,0],xb[:,1],c=\'b\',marker=\'o\')
  24.     
  25.     lo = sess.run(loss,feed_dict={input_x:test_x,input_y:np.reshape(test_y,[-1,1])})
  26.     print(\'Test data  loss {0}\'.format(lo))
  27.         
  28.     nb_of_xs = 200
  29.     xs1 = np.linspace(-1,8,num = nb_of_xs)
  30.     xs2 = np.linspace(-1,8,num = nb_of_xs)
  31.     
  32.     #创建网格
  33.     xx,yy = np.meshgrid(xs1,xs2)
  34.     
  35.     #初始化和填充 classfication plane
  36.     classfication_plane = np.zeros([nb_of_xs,nb_of_xs])
  37.     
  38.     for i in range(nb_of_xs):
  39.         for j in range(nb_of_xs):
  40.             #计算每个输入样本对应的分类标签
  41.             classfication_plane[i,j] = sess.run(y_pred,feed_dict={input_x:[[xx[i,j],yy[i,j]]]})
  42.             
  43.     #创建 color map用于显示
  44.     cmap = ListedColormap([
  45.                 colorConverter.to_rgba(\'r\',alpha = 0.30),
  46.                 colorConverter.to_rgba(\'b\',alpha = 0.30),      
  47.             ])
  48.     #显示各个样本边界
  49.     plt.contourf(xx,yy,classfication_plane,cmap = cmap)
  50.     plt.show()

从这次运行结果，我们可以看到测试集的loss增加到了0.21，并没有原来训练时候的那么好0.056，模型还是原来的模型，但是这次却只框住了少量的样本。这种现象就是过拟合，它和欠拟合都是我们在训练模型中不愿意看到的现象，我们要的是真正的拟合在测试情况下能够变现出训练时的良好效果。

避免过拟合的方法有很多：常用的有early stopping、数据集扩展、正则化、弃权等，下面会使用这些方法来对该案例来进行优化。

 Tensorflow中封装了L2正则化的函数可以直接使用：

  1. tf.nn.l2_loss(t,name=None)

函数原型如下：

  1. def l2_loss(t, name=None):
  2.   r"""L2 Loss.
  3.  
  4.   Computes half the L2 norm of a tensor without the `sqrt`:
  5.  
  6.       output = sum(t ** 2) / 2
  7.  
  8.   Args:
  9.     t: A `Tensor`. Must be one of the following types: `half`, `float32`, `float64`.
  10.       Typically 2-D, but may have any dimensions.
  11.     name: A name for the operation (optional).
  12.  
  13.   Returns:
  14.     A `Tensor`. Has the same type as `t`. 0-D.
  15.   """
  16.   result = _op_def_lib.apply_op("L2Loss", t=t, name=name)
  17.   return result

但是并没有提供L1正则化函数，但是可以自己组合：

  1. tf.reduce_sum(tf.abs(w))

我们在代码中加入L2正则化：并设置返回参数lamda=1.6，修改代价函数如下：

  1. loss = tf.reduce_mean(tf.square(y_pred - input_y)) + lamda * tf.nn.l2_loss(weights[\'h1\'])/ num_samples + tf.nn.l2_loss(weights[\'h2\']) *lamda/ num_samples

　　

训练集的代价值从0.056增加到了0.106，但是测试集的代价值仅仅从0.21降到了0.0197，其效果并不是太明显。

下面再试试通过增大数据集的方法来改善过度拟合的情况，这里不再生产一个随机样本，而是每次从循环生成1000个数据。部分代码如下：

  1.  for epoch in range(training_epochs):
  2.         train_x,train_y = generate(num_samples,mean,cov,[[3.0,0.0],[3.0,3.0],[0.0,3.0]],num_classes=4)
  3.         #转换为二种类别
  4.         train_y = train_y % 2      
  5.         _,lo = sess.run([train,loss],feed_dict={input_x:train_x,input_y:np.reshape(train_y,[-1,1])})
  6.         if epoch % 1000 == 0:
  7.             print(\'Epoch {0}  loss {1}\'.format(epoch,lo))

　　

这次测试集代价值降到了0.04，比训练集还低，泛化效果更好了。

在TensorFlow中弃权的函数原型如下：

  1. def dropout(x,keep_prob,noise_shape=None,seed=None,name=None)

其中的参数意义如下：

  • x：输入的模型节点
  • keep_prob：保存率，如果为1，则代表全部进行学习，如果为0.8,则代表丢弃20%的节点，只让80%的节点参与学习。
  • noise_shape：指定x中，哪些维度可以使用dropout技术。
  • seed：随机选择节点的过程中随机数的种子值。

dropout改变了神经网络的结构，它仅仅是属于训练时的方法，所以一般在进行测试时要将dropout的keep_prob设置为1，代表不需要进行丢弃，否则会影响模型的正常输出。

程序中加入了弃权，并且把keep_prob设置为0.5.

  1. \'\'\'
  2.     定义网络模型
  3.     \'\'\'
  4.     #隐藏层
  5.     layer_1 = tf.nn.relu(tf.add(tf.matmul(input_x,weights[\'h1\']),biases[\'h1\']))
  6.     keep_prob = tf.placeholder(dtype=tf.float32)
  7.     layer_1_drop = tf.nn.dropout(layer_1,keep_prob)
  8.     
  9.     #代价函数
  10.     y_pred = tf.nn.sigmoid(tf.add(tf.matmul(layer_1_drop, weights[\'h2\']),biases[\'h2\'])) 
  11.     loss = tf.reduce_mean(tf.square(y_pred - input_y))

输出结果如下，可以看到加入弃权改进也并不是多大，和L2正则化效果差不多。

从上面结果可以看到代价值在来回波动，这主要是因为在训练后期出现了抖动现象，这表明学习率有点大了，这里我们可以添加退化学习率。

在使用优化器代码部分添加learning_rate，设置总步数为30000，每执行1000步，学习率衰减0.9，部分代码如下：

  1. \'\'\'
  2.     定义网络模型
  3.     \'\'\'
  4.     #隐藏层
  5.     layer_1 = tf.nn.relu(tf.add(tf.matmul(input_x,weights[\'h1\']),biases[\'h1\']))
  6.     keep_prob = tf.placeholder(dtype=tf.float32)
  7.     layer_1_drop = tf.nn.dropout(layer_1,keep_prob)
  8.     
  9.     #代价函数
  10.     y_pred = tf.nn.sigmoid(tf.add(tf.matmul(layer_1_drop, weights[\'h2\']),biases[\'h2\'])) 
  11.     loss = tf.reduce_mean(tf.square(y_pred - input_y))
  12.     
  13.         
  14.     global_step = tf.Variable(0,trainable=False)
  15.     decaylearning_rate = tf.train.exponential_decay(learning_rate,global_step,1000,0.9)
  16.     train = tf.train.AdamOptimizer(decaylearning_rate).minimize(loss,global_step = global_step)
  17.  
  18.     
  19.     \'\'\'
  20.     开始训练
  21.     \'\'\'
  22.     training_epochs = 30000
  23.     sess = tf.InteractiveSession()
  24.     
  25.     #初始化
  26.     sess.run(tf.global_variables_initializer())
  27.     
  28.     for epoch in range(training_epochs):        
  29.         #执行一次train global_step变量会自加1
  30.         rate,_,lo = sess.run([decaylearning_rate,train,loss],feed_dict={input_x:train_x,input_y:np.reshape(train_y,[-1,1]),keep_prob:0.5})
  31.         if epoch % 1000 == 0:
  32.             print(\'Epoch {0}   learning_rate  {1} loss {2} \'.format(epoch,rate,lo))

我们可以看到学习率是衰减了，但是效果并不是很明显，代价值还是在震荡，我们可以尝试调整一些参数，是的效果更好，这是一件需要耐心的事情。

完整代码：

  1. # -*- coding: utf-8 -*-
  2. """
  3. Created on Thu Apr 26 15:02:16 2018
  5. @author: zy
  6. """
  7.  
  8. \'\'\'
  9. 通过一个过拟合的案例 来学习全网络训练中的优化技巧 比如：正则化，弃权等
  10. \'\'\'
  11.  
  12. import  tensorflow  as tf
  13. import  numpy as np
  14. from sklearn.utils import shuffle
  15. import matplotlib.pyplot as plt
  16. import random
  17. from matplotlib.colors import colorConverter, ListedColormap 
  19. \'\'\'
  20. 生成数据集
  21. \'\'\'
  22.  
  23. def get_one_hot(labels,num_classes):
  24.     \'\'\'
  25.     one_hot编码
  26.     
  27.     args:
  28.         labels : 输如类标签
  29.         num_classes：类别个数
  30.     \'\'\'    
  31.     m = np.zeros([labels.shape[0],num_classes])
  32.     for i in range(labels.shape[0]):  
  33.         m[i][labels[i]] = 1
  34.     return m
  35.         
  36.     
  38. def  generate(sample_size,mean,cov,diff,num_classes=2,one_hot = False):
  39.     \'\'\'
  40.     因为没有医院的病例数据，所以模拟生成一些样本
  41.     按照指定的均值和方差生成固定数量的样本
  42.     
  43.     args:
  44.         sample_size:样本个数
  45.         mean: 长度为 M 的 一维ndarray或者list  对应每个特征的均值
  46.         cov： N X N的ndarray或者list  协方差  对称矩阵
  47.         diff:长度为 类别-1 的list    每i元素为第i个类别和第0个类别均值的差值 [特征1差，特征2差....]  如果长度不够，后面每个元素值取diff最后一个元素
  48.         num_classes：分类数
  49.         one_hot : one_hot编码
  50.     \'\'\'
  51.         
  52.     #每一类的样本数 假设有1000个样本 分两类，每类500个样本    
  53.     sample_per_class = int(sample_size/num_classes)
  54.     
  55.     
  56.     \'\'\'
  57.     多变量正态分布
  58.     mean : 1-D array_like, of length N . Mean of the N-dimensional distribution.    数组类型，每一个元素对应一维的平均值
  59.     cov : 2-D array_like, of shape (N, N) .Covariance matrix of the distribution. It must be symmetric and positive-semidefinite 
  60.         for proper sampling.
  61.     size:shape. Given a shape of, for example, (m,n,k), m*n*k samples are generated, and packed in an m-by-n-by-k arrangement.
  62.         Because each sample is N-dimensional, the output shape is (m,n,k,N). If no shape is specified, a single (N-D) sample is 
  63.         returned.
  64.     \'\'\'
  65.     #生成均值为mean,协方差为cov sample_per_class x len(mean)个样本 类别为0
  66.     X0 = np.random.multivariate_normal(mean,cov,sample_per_class)    
  67.     Y0 = np.zeros(sample_per_class,dtype=np.int32)
  68.     
  69.     
  70.     #对于diff长度不够进行处理
  71.     if len(diff) != num_classes-1:
  72.         tmp = np.zeros(num_classes-1)
  73.         tmp[0:len(diff)] = diff  
  74.         tmp[len(diff):] = diff[-1]
  75.     else:
  76.         tmp = diff
  77.     
  78.     
  79.     for ci,d  in enumerate(tmp):
  80.         \'\'\'
  81.         把list变成 索引-元素树，同时迭代索引和元素本身
  82.         \'\'\'
  83.         
  84.         #生成均值为mean+d,协方差为cov sample_per_class x len(mean)个样本 类别为ci+1
  85.         X1 = np.random.multivariate_normal(mean+d,cov,sample_per_class)                
  86.         Y1 = (ci+1)*np.ones(sample_per_class,dtype=np.int32)
  87.                 
  88.         #合并X0,X1  按列拼接
  89.         X0 = np.concatenate((X0,X1))
  90.         Y0 = np.concatenate((Y0,Y1))
  91.         
  92.         
  93.     if one_hot:           
  94.         Y0 = get_one_hot(Y0,num_classes)
  95.         
  96.     #打乱顺序
  97.     X,Y  =  shuffle(X0,Y0)
  98.     
  99.     return X,Y
  102. def example_overfit():
  103.     \'\'\'
  104.     显示一个过拟合的案例
  105.     \'\'\'
  106.     
  107.     \'\'\'
  108.     生成随机数据
  109.     \'\'\'
  110.     np.random.seed(10)
  111.     #特征个数
  112.     num_features = 2
  113.     #样本个数
  114.     num_samples = 320
  115.     #n返回长度为特征的数组 正太分布
  116.     mean = np.random.randn(num_features)
  117.     print(\'mean\',mean)
  118.     cov = np.eye(num_features)
  119.     print(\'cov\',cov)
  120.     train_x,train_y = generate(num_samples,mean,cov,[[3.0,0.0],[3.0,3.0],[0.0,3.0]],num_classes=4)
  121.     #转换为二种类别
  122.     train_y = train_y % 2      
  125.     
  126.     xr = []
  127.     xb = []
  128.     
  129.     for (l,k) in zip(train_y[:],train_x[:]):
  130.         if l == 0.0:
  131.             xr.append([k[0],k[1]])
  132.         else:
  133.             xb.append([k[0],k[1]])
  134.         
  135.     xr = np.array(xr)
  136.     xb = np.array(xb)
  137.     plt.scatter(xr[:,0],xr[:,1],c=\'r\',marker=\'+\')
  138.     plt.scatter(xb[:,0],xb[:,1],c=\'b\',marker=\'o\')
  140.     
  141.     
  142.     
  143.     \'\'\'
  144.     定义变量
  145.     \'\'\'
  146.     #学习率
  147.     learning_rate = 1e-4
  148.     #输入层节点个数
  149.     n_input = 2
  150.     #隐藏层节点个数
  151.     n_hidden = 200   #设置为2则会欠拟合
  152.     #输出节点数
  153.     n_label = 1
  154.     
  155.     input_x = tf.placeholder(tf.float32,[None,n_input])
  156.     input_y = tf.placeholder(tf.float32,[None,n_label])
  157.     
  158.     \'\'\'
  159.     定义学习参数
  160.     
  161.     h1 代表隐藏层
  162.     h2 代表输出层
  163.     \'\'\'
  164.     weights = {
  165.             \'h1\':tf.Variable(tf.truncated_normal(shape=[n_input,n_hidden],stddev = 0.01)),     #方差0.1
  166.             \'h2\':tf.Variable(tf.truncated_normal(shape=[n_hidden,n_label],stddev=0.01))
  167.             }
  168.     
  169.     
  170.     biases = {
  171.             \'h1\':tf.Variable(tf.zeros([n_hidden])),    
  172.             \'h2\':tf.Variable(tf.zeros([n_label]))
  173.             }
  174.     
  175.     
  176.     \'\'\'
  177.     定义网络模型
  178.     \'\'\'
  179.     #隐藏层
  180.     layer_1 = tf.nn.relu(tf.add(tf.matmul(input_x,weights[\'h1\']),biases[\'h1\']))
  181.     
  182.     
  183.     #代价函数
  184.     y_pred = tf.nn.sigmoid(tf.add(tf.matmul(layer_1, weights[\'h2\']),biases[\'h2\'])) 
  185.     loss = tf.reduce_mean(tf.square(y_pred - input_y))
  186.     
  187.         
  188.     train = tf.train.AdamOptimizer(learning_rate).minimize(loss)
  189.     
  190.     
  191.     \'\'\'
  192.     开始训练
  193.     \'\'\'
  194.     training_epochs = 30000
  195.     sess = tf.InteractiveSession()
  196.     
  197.     #初始化
  198.     sess.run(tf.global_variables_initializer())
  199.     
  200.     for epoch in range(training_epochs):
  201.         _,lo = sess.run([train,loss],feed_dict={input_x:train_x,input_y:np.reshape(train_y,[-1,1])})
  202.         if epoch % 1000 == 0:
  203.             print(\'Epoch {0}  loss {1}\'.format(epoch,lo))
  204.         
  205.         
  206.     \'\'\'
  207.     数据可视化
  208.     \'\'\'      
  209.     nb_of_xs = 200
  210.     xs1 = np.linspace(-1,8,num = nb_of_xs)
  211.     xs2 = np.linspace(-1,8,num = nb_of_xs)
  212.     
  213.     #创建网格
  214.     xx,yy = np.meshgrid(xs1,xs2)
  215.     
  216.     #初始化和填充 classfication plane
  217.     classfication_plane = np.zeros([nb_of_xs,nb_of_xs])
  218.     
  219.     for i in range(nb_of_xs):
  220.         for j in range(nb_of_xs):
  221.             #计算每个输入样本对应的分类标签
  222.             classfication_plane[i,j] = sess.run(y_pred,feed_dict={input_x:[[xx[i,j],yy[i,j]]]})
  223.             
  224.     #创建 color map用于显示
  225.     cmap = ListedColormap([
  226.                 colorConverter.to_rgba(\'r\',alpha = 0.30),
  227.                 colorConverter.to_rgba(\'b\',alpha = 0.30),      
  228.             ])
  229.     #显示各个样本边界
  230.     plt.contourf(xx,yy,classfication_plane,cmap = cmap)
  231.     plt.show()
  232.     
  233.     
  234.     
  235.     \'\'\'
  236.     测试  可以看到测试集loss值和训练集loss差距较大 这是因为模型过拟合了 
  237.     \'\'\'
  238.     test_x,test_y = generate(12,mean,cov,[[3.0,0.0],[3.0,3.0],[0.0,3.0]],num_classes=4)
  239.     #转换为二种类别
  240.     test_y = test_y % 2      
  243.     
  244.     xr = []
  245.     xb = []
  246.     
  247.     for (l,k) in zip(test_y[:],test_x[:]):
  248.         if l == 0.0:
  249.             xr.append([k[0],k[1]])
  250.         else:
  251.             xb.append([k[0],k[1]])
  252.         
  253.     xr = np.array(xr)
  254.     xb = np.array(xb)
  255.     plt.figure()
  256.     plt.scatter(xr[:,0],xr[:,1],c=\'r\',marker=\'+\')
  257.     plt.scatter(xb[:,0],xb[:,1],c=\'b\',marker=\'o\')
  258.     
  259.     lo = sess.run(loss,feed_dict={input_x:test_x,input_y:np.reshape(test_y,[-1,1])})
  260.     print(\'Test data  loss {0}\'.format(lo))
  261.         
  262.     nb_of_xs = 200
  263.     xs1 = np.linspace(-1,8,num = nb_of_xs)
  264.     xs2 = np.linspace(-1,8,num = nb_of_xs)
  265.     
  266.     #创建网格
  267.     xx,yy = np.meshgrid(xs1,xs2)
  268.     
  269.     #初始化和填充 classfication plane
  270.     classfication_plane = np.zeros([nb_of_xs,nb_of_xs])
  271.     
  272.     for i in range(nb_of_xs):
  273.         for j in range(nb_of_xs):
  274.             #计算每个输入样本对应的分类标签
  275.             classfication_plane[i,j] = sess.run(y_pred,feed_dict={input_x:[[xx[i,j],yy[i,j]]]})
  276.             
  277.     #创建 color map用于显示
  278.     cmap = ListedColormap([
  279.                 colorConverter.to_rgba(\'r\',alpha = 0.30),
  280.                 colorConverter.to_rgba(\'b\',alpha = 0.30),      
  281.             ])
  282.     #显示各个样本边界
  283.     plt.contourf(xx,yy,classfication_plane,cmap = cmap)
  284.     plt.show()
  289. def example_l2_norm():
  290.     \'\'\'
  291.     显利用l2范数缓解过拟合
  292.     \'\'\'
  293.     
  294.     \'\'\'
  295.     生成随机数据
  296.     \'\'\'
  297.     np.random.seed(10)
  298.     #特征个数
  299.     num_features = 2
  300.     #样本个数
  301.     num_samples = 320
  302.     #n返回长度为特征的数组 正太分布
  303.     mean = np.random.randn(num_features)
  304.     print(\'mean\',mean)
  305.     cov = np.eye(num_features)
  306.     print(\'cov\',cov)
  307.     train_x,train_y = generate(num_samples,mean,cov,[[3.0,0.0],[3.0,3.0],[0.0,3.0]],num_classes=4)
  308.     #转换为二种类别
  309.     train_y = train_y % 2      
  312.     
  313.     xr = []
  314.     xb = []
  315.     
  316.     for (l,k) in zip(train_y[:],train_x[:]):
  317.         if l == 0.0:
  318.             xr.append([k[0],k[1]])
  319.         else:
  320.             xb.append([k[0],k[1]])
  321.         
  322.     xr = np.array(xr)
  323.     xb = np.array(xb)
  324.     plt.scatter(xr[:,0],xr[:,1],c=\'r\',marker=\'+\')
  325.     plt.scatter(xb[:,0],xb[:,1],c=\'b\',marker=\'o\')
  327.     
  328.     
  329.     
  330.     \'\'\'
  331.     定义变量
  332.     \'\'\'
  333.     #学习率
  334.     learning_rate = 1e-4
  335.     #输入层节点个数
  336.     n_input = 2
  337.     #隐藏层节点个数
  338.     n_hidden = 200   #设置为2则会欠拟合
  339.     #输出节点数
  340.     n_label = 1
  341.     #规范化参数
  342.     lamda = 1.6
  343.     
  344.     input_x = tf.placeholder(tf.float32,[None,n_input])
  345.     input_y = tf.placeholder(tf.float32,[None,n_label])
  346.     
  347.     \'\'\'
  348.     定义学习参数
  349.     
  350.     h1 代表隐藏层
  351.     h2 代表输出层
  352.     \'\'\'
  353.     weights = {
  354.             \'h1\':tf.Variable(tf.truncated_normal(shape=[n_input,n_hidden],stddev = 0.01)),     #方差0.1
  355.             \'h2\':tf.Variable(tf.truncated_normal(shape=[n_hidden,n_label],stddev=0.01))
  356.             }
  357.     
  358.     
  359.     biases = {
  360.             \'h1\':tf.Variable(tf.zeros([n_hidden])),    
  361.             \'h2\':tf.Variable(tf.zeros([n_label]))
  362.             }
  363.     
  364.     
  365.     \'\'\'
  366.     定义网络模型
  367.     \'\'\'
  368.     #隐藏层
  369.     layer_1 = tf.nn.relu(tf.add(tf.matmul(input_x,weights[\'h1\']),biases[\'h1\']))
  370.     
  371.     
  372.     #代价函数
  373.     y_pred = tf.nn.sigmoid(tf.add(tf.matmul(layer_1, weights[\'h2\']),biases[\'h2\'])) 
  374.     loss = tf.reduce_mean(tf.square(y_pred - input_y)) + lamda * tf.nn.l2_loss(weights[\'h1\'])/ num_samples + tf.nn.l2_loss(weights[\'h2\']) *lamda/ num_samples
  375.     
  376.         
  377.     train = tf.train.AdamOptimizer(learning_rate).minimize(loss)
  378.     
  379.     
  380.     \'\'\'
  381.     开始训练
  382.     \'\'\'
  383.     training_epochs = 30000
  384.     sess = tf.InteractiveSession()
  385.     
  386.     #初始化
  387.     sess.run(tf.global_variables_initializer())
  388.     
  389.     for epoch in range(training_epochs):
  390.         _,lo = sess.run([train,loss],feed_dict={input_x:train_x,input_y:np.reshape(train_y,[-1,1])})
  391.         if epoch % 1000 == 0:
  392.             print(\'Epoch {0}  loss {1}\'.format(epoch,lo))
  393.         
  394.         
  395.     \'\'\'
  396.     数据可视化
  397.     \'\'\'      
  398.     nb_of_xs = 200
  399.     xs1 = np.linspace(-1,8,num = nb_of_xs)
  400.     xs2 = np.linspace(-1,8,num = nb_of_xs)
  401.     
  402.     #创建网格
  403.     xx,yy = np.meshgrid(xs1,xs2)
  404.     
  405.     #初始化和填充 classfication plane
  406.     classfication_plane = np.zeros([nb_of_xs,nb_of_xs])
  407.     
  408.     for i in range(nb_of_xs):
  409.         for j in range(nb_of_xs):
  410.             #计算每个输入样本对应的分类标签
  411.             classfication_plane[i,j] = sess.run(y_pred,feed_dict={input_x:[[xx[i,j],yy[i,j]]]})
  412.             
  413.     #创建 color map用于显示
  414.     cmap = ListedColormap([
  415.                 colorConverter.to_rgba(\'r\',alpha = 0.30),
  416.                 colorConverter.to_rgba(\'b\',alpha = 0.30),      
  417.             ])
  418.     #显示各个样本边界
  419.     plt.contourf(xx,yy,classfication_plane,cmap = cmap)
  420.     plt.show()
  421.     
  422.     
  423.     
  424.     \'\'\'
  425.     测试  可以看到测试集loss值和训练集loss差距较大 这是因为模型过拟合了 
  426.     \'\'\'
  427.     test_x,test_y = generate(12,mean,cov,[[3.0,0.0],[3.0,3.0],[0.0,3.0]],num_classes=4)
  428.     #转换为二种类别
  429.     test_y = test_y % 2      
  432.     
  433.     xr = []
  434.     xb = []
  435.     
  436.     for (l,k) in zip(test_y[:],test_x[:]):
  437.         if l == 0.0:
  438.             xr.append([k[0],k[1]])
  439.         else:
  440.             xb.append([k[0],k[1]])
  441.         
  442.     xr = np.array(xr)
  443.     xb = np.array(xb)
  444.     plt.figure()
  445.     plt.scatter(xr[:,0],xr[:,1],c=\'r\',marker=\'+\')
  446.     plt.scatter(xb[:,0],xb[:,1],c=\'b\',marker=\'o\')
  447.     
  448.     lo = sess.run(loss,feed_dict={input_x:test_x,input_y:np.reshape(test_y,[-1,1])})
  449.     print(\'Test data  loss {0}\'.format(lo))
  450.         
  451.     nb_of_xs = 200
  452.     xs1 = np.linspace(-1,8,num = nb_of_xs)
  453.     xs2 = np.linspace(-1,8,num = nb_of_xs)
  454.     
  455.     #创建网格
  456.     xx,yy = np.meshgrid(xs1,xs2)
  457.     
  458.     #初始化和填充 classfication plane
  459.     classfication_plane = np.zeros([nb_of_xs,nb_of_xs])
  460.     
  461.     for i in range(nb_of_xs):
  462.         for j in range(nb_of_xs):
  463.             #计算每个输入样本对应的分类标签
  464.             classfication_plane[i,j] = sess.run(y_pred,feed_dict={input_x:[[xx[i,j],yy[i,j]]]})
  465.             
  466.     #创建 color map用于显示
  467.     cmap = ListedColormap([
  468.                 colorConverter.to_rgba(\'r\',alpha = 0.30),
  469.                 colorConverter.to_rgba(\'b\',alpha = 0.30),      
  470.             ])
  471.     #显示各个样本边界
  472.     plt.contourf(xx,yy,classfication_plane,cmap = cmap)
  473.     plt.show()
  476. def example_add_trainset():
  477.     \'\'\'
  478.     通过增加训练集解过拟合
  479.     \'\'\'
  480.     
  481.     \'\'\'
  482.     生成随机数据
  483.     \'\'\'
  484.     np.random.seed(10)
  485.     #特征个数
  486.     num_features = 2
  487.     #样本个数
  488.     num_samples = 1000
  489.     #n返回长度为特征的数组 正太分布
  490.     mean = np.random.randn(num_features)
  491.     print(\'mean\',mean)
  492.     cov = np.eye(num_features)
  493.     print(\'cov\',cov)
  494.     
  495.     
  498.     \'\'\'
  499.     定义变量
  500.     \'\'\'
  501.     #学习率
  502.     learning_rate = 1e-4
  503.     #输入层节点个数
  504.     n_input = 2
  505.     #隐藏层节点个数
  506.     n_hidden = 200   #设置为2则会欠拟合
  507.     #输出节点数
  508.     n_label = 1
  510.     
  511.     input_x = tf.placeholder(tf.float32,[None,n_input])
  512.     input_y = tf.placeholder(tf.float32,[None,n_label])
  513.     
  514.     \'\'\'
  515.     定义学习参数
  516.     
  517.     h1 代表隐藏层
  518.     h2 代表输出层
  519.     \'\'\'
  520.     weights = {
  521.             \'h1\':tf.Variable(tf.truncated_normal(shape=[n_input,n_hidden],stddev = 0.01)),     #方差0.1
  522.             \'h2\':tf.Variable(tf.truncated_normal(shape=[n_hidden,n_label],stddev=0.01))
  523.             }
  524.     
  525.     
  526.     biases = {
  527.             \'h1\':tf.Variable(tf.zeros([n_hidden])),    
  528.             \'h2\':tf.Variable(tf.zeros([n_label]))
  529.             }
  530.     
  531.     
  532.     \'\'\'
  533.     定义网络模型
  534.     \'\'\'
  535.     #隐藏层
  536.     layer_1 = tf.nn.relu(tf.add(tf.matmul(input_x,weights[\'h1\']),biases[\'h1\']))
  537.     
  538.     
  539.     #代价函数
  540.     y_pred = tf.nn.sigmoid(tf.add(tf.matmul(layer_1, weights[\'h2\']),biases[\'h2\'])) 
  541.     loss = tf.reduce_mean(tf.square(y_pred - input_y)) 
  542.     
  543.         
  544.     train = tf.train.AdamOptimizer(learning_rate).minimize(loss)
  545.     
  546.     
  547.     \'\'\'
  548.     开始训练
  549.     \'\'\'
  550.     training_epochs = 30000
  551.     sess = tf.InteractiveSession()
  552.     
  553.     #初始化
  554.     sess.run(tf.global_variables_initializer())
  555.     
  556.     for epoch in range(training_epochs):
  557.         train_x,train_y = generate(num_samples,mean,cov,[[3.0,0.0],[3.0,3.0],[0.0,3.0]],num_classes=4)
  558.         #转换为二种类别
  559.         train_y = train_y % 2      
  560.         _,lo = sess.run([train,loss],feed_dict={input_x:train_x,input_y:np.reshape(train_y,[-1,1])})
  561.         if epoch % 1000 == 0:
  562.             print(\'Epoch {0}  loss {1}\'.format(epoch,lo))
  563.         
  564.         
  565.     
  566.     \'\'\'
  567.     测试  可以看到测试集loss值和训练集loss差距较大 这是因为模型过拟合了 
  568.     \'\'\'
  569.     test_x,test_y = generate(12,mean,cov,[[3.0,0.0],[3.0,3.0],[0.0,3.0]],num_classes=4)
  570.     #转换为二种类别
  571.     test_y = test_y % 2      
  574.     
  575.     xr = []
  576.     xb = []
  577.     
  578.     for (l,k) in zip(test_y[:],test_x[:]):
  579.         if l == 0.0:
  580.             xr.append([k[0],k[1]])
  581.         else:
  582.             xb.append([k[0],k[1]])
  583.         
  584.     xr = np.array(xr)
  585.     xb = np.array(xb)
  586.     plt.figure()
  587.     plt.scatter(xr[:,0],xr[:,1],c=\'r\',marker=\'+\')
  588.     plt.scatter(xb[:,0],xb[:,1],c=\'b\',marker=\'o\')
  589.     
  590.     lo = sess.run(loss,feed_dict={input_x:test_x,input_y:np.reshape(test_y,[-1,1])})
  591.     print(\'Test data  loss {0}\'.format(lo))
  592.         
  593.     nb_of_xs = 200
  594.     xs1 = np.linspace(-1,8,num = nb_of_xs)
  595.     xs2 = np.linspace(-1,8,num = nb_of_xs)
  596.     
  597.     #创建网格
  598.     xx,yy = np.meshgrid(xs1,xs2)
  599.     
  600.     #初始化和填充 classfication plane
  601.     classfication_plane = np.zeros([nb_of_xs,nb_of_xs])
  602.     
  603.     for i in range(nb_of_xs):
  604.         for j in range(nb_of_xs):
  605.             #计算每个输入样本对应的分类标签
  606.             classfication_plane[i,j] = sess.run(y_pred,feed_dict={input_x:[[xx[i,j],yy[i,j]]]})
  607.             
  608.     #创建 color map用于显示
  609.     cmap = ListedColormap([
  610.                 colorConverter.to_rgba(\'r\',alpha = 0.30),
  611.                 colorConverter.to_rgba(\'b\',alpha = 0.30),      
  612.             ])
  613.     #显示各个样本边界
  614.     plt.contourf(xx,yy,classfication_plane,cmap = cmap)
  615.     plt.show()
  619. def example_dropout():
  620.     \'\'\'
  621.     使用弃权解过拟合
  622.     \'\'\'
  623.     
  624.     \'\'\'
  625.     生成随机数据
  626.     \'\'\'
  627.     np.random.seed(10)
  628.     #特征个数
  629.     num_features = 2
  630.     #样本个数
  631.     num_samples = 320
  632.     #n返回长度为特征的数组 正太分布
  633.     mean = np.random.randn(num_features)
  634.     print(\'mean\',mean)
  635.     cov = np.eye(num_features)
  636.     print(\'cov\',cov)
  637.     train_x,train_y = generate(num_samples,mean,cov,[[3.0,0.0],[3.0,3.0],[0.0,3.0]],num_classes=4)
  638.     #转换为二种类别
  639.     train_y = train_y % 2      
  642.     
  643.     xr = []
  644.     xb = []
  645.     
  646.     for (l,k) in zip(train_y[:],train_x[:]):
  647.         if l == 0.0:
  648.             xr.append([k[0],k[1]])
  649.         else:
  650.             xb.append([k[0],k[1]])
  651.         
  652.     xr = np.array(xr)
  653.     xb = np.array(xb)
  654.     plt.scatter(xr[:,0],xr[:,1],c=\'r\',marker=\'+\')
  655.     plt.scatter(xb[:,0],xb[:,1],c=\'b\',marker=\'o\')
  657.     
  658.     
  659.     
  660.     \'\'\'
  661.     定义变量
  662.     \'\'\'
  663.     #学习率
  664.     learning_rate = 1e-4
  665.     #输入层节点个数
  666.     n_input = 2
  667.     #隐藏层节点个数
  668.     n_hidden = 200   #设置为2则会欠拟合
  669.     #输出节点数
  670.     n_label = 1
  672.     
  673.     input_x = tf.placeholder(tf.float32,[None,n_input])
  674.     input_y = tf.placeholder(tf.float32,[None,n_label])
  675.     
  676.     \'\'\'
  677.     定义学习参数
  678.     
  679.     h1 代表隐藏层
  680.     h2 代表输出层
  681.     \'\'\'
  682.     weights = {
  683.             \'h1\':tf.Variable(tf.truncated_normal(shape=[n_input,n_hidden],stddev = 0.01)),     #方差0.1
  684.             \'h2\':tf.Variable(tf.truncated_normal(shape=[n_hidden,n_label],stddev=0.01))
  685.             }
  686.     
  687.     
  688.     biases = {
  689.             \'h1\':tf.Variable(tf.zeros([n_hidden])),    
  690.             \'h2\':tf.Variable(tf.zeros([n_label]))
  691.             }
  692.     
  693.     
  694.     \'\'\'
  695.     定义网络模型
  696.     \'\'\'
  697.     #隐藏层
  698.     layer_1 = tf.nn.relu(tf.add(tf.matmul(input_x,weights[\'h1\']),biases[\'h1\']))
  699.     keep_prob = tf.placeholder(dtype=tf.float32)
  700.     layer_1_drop = tf.nn.dropout(layer_1,keep_prob)
  701.     
  702.     #代价函数
  703.     y_pred = tf.nn.sigmoid(tf.add(tf.matmul(layer_1_drop, weights[\'h2\']),biases[\'h2\'])) 
  704.     loss = tf.reduce_mean(tf.square(y_pred - input_y))
  705.     
  706.         
  707.     train = tf.train.AdamOptimizer(learning_rate).minimize(loss)
  708.     
  709.     
  710.     \'\'\'
  711.     开始训练
  712.     \'\'\'
  713.     training_epochs = 30000
  714.     sess = tf.InteractiveSession()
  715.     
  716.     #初始化
  717.     sess.run(tf.global_variables_initializer())
  718.     
  719.     for epoch in range(training_epochs):
  720.         _,lo = sess.run([train,loss],feed_dict={input_x:train_x,input_y:np.reshape(train_y,[-1,1]),keep_prob:0.5})
  721.         if epoch % 1000 == 0:
  722.             print(\'Epoch {0}  loss {1}\'.format(epoch,lo))
  723.         
  724.         
  725.     \'\'\'
  726.     数据可视化
  727.     \'\'\'      
  728.     nb_of_xs = 200
  729.     xs1 = np.linspace(-1,8,num = nb_of_xs)
  730.     xs2 = np.linspace(-1,8,num = nb_of_xs)
  731.     
  732.     #创建网格
  733.     xx,yy = np.meshgrid(xs1,xs2)
  734.     
  735.     #初始化和填充 classfication plane
  736.     classfication_plane = np.zeros([nb_of_xs,nb_of_xs])
  737.     
  738.     for i in range(nb_of_xs):
  739.         for j in range(nb_of_xs):
  740.             #计算每个输入样本对应的分类标签
  741.             classfication_plane[i,j] = sess.run(y_pred,feed_dict={input_x:[[xx[i,j],yy[i,j]]],keep_prob:1.0})
  742.             
  743.     #创建 color map用于显示
  744.     cmap = ListedColormap([
  745.                 colorConverter.to_rgba(\'r\',alpha = 0.30),
  746.                 colorConverter.to_rgba(\'b\',alpha = 0.30),      
  747.             ])
  748.     #显示各个样本边界
  749.     plt.contourf(xx,yy,classfication_plane,cmap = cmap)
  750.     plt.show()
  751.     
  752.     
  753.     
  754.     \'\'\'
  755.     测试  可以看到测试集loss值和训练集loss差距较大 这是因为模型过拟合了 
  756.     \'\'\'
  757.     test_x,test_y = generate(12,mean,cov,[[3.0,0.0],[3.0,3.0],[0.0,3.0]],num_classes=4)
  758.     #转换为二种类别
  759.     test_y = test_y % 2      
  762.     
  763.     xr = []
  764.     xb = []
  765.     
  766.     for (l,k) in zip(test_y[:],test_x[:]):
  767.         if l == 0.0:
  768.             xr.append([k[0],k[1]])
  769.         else:
  770.             xb.append([k[0],k[1]])
  771.         
  772.     xr = np.array(xr)
  773.     xb = np.array(xb)
  774.     plt.figure()
  775.     plt.scatter(xr[:,0],xr[:,1],c=\'r\',marker=\'+\')
  776.     plt.scatter(xb[:,0],xb[:,1],c=\'b\',marker=\'o\')
  777.     
  778.     lo = sess.run(loss,feed_dict={input_x:test_x,input_y:np.reshape(test_y,[-1,1]),keep_prob:1.0})
  779.     print(\'Test data  loss {0}\'.format(lo))
  780.         
  781.     nb_of_xs = 200
  782.     xs1 = np.linspace(-1,8,num = nb_of_xs)
  783.     xs2 = np.linspace(-1,8,num = nb_of_xs)
  784.     
  785.     #创建网格
  786.     xx,yy = np.meshgrid(xs1,xs2)
  787.     
  788.     #初始化和填充 classfication plane
  789.     classfication_plane = np.zeros([nb_of_xs,nb_of_xs])
  790.     
  791.     for i in range(nb_of_xs):
  792.         for j in range(nb_of_xs):
  793.             #计算每个输入样本对应的分类标签
  794.             classfication_plane[i,j] = sess.run(y_pred,feed_dict={input_x:[[xx[i,j],yy[i,j]]],keep_prob:1.0})
  795.             
  796.     #创建 color map用于显示
  797.     cmap = ListedColormap([
  798.                 colorConverter.to_rgba(\'r\',alpha = 0.30),
  799.                 colorConverter.to_rgba(\'b\',alpha = 0.30),      
  800.             ])
  801.     #显示各个样本边界
  802.     plt.contourf(xx,yy,classfication_plane,cmap = cmap)
  803.     plt.show()
  806. def example_dropout_learningrate_decay():
  807.     \'\'\'
  808.     使用弃权解过拟合 并使用退化学习率进行加速学习
  809.     \'\'\'
  810.     
  811.     \'\'\'
  812.     生成随机数据
  813.     \'\'\'
  814.     np.random.seed(10)
  815.     #特征个数
  816.     num_features = 2
  817.     #样本个数
  818.     num_samples = 320
  819.     #n返回长度为特征的数组 正太分布
  820.     mean = np.random.randn(num_features)
  821.     print(\'mean\',mean)
  822.     cov = np.eye(num_features)
  823.     print(\'cov\',cov)
  824.     train_x,train_y = generate(num_samples,mean,cov,[[3.0,0.0],[3.0,3.0],[0.0,3.0]],num_classes=4)
  825.     #转换为二种类别
  826.     train_y = train_y % 2      
  829.     
  830.     xr = []
  831.     xb = []
  832.     
  833.     for (l,k) in zip(train_y[:],train_x[:]):
  834.         if l == 0.0:
  835.             xr.append([k[0],k[1]])
  836.         else:
  837.             xb.append([k[0],k[1]])
  838.         
  839.     xr = np.array(xr)
  840.     xb = np.array(xb)
  841.     plt.scatter(xr[:,0],xr[:,1],c=\'r\',marker=\'+\')
  842.     plt.scatter(xb[:,0],xb[:,1],c=\'b\',marker=\'o\')
  844.     
  845.     
  846.     
  847.     \'\'\'
  848.     定义变量
  849.     \'\'\'
  850.     #学习率
  851.     learning_rate = 1e-4
  852.     #输入层节点个数
  853.     n_input = 2
  854.     #隐藏层节点个数
  855.     n_hidden = 200   #设置为2则会欠拟合
  856.     #输出节点数
  857.     n_label = 1
  859.     
  860.     input_x = tf.placeholder(tf.float32,[None,n_input])
  861.     input_y = tf.placeholder(tf.float32,[None,n_label])
  862.     
  863.     \'\'\'
  864.     定义学习参数
  865.     
  866.     h1 代表隐藏层
  867.     h2 代表输出层
  868.     \'\'\'
  869.     weights = {
  870.             \'h1\':tf.Variable(tf.truncated_normal(shape=[n_input,n_hidden],stddev = 0.01)),     #方差0.1
  871.             \'h2\':tf.Variable(tf.truncated_normal(shape=[n_hidden,n_label],stddev=0.01))
  872.             }
  873.     
  874.     
  875.     biases = {
  876.             \'h1\':tf.Variable(tf.zeros([n_hidden])),    
  877.             \'h2\':tf.Variable(tf.zeros([n_label]))
  878.             }
  879.     
  880.     
  881.     \'\'\'
  882.     定义网络模型
  883.     \'\'\'
  884.     #隐藏层
  885.     layer_1 = tf.nn.relu(tf.add(tf.matmul(input_x,weights[\'h1\']),biases[\'h1\']))
  886.     keep_prob = tf.placeholder(dtype=tf.float32)
  887.     layer_1_drop = tf.nn.dropout(layer_1,keep_prob)
  888.     
  889.     #代价函数
  890.     y_pred = tf.nn.sigmoid(tf.add(tf.matmul(layer_1_drop, weights[\'h2\']),biases[\'h2\'])) 
  891.     loss = tf.reduce_mean(tf.square(y_pred - input_y))
  892.     
  893.         
  894.     global_step = tf.Variable(0,trainable=False)
  895.     decaylearning_rate = tf.train.exponential_decay(learning_rate,global_step,1000,0.9)
  896.     train = tf.train.AdamOptimizer(decaylearning_rate).minimize(loss,global_step = global_step)
  898.     
  899.     \'\'\'
  900.     开始训练
  901.     \'\'\'
  902.     training_epochs = 30000
  903.     sess = tf.InteractiveSession()
  904.     
  905.     #初始化
  906.     sess.run(tf.global_variables_initializer())
  907.     
  908.     for epoch in range(training_epochs):        
  909.         #执行一次train global_step变量会自加1
  910.         rate,_,lo = sess.run([decaylearning_rate,train,loss],feed_dict={input_x:train_x,input_y:np.reshape(train_y,[-1,1]),keep_prob:0.5})
  911.         if epoch % 1000 == 0:
  912.             print(\'Epoch {0}   learning_rate  {1} loss {2} \'.format(epoch,rate,lo))
  913.         
  914.         
  915.     \'\'\'
  916.     数据可视化
  917.     \'\'\'      
  918.     nb_of_xs = 200
  919.     xs1 = np.linspace(-1,8,num = nb_of_xs)
  920.     xs2 = np.linspace(-1,8,num = nb_of_xs)
  921.     
  922.     #创建网格
  923.     xx,yy = np.meshgrid(xs1,xs2)
  924.     
  925.     #初始化和填充 classfication plane
  926.     classfication_plane = np.zeros([nb_of_xs,nb_of_xs])
  927.     
  928.     for i in range(nb_of_xs):
  929.         for j in range(nb_of_xs):
  930.             #计算每个输入样本对应的分类标签
  931.             classfication_plane[i,j] = sess.run(y_pred,feed_dict={input_x:[[xx[i,j],yy[i,j]]],keep_prob:1.0})
  932.             
  933.     #创建 color map用于显示
  934.     cmap = ListedColormap([
  935.                 colorConverter.to_rgba(\'r\',alpha = 0.30),
  936.                 colorConverter.to_rgba(\'b\',alpha = 0.30),      
  937.             ])
  938.     #显示各个样本边界
  939.     plt.contourf(xx,yy,classfication_plane,cmap = cmap)
  940.     plt.show()
  941.     
  942.     
  943.     
  944.     \'\'\'
  945.     测试  可以看到测试集loss值和训练集loss差距较大 这是因为模型过拟合了 
  946.     \'\'\'
  947.     test_x,test_y = generate(12,mean,cov,[[3.0,0.0],[3.0,3.0],[0.0,3.0]],num_classes=4)
  948.     #转换为二种类别
  949.     test_y = test_y % 2      
  952.     
  953.     xr = []
  954.     xb = []
  955.     
  956.     for (l,k) in zip(test_y[:],test_x[:]):
  957.         if l == 0.0:
  958.             xr.append([k[0],k[1]])
  959.         else:
  960.             xb.append([k[0],k[1]])
  961.         
  962.     xr = np.array(xr)
  963.     xb = np.array(xb)
  964.     plt.figure()
  965.     plt.scatter(xr[:,0],xr[:,1],c=\'r\',marker=\'+\')
  966.     plt.scatter(xb[:,0],xb[:,1],c=\'b\',marker=\'o\')
  967.     
  968.     lo = sess.run(loss,feed_dict={input_x:test_x,input_y:np.reshape(test_y,[-1,1]),keep_prob:1.0})
  969.     print(\'Test data  loss {0}\'.format(lo))
  970.         
  971.     nb_of_xs = 200
  972.     xs1 = np.linspace(-1,8,num = nb_of_xs)
  973.     xs2 = np.linspace(-1,8,num = nb_of_xs)
  974.     
  975.     #创建网格
  976.     xx,yy = np.meshgrid(xs1,xs2)
  977.     
  978.     #初始化和填充 classfication plane
  979.     classfication_plane = np.zeros([nb_of_xs,nb_of_xs])
  980.     
  981.     for i in range(nb_of_xs):
  982.         for j in range(nb_of_xs):
  983.             #计算每个输入样本对应的分类标签
  984.             classfication_plane[i,j] = sess.run(y_pred,feed_dict={input_x:[[xx[i,j],yy[i,j]]],keep_prob:1.0})
  985.             
  986.     #创建 color map用于显示
  987.     cmap = ListedColormap([
  988.                 colorConverter.to_rgba(\'r\',alpha = 0.30),
  989.                 colorConverter.to_rgba(\'b\',alpha = 0.30),      
  990.             ])
  991.     #显示各个样本边界
  992.     plt.contourf(xx,yy,classfication_plane,cmap = cmap)
  993.     plt.show()
  996. if __name__== \'__main__\':
  997.     #example_overfit()
  998.     #example_l2_norm()
  999.     #example_add_trainset()
  1000.     #example_dropout()
  1001.     example_dropout_learningrate_decay()

View Code

版权声明：本文为zyly原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/zyly/p/8952384.html