您的位置:新葡亰496net > 奥门新萄京娱乐场 > tensorflow入门之训练简单的神经网络方法,Tensor

tensorflow入门之训练简单的神经网络方法,Tensor

发布时间:2019-06-18 12:50编辑:奥门新萄京娱乐场浏览(96)

    在机器学习中可能会存在过拟合的问题,表现为在训练集上表现很好,但在测试集中表现不如训练集中的那么好。

    1. 简单线性回归

       import tensorflow as tf
       import numpy 
      
       # 创造数据
       x_data = numpy.random.rand(100).astype(numpy.float32)
       y_data = x_data*0.1   0.3
      
       print(x_data,y_data)
      
       Weights = tf.Variable(tf.random_uniform([1],-1.0,1))
       biases = tf.Variable(tf.zeros([1]))
       y = Weights*x_data biases
      
       loss = tf.reduce_mean(tf.square(y-y_data))
      
       optimizer = tf.train.GradientDescentOptimizer(0.5)
       train = optimizer.minimize(loss)
       init = tf.global_variables_initializer()
      
       sess = tf.Session()
       sess.run(init)
       for step in range(201):
           sess.run(train)
           if step  == 0:
               print(step,sess.run(Weights),sess.run(biases))
      
    2. 矩阵相乘,和Session()的两种使用方法

       import tensorflow as tf
      
       #创建两个矩阵
       matrix1 = tf.constant([[3,3]])
       matrix2 = tf.constant([[2],[2]])
       product = tf.matmul(matrix1,matrix2)
       #到此都是在准备计算关系,并没有实际计算
      
       #启动session并计算的第一种形式
       sess = tf.Session()
       result = sess.run(product)
       print(result)
       sess.close()
      
       #启动session并计算的第二种方法
       with tf.Session() as sess:
           result = sess.run(product)
           print(result)
      
    3. 变量定义,常量定义,步骤定义,操作定义 ,Session 本身对状态保存的特性

       # Tensorflow中必须定义变量,添加到构建的流图中  基本语法  state = tensorflow.Variable()  
      
       import tensorflow as tf
       #定义变量
       state = tf.Variable(0, name='counter')
       #定义常量
       one = tf.constant(1)
       #定义步骤
       new_value = tf.add(state,one)
       #定义赋值操作
       update = tf.assign(state, new_value)
      
       #定义变量以后初始化变量就是必须的
       init = tf.global_variables_initializer()
      
       #启动Session
       with tf.Session() as sess:
           sess.run(init)
           for _ in range(3):
               sess.run(update)
               print(sess.run(state))
      
    4. placeholder

       #placeholder 有时候会出现一些量我们不想在,定义流图阶段就把这些量写成常量,而是想计算的时候再输入。此时就要用到placeholder,定义流图的时候占位
       import tensorflow as tf
       #在 Tensorflow 中需要定义 placeholder 的 type ,一般为 float32 形式
       input1 = tf.placeholder(tf.float32)
       input2 = tf.placeholder(tf.float32)
      
       # mul = multiply 是将input1和input2 做乘法运算,并输出为 output 
       ouput = tf.multiply(input1, input2)
       with tf.Session() as sess:
           print(sess.run(ouput, feed_dict={input1: [7.], input2: [2.]}))
      
    5. 激励函数 (Activation Function),人工智能领域为了适应复杂多变的现实世界专门找到的一些形状奇特的函数。特点或是要求:1.必须是非线性函数,因为要适应非线性问题。2.必须是可微分的,backpropagation误差反向传递要使用到可微分特性。

    6. 添加层函数

       # 神经网络层的构建
       import tensorflow as tf
      
       #定义添加层的操作,新版的TensorFlow库中自带层不用手动怼
       def add_layer(inputs, in_size, out_size, activation_function = None):
           Weights = tf.Variable(tf.random_normal([in_size, out_size]))
           biases = tf.Variable(tf.zeros(1,out_size)) 0.1
           Wx_plus_b = tf.matmul(inputs, Weights) biases
           if activation_function is None:
               outputs = Wx_plus_b
           else:
               outputs = activation_function(Wx_plus_b)
           return outputs
      
    7. 数据可视化

       #结果可视化, 数据转换成图像
       # 1. matplotlib 
       import tensorflow as tf
       import numpy as np
       import matplotlib.pyplot as plt
      
       x_data = np.linspace(-1,1,300, dtype=np.float32)[:,np.newaxis]
       noise = np.random.normal(0,0.05,x_data.shape).astype(np.float32)
       y_data = np.square(x_data) - 0.5  noise
      
       plt.figure(1, figsize=(8, 6))
      
       plt.subplot(111)
       plt.plot(x_data, y_data, c='red', label='relu')
       plt.ylim((-1, 5))
       plt.legend(loc='best')
      
       plt.show()
      

      动画过程

        # 神经网络建造,训练过程
       import tensorflow as tf
       import numpy as np
       import matplotlib.pyplot as plt
      
       def add_layer(inputs, in_size, out_size, activation_function=None):
           Weights = tf.Variable(tf.random_normal([in_size, out_size]))
           biases = tf.Variable(tf.zeros([1, out_size])   0.1)
           Wx_plus_b = tf.matmul(inputs, Weights)   biases
           if activation_function is None:
               outputs = Wx_plus_b
           else:
               outputs = activation_function(Wx_plus_b)
           return outputs
      
       x_data = np.linspace(-1,1,300, dtype=np.float32)[:,np.newaxis]
       noise = np.random.normal(0,0.05,x_data.shape).astype(np.float32)
       y_data = np.square(x_data) - 0.5  noise
      
       xs = tf.placeholder(tf.float32,[None,1])
       ys = tf.placeholder(tf.float32,[None,1])
      
       #开始搭建神经网络
       #1个输入,10个输出 激励函数为tf.nn.relu
       l1 = add_layer(xs,1,10,activation_function=tf.nn.relu)
       #输出层定义
       prediction = add_layer(l1,10,1,activation_function=None)
       #误差计算 二者差的平方求和再取平均
       loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys-prediction),reduction_indices=[1]))
       #学习效率参数 学习效率 0-1
       train_step = tf.train.GradientDescentOptimizer(0.1).minimize(loss)
      
       #初始化变量
       init = tf.global_variables_initializer()
      
       #准备显示数据
       fig = plt.figure()
       ax = fig.add_subplot(1,1,1)
       ax.scatter(x_data, y_data)
       plt.ion()
       plt.show()
      
       #启动Session 开始训练
       with tf.Session() as sess:
           sess.run(init)
           for i in range(1000):
               sess.run(train_step,feed_dict={xs:x_data,ys:y_data})
               #每过50步输出状态
               if iP == 0 :
                   # to visualize the result and improvement
                   try:
                       ax.lines.remove(lines[0])
                   except Exception:
                       pass
                   prediction_value = sess.run(prediction, feed_dict={xs: x_data})
                   # plot the prediction
                   lines = ax.plot(x_data, prediction_value, 'r-', lw=5)
                   plt.pause(0.1)
      
    8. 加速神经网络训练 包括以下几种模式:

      1. Stochastic Gradient Descent (SGD)
      2. Momentum
      3. AdaGrad
      4. RMSProp
      5. Adam
    9. 计算可视化(tensorboard)

       # TensorFlow 中自带一个流图可视化工具tensorboard 可以用图的方式显示定义的流图
       # 神经网络建造,训练过程
       import tensorflow as tf
       import numpy as np
       import matplotlib.pyplot as plt
      
       def add_layer(inputs, in_size, out_size, activation_function=None):
           #都放到命名空间内
           with tf.name_scope('layer'):
               with tf.name_scope('weights'):
                   Weights = tf.Variable(
                   tf.random_normal([in_size, out_size]), 
                   name='W')
               with tf.name_scope('biases'):
                   biases = tf.Variable(
                   tf.zeros([1, out_size])   0.1, 
                   name='b')
               with tf.name_scope('Wx_plus_b'):
                   Wx_plus_b = tf.add(
                   tf.matmul(inputs, Weights), 
                   biases)
               if activation_function is None:
                   outputs = Wx_plus_b
               else:
                   outputs = activation_function(Wx_plus_b, )
               return outputs
      
       x_data = np.linspace(-1,1,300, dtype=np.float32)[:,np.newaxis]
       noise = np.random.normal(0,0.05,x_data.shape).astype(np.float32)
       y_data = np.square(x_data) - 0.5  noise
      
       #图结构分层 把两个placeholder放在一个方框中
       with tf.name_scope('inputs'):
           #站位名称给定 以前没有name参数
           xs= tf.placeholder(tf.float32, [None, 1],name='x_in') 
           ys= tf.placeholder(tf.float32, [None, 1],name='y_in')
      
       #开始搭建神经网络
       #1个输入,10个输出 激励函数为tf.nn.relu
       l1 = add_layer(xs,1,10,activation_function=tf.nn.relu)
       #输出层定义
       prediction = add_layer(l1,10,1,activation_function=None)
      
       with tf.name_scope('loss'):
           #误差计算 二者差的平方求和再取平均
           loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys-prediction),reduction_indices=[1]))
      
       with tf.name_scope('train'):
           #学习效率参数 学习效率 0-1
           train_step = tf.train.GradientDescentOptimizer(0.1).minimize(loss)
      
       #初始化变量
       init = tf.global_variables_initializer()
      
       #准备显示数据
       fig = plt.figure()
       ax = fig.add_subplot(1,1,1)
       ax.scatter(x_data, y_data)
       plt.ion()
       plt.show()
      
       #启动Session 开始训练
       with tf.Session() as sess:
           sess.run(init)
           #手动建立logs文件夹,运行后没有错误 再执行tensorboard --logdir logs
           writer = tf.summary.FileWriter("logs/", sess.graph)
           for i in range(1000):
               sess.run(train_step,feed_dict={xs:x_data,ys:y_data})
               #每过50步输出状态
               if iP == 0 :
                   # to visualize the result and improvement
                   try:
                       ax.lines.remove(lines[0])
                   except Exception:
                       pass
                   prediction_value = sess.run(prediction, feed_dict={xs: x_data})
                   # plot the prediction
                   lines = ax.plot(x_data, prediction_value, 'r-', lw=5)
                   plt.pause(0.1)
      
    10. 训练可视化,在计算结构中记录变量tf.summary.histogram(layer_name '/weights',Weights)记录标量tf.summary.scalar('loss', loss)。Seesion初始化以后merged = tf.summary.merge_all()相当于初始化,通过rs = sess.run(merged,feed_dict={xs:x_data,ys:y_data}),writer.add_summary(rs, i)进行步进记录

      # TensorFlow 中自带一个流图可视化工具tensorboard 可以用图的方式显示定义的流图
      # 神经网络建造,训练过程
      import tensorflow as tf
      import numpy as np
      import matplotlib.pyplot as plt
      
      def add_layer(inputs, in_size, out_size,layer_n, activation_function=None):
          #都放到命名空间内
          layer_name = 'layer%s'%layer_n
          with tf.name_scope('layer'):
              with tf.name_scope('weights'):
                  Weights = tf.Variable(
                  tf.random_normal([in_size, out_size]), 
                  name='W')
              with tf.name_scope('biases'):
                  biases = tf.Variable(
                  tf.zeros([1, out_size])   0.1, 
                  name='b')
              with tf.name_scope('Wx_plus_b'):
                  Wx_plus_b = tf.add(
                  tf.matmul(inputs, Weights), 
                  biases)
              if activation_function is None:
                  outputs = Wx_plus_b
              else:
                  outputs = activation_function(Wx_plus_b, )
              #添加分析数据
              tf.summary.histogram(layer_name '/weights',Weights)
              tf.summary.histogram(layer_name '/biase',biases)
              tf.summary.histogram(layer_name '/outputs',outputs)
              return outputs
      
      x_data = np.linspace(-1,1,300, dtype=np.float32)[:,np.newaxis]
      noise = np.random.normal(0,0.05,x_data.shape).astype(np.float32)
      y_data = np.square(x_data) - 0.5  noise
      
      #图结构分层 把两个placeholder放在一个方框中
      with tf.name_scope('inputs'):
          #站位名称给定 以前没有name参数
          xs= tf.placeholder(tf.float32, [None, 1],name='x_in') 
          ys= tf.placeholder(tf.float32, [None, 1],name='y_in')
      
      #开始搭建神经网络
      #1个输入,10个输出 激励函数为tf.nn.relu
      l1 = add_layer(xs,1,10,1,activation_function=tf.nn.relu)
      #输出层定义
      prediction = add_layer(l1,10,1,2,activation_function=None)
      
      with tf.name_scope('loss'):
          #误差计算 二者差的平方求和再取平均
          loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys-prediction),reduction_indices=[1]))
          #添加分析数据
          tf.summary.scalar('loss', loss)
      
      with tf.name_scope('train'):
          #学习效率参数 学习效率 0-1
          train_step = tf.train.GradientDescentOptimizer(0.1).minimize(loss)
      
      #初始化变量
      init = tf.global_variables_initializer()
      
      #准备显示数据
      fig = plt.figure()
      ax = fig.add_subplot(1,1,1)
      ax.scatter(x_data, y_data)
      plt.ion()
      plt.show()
      
      #启动Session 开始训练
      with tf.Session() as sess:
          sess.run(init)
          #数据分析初始化
          merged = tf.summary.merge_all()
          #手动建立logs文件夹,运行后没有错误 再执行tensorboard --logdir logs
          writer = tf.summary.FileWriter("logs/", sess.graph)
          for i in range(1000):
              sess.run(train_step,feed_dict={xs:x_data,ys:y_data})
              #每过50步输出状态
              if iP == 0 :
                  #图标统计
                  rs = sess.run(merged,feed_dict={xs:x_data,ys:y_data})
                  writer.add_summary(rs, i)
                  # to visualize the result and improvement
                  try:
                      ax.lines.remove(lines[0])
                  except Exception:
                      pass
                  prediction_value = sess.run(prediction, feed_dict={xs: x_data})
                  # plot the prediction
                  lines = ax.plot(x_data, prediction_value, 'r-', lw=5)
                  plt.pause(0.1)
      
    11. 分类器:利用MNIST数据实现测试分类器,程序中主要新的学习点有1. MNIST数据使用。2.优化目标函数中的交叉熵函数 3. 训练方法采用梯度下降法

      import tensorflow as tf
      
      def add_layer(inputs, in_size, out_size,layer_n, activation_function=None):
          #都放到命名空间内
          layer_name = 'layer%s'%layer_n
          with tf.name_scope('layer'):
              with tf.name_scope('weights'):
                  Weights = tf.Variable(
                  tf.random_normal([in_size, out_size]), 
                  name='W')
              with tf.name_scope('biases'):
                  biases = tf.Variable(
                  tf.zeros([1, out_size])   0.1, 
                  name='b')
              with tf.name_scope('Wx_plus_b'):
                  Wx_plus_b = tf.add(
                  tf.matmul(inputs, Weights), 
                  biases)
              if activation_function is None:
                  outputs = Wx_plus_b
              else:
                  outputs = activation_function(Wx_plus_b, )
              #添加分析数据
              tf.summary.histogram(layer_name '/weights',Weights)
              tf.summary.histogram(layer_name '/biase',biases)
              tf.summary.histogram(layer_name '/outputs',outputs)
              return outputs
      
      def compute_accuracy(v_xs, v_ys):
          global prediction
          y_pre = sess.run(prediction, feed_dict={xs: v_xs})
          correct_prediction = tf.equal(tf.argmax(y_pre,1), tf.argmax(v_ys,1))
          accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
          result = sess.run(accuracy, feed_dict={xs: v_xs, ys: v_ys})
          return result
      
      from tensorflow.examples.tutorials.mnist import input_data
      mnist = input_data.read_data_sets('MNIST_data',one_hot = True)
      
      xs = tf.placeholder(tf.float32,[None,784])
      ys = tf.placeholder(tf.float32,[None,10])
      
      prediction = add_layer(xs,784,10,1,activation_function=tf.nn.softmax)
      
      #loss函数(即最优化目标函数)选用交叉熵函数。交叉熵用来衡量预测值和真实值的相似程度,如果完全相同,它们的交叉熵等于零
      cross_entropy = tf.reduce_mean(-tf.reduce_sum(ys*tf.log(prediction),reduction_indices=[1]))
      #train方法(最优化算法)采用梯度下降法。
      train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)
      
      with tf.Session() as sess:
          sess.run(tf.global_variables_initializer())
          for i in range(1000):
              batch_xs,batch_ys = mnist.train.next_batch(100)
              sess.run(train_step,feed_dict={xs:batch_xs,ys:batch_ys})
              if iP == 0:
                  print(compute_accuracy(mnist.test.images, mnist.test.labels))
      
    12. 过度拟合(Overfitting),过度学习。在处理现实问题的时候,数据来源是不可控的。总会出现对机器学习神经网络不利的数据,来源主要可以分为,测量误差,文化背景,外界干扰。总结起来就是机器学习的神经网络自设计之初就处理不了的数据。对于由于过度拟合人们找到了优化神经网络的思路。

      1. 增加数据量,机器学习的结果来源于数据的思想。数据量大了,有一个半个的异常数据也就不算什么了,或是出现对立的数来平衡(小概率数据)。没有提高神经网络的质量。
      2. 正规化。
        1.修改误差计算函数,使得神经网络得到不同程度的反馈。原始的 cost 误差是这样计算, cost = 预测值-真实值的平方。如果 W 变得太大, 我们就让 cost 也跟着变大, 变成一种惩罚机制. 所以我们把 W 自己考虑进来. 这里 abs 是绝对值. 这一种形式的 正规化, 叫做 l1 正规化. L2 正规化和 l1 类似, 只是绝对值换成了平方. 其他的l3, l4 也都是换成了立方和4次方等等. 形式类似. 用这些方法,我们就能保证让学出来的线条不会过于扭曲.(引用https://morvanzhou.github.io/tutorials/machine-learning/tensorflow/5-02-A-overfitting/)
        1. dropout。一种专门用在神经网络的正规化的方法。Dropout 的做法是从根本上让神经网络没机会过度依赖.信息存在网络中而不是关键节点。
    13. overfitting和dropout 效果对比,dropout 对于不重复的数据很有效但是如果数据有限,过度训练的情况下效果会反弹。

      import tensorflow as tf
      import numpy as np
      import matplotlib.pyplot as plt
      
      tf.set_random_seed(1)
      np.random.seed(1)
      
      # Hyper parameters
      N_SAMPLES = 20
      N_HIDDEN = 300
      LR = 0.01
      
      # training data
      x = np.linspace(-1, 1, N_SAMPLES)[:, np.newaxis]
      y = x   0.3*np.random.randn(N_SAMPLES)[:, np.newaxis]
      
      # test data
      test_x = x.copy()
      test_y = test_x   0.3*np.random.randn(N_SAMPLES)[:, np.newaxis]
      
      # show data
      plt.scatter(x, y, c='magenta', s=50, alpha=0.5, label='train')
      plt.scatter(test_x, test_y, c='cyan', s=50, alpha=0.5, label='test')
      plt.legend(loc='upper left')
      plt.ylim((-2.5, 2.5))
      plt.show()
      
      # tf placeholders
      tf_x = tf.placeholder(tf.float32, [None, 1])
      tf_y = tf.placeholder(tf.float32, [None, 1])
      tf_is_training = tf.placeholder(tf.bool, None)  # to control dropout when training and testing
      
      # overfitting net
      o1 = tf.layers.dense(tf_x, N_HIDDEN, tf.nn.relu)
      o2 = tf.layers.dense(o1, N_HIDDEN, tf.nn.relu)
      o_out = tf.layers.dense(o2, 1)
      o_loss = tf.losses.mean_squared_error(tf_y, o_out)
      o_train = tf.train.AdamOptimizer(LR).minimize(o_loss)
      
      # dropout net
      d1 = tf.layers.dense(tf_x, N_HIDDEN, tf.nn.relu)
      d1 = tf.layers.dropout(d1, rate=0.5, training=tf_is_training)   # drop out 50% of inputs
      d2 = tf.layers.dense(d1, N_HIDDEN, tf.nn.relu)
      d2 = tf.layers.dropout(d2, rate=0.5, training=tf_is_training)   # drop out 50% of inputs
      d_out = tf.layers.dense(d2, 1)
      d_loss = tf.losses.mean_squared_error(tf_y, d_out)
      d_train = tf.train.AdamOptimizer(LR).minimize(d_loss)
      
      sess = tf.Session()
      sess.run(tf.global_variables_initializer())
      
      plt.ion()   # something about plotting
      
      for t in range(5000):
          sess.run([o_train, d_train], {tf_x: x, tf_y: y, tf_is_training: True})  # train, set is_training=True
      
          if t % 50 == 0:
              # plotting
              plt.cla()
              o_loss_, d_loss_, o_out_, d_out_ = sess.run(
                  [o_loss, d_loss, o_out, d_out], {tf_x: test_x, tf_y: test_y, tf_is_training: False} # test, set is_training=False
              )
              plt.scatter(x, y, c='magenta', s=50, alpha=0.3, label='train'); 
              plt.scatter(test_x, test_y, c='cyan', s=50, alpha=0.3, label='test')
              plt.plot(test_x, o_out_, 'r-', lw=3, label='overfitting'); 
              plt.plot(test_x, d_out_, 'b--', lw=3, label='dropout(50%)')
              plt.text(0, -1.2, 'overfitting loss=%.4f' % o_loss_, fontdict={'size': 20, 'color':  'red'}); 
              plt.text(0, -1.5, 'dropout loss=%.4f' % d_loss_, fontdict={'size': 20, 'color': 'blue'})
              plt.legend(loc='upper left'); 
              plt.ylim((-2.5, 2.5)); 
              plt.pause(0.1)
      
      plt.ioff()
      plt.show()
      
    14. 卷积神经网络,非常消耗计算资源,pc机器已经显得慢了。参考:https://morvanzhou.github.io/tutorials/machine-learning/tensorflow/5-03-A-CNN/

      import tensorflow as tf
      from tensorflow.examples.tutorials.mnist import input_data
      import numpy as np
      import matplotlib.pyplot as plt
      
      tf.set_random_seed(1)
      np.random.seed(1)
      
      BATCH_SIZE = 50
      LR = 0.001              # learning rate
      
      mnist = input_data.read_data_sets('./mnist', one_hot=True)  # they has been normalized to range (0,1)
      test_x = mnist.test.images[:2000]
      test_y = mnist.test.labels[:2000]
      
      # plot one example
      print(mnist.train.images.shape)     # (55000, 28 * 28)
      print(mnist.train.labels.shape)   # (55000, 10)
      plt.imshow(mnist.train.images[0].reshape((28, 28)), cmap='gray')
      plt.title('%i' % np.argmax(mnist.train.labels[0])); plt.show()
      
      tf_x = tf.placeholder(tf.float32, [None, 28*28]) / 255.
      image = tf.reshape(tf_x, [-1, 28, 28, 1])              # (batch, height, width, channel)
      tf_y = tf.placeholder(tf.int32, [None, 10])            # input y
      
      # CNN
      conv1 = tf.layers.conv2d(   # shape (28, 28, 1)
          inputs=image,
          filters=16,
          kernel_size=5,
          strides=1,
          padding='same',
          activation=tf.nn.relu
      )           # -> (28, 28, 16)
      pool1 = tf.layers.max_pooling2d(
          conv1,
          pool_size=2,
          strides=2,
      )           # -> (14, 14, 16)
      conv2 = tf.layers.conv2d(pool1, 32, 5, 1, 'same', activation=tf.nn.relu)    # -> (14, 14, 32)
      pool2 = tf.layers.max_pooling2d(conv2, 2, 2)    # -> (7, 7, 32)
      flat = tf.reshape(pool2, [-1, 7*7*32])          # -> (7*7*32, )
      output = tf.layers.dense(flat, 10)              # output layer
      
      loss = tf.losses.softmax_cross_entropy(onehot_labels=tf_y, logits=output)           # compute cost
      train_op = tf.train.AdamOptimizer(LR).minimize(loss)
      
      accuracy = tf.metrics.accuracy(          # return (acc, update_op), and create 2 local variables
          labels=tf.argmax(tf_y, axis=1), predictions=tf.argmax(output, axis=1),)[1]
      
      sess = tf.Session()
      init_op = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer()) # the local var is for accuracy_op
      sess.run(init_op)     # initialize var in graph
      
      # following function (plot_with_labels) is for visualization, can be ignored if not interested
      from matplotlib import cm
      try: from sklearn.manifold import TSNE; HAS_SK = True
      except: HAS_SK = False; print('nPlease install sklearn for layer visualizationn')
      def plot_with_labels(lowDWeights, labels):
          plt.cla(); X, Y = lowDWeights[:, 0], lowDWeights[:, 1]
          for x, y, s in zip(X, Y, labels):
              c = cm.rainbow(int(255 * s / 9)); plt.text(x, y, s, backgroundcolor=c, fontsize=9)
          plt.xlim(X.min(), X.max()); plt.ylim(Y.min(), Y.max()); plt.title('Visualize last layer'); plt.show(); plt.pause(0.01)
      
      plt.ion()
      for step in range(600):
          b_x, b_y = mnist.train.next_batch(BATCH_SIZE)
          _, loss_ = sess.run([train_op, loss], {tf_x: b_x, tf_y: b_y})
          if step % 50 == 0:
              accuracy_, flat_representation = sess.run([accuracy, flat], {tf_x: test_x, tf_y: test_y})
              print('Step:', step, '| train loss: %.4f' % loss_, '| test accuracy: %.2f' % accuracy_)
      
              if HAS_SK:
                  # Visualization of trained flatten layer (T-SNE)
                  tsne = TSNE(perplexity=30, n_components=2, init='pca', n_iter=5000); plot_only = 500
                  low_dim_embs = tsne.fit_transform(flat_representation[:plot_only, :])
                  labels = np.argmax(test_y, axis=1)[:plot_only]; plot_with_labels(low_dim_embs, labels)
      plt.ioff()
      
      # print 10 predictions from test data
      test_output = sess.run(output, {tf_x: test_x[:10]})
      pred_y = np.argmax(test_output, 1)
      print(pred_y, 'prediction number')
      print(np.argmax(test_y[:10], 1), 'real number')
      
    15. 神经网络的保存或提取。

      1. 保存,本质是session的保存。

        import tensorflow as tf import numpy as np

        ## Save to file # remember to define the same dtype and shape when restore W = tf.Variable([[1,2,3],[3,4,5]], dtype=tf.float32, name='weights') b = tf.Variable([[1,2,3]], dtype=tf.float32, name='biases')

        # 替换成下面的写法: init = tf.global_variables_initializer()

        saver = tf.train.Saver()

        with tf.Session() as sess:

         sess.run(init)
         save_path = saver.save(sess, "my_net/save_net.ckpt")
         print("Save to path: ", save_path)
        
      2. 提取,session的恢复

      import tensorflow as tf
      import numpy as np
      
      # 先建立 W, b 的容器
      W = tf.Variable(np.arange(6).reshape((2, 3)), dtype=tf.float32, name="weights")
      b = tf.Variable(np.arange(3).reshape((1, 3)), dtype=tf.float32, name="biases")
      
      # 这里不需要初始化步骤 init= tf.initialize_all_variables()
      
      saver = tf.train.Saver()
      with tf.Session() as sess:
          # 提取变量
          saver.restore(sess, "my_net/save_net.ckpt")
          print("weights:", sess.run(W))
          print("biases:", sess.run(b))
      
    16. 循环神经网络。参考:https://morvanzhou.github.io/tutorials/machine-learning/tensorflow/5-07-A-RNN/

    tensorflow入门之训练简单的神经网络方法,tensorflow神经网络

    这几天开始学tensorflow,先来做一下学习记录

    一.神经网络解决问题步骤:

    1.提取问题中实体的特征向量作为神经网络的输入。也就是说要对数据集进行特征工程,然后知道每个样本的特征维度,以此来定义输入神经元的个数。

    2.定义神经网络的结构,并定义如何从神经网络的输入得到输出。也就是说定义输入层,隐藏层以及输出层。

    3.通过训练数据来调整神经网络中的参数取值,这是训练神经网络的过程。一般来说要定义模型的损失函数,以及参数优化的方法,如交叉熵损失函数和梯度下降法调优等。

    4.利用训练好的模型预测未知的数据。也就是评估模型的好坏。

    二.训练简单的向前传播神经网络

    一下训练的神经模型是最简单的一类,而且是线性的(也就是说没有用激活函数去线性话),没有反向传播的过程,只是简单的说明神经网络工作的流程。

    import tensorflow as tf
    
    #定义隐藏层参数,每个w变量是一个tensor(可以当成是n*m的数组,n表示上一层结点个数,m表示本层结点个数)表示上一层与本层的连接权重,这里先随机定义权重
    w1=tf.Variable(tf.random_normal([2,3],stddev=1))
    w2=tf.Variable(tf.random_normal([3,1],stddev=1))
    
    #定义存放输入数据的地方,也就是x向量,这里shape为前一个传入训练的样本个数,后面出入每个样本的维度大小
    x=tf.placeholder(tf.float32,shape=(None,2),name="input")
    #矩阵乘法
    a=tf.matmul(x,w1)
    y=tf.matmul(a,w2)
    
    with tf.Session() as sess:
      #新版本好像不能用这个函数初始化所有变量了
      init_op=tf.initialize_all_variables()
      sess.run(init_op)
      #feed_dict用于向y中的x传入参数,这里传入3个,则y输出为一个3*1的tensor
      print(sess.run(y,feed_dict={x:[[0.7,0.9],[1.0,1.5],[2.1,2.3]]}))
    

    至此,一个用x的每个维度乘以两层权重之后输出单个值得线性神经网络就定义好了。

    三.定义损失函数以及反向传播算法

    有了上面的基础,我们可以定义损失函数以及反向传播算法去拟合数据了,非线性数据我们可以定义激活函数去线性化。还有一些细节就是学习率的问题,这次使用的是动态学习率,首先把学习率设定为比较大的值,加速收敛,然后随着迭代次数的增加,学习率不断下降,防止错过局部最小值。还有一个问题,就是防止过拟合。一般神经网络防止过拟合的策略有两种,一种是正则化,一种是dropout,我们暂且不作讨论后者

    损失函数:交叉熵

    反向传播算法:梯度下降法

    激活函数:relu

    # -*- coding: utf-8 -*-
    """
    Created on Fri Aug 18 14:02:19 2017
    
    @author: osT
    """
    import tensorflow as tf 
    import numpy as np
    #导入数据,这里的数据是每一行代表一个样本,每一行最后一列表示样本标签,0-32一共33个类
    data=np.loadtxt('train_data.txt',dtype='float',delimiter=',')
    
    #将样本标签转换成独热编码
    def label_change(before_label):
      label_num=len(before_label)
      change_arr=np.zeros((label_num,33))
      for i in range(label_num):
        #该样本标签原本为0-32的,本人疏忽下32标记成33
        if before_label[i]==33.0:
          change_arr[i,int(before_label[i]-1)]=1
        else:
          change_arr[i,int(before_label[i])]=1
      return change_arr
    
    #定义神经网络的输入输出结点,每个样本为1*315维,以及输出分类结果
    INPUT_NODE=315
    OUTPUT_NODE=33
    
    #定义两层隐含层的神经网络,一层300个结点,一层100个结点
    LAYER1_NODE=300
    LAYER2_NODE=100
    
    #定义学习率,学习率衰减速度,正则系数,训练调整参数的次数以及平滑衰减率
    LEARNING_RATE_BASE=0.5
    LEARNING_RATE_DECAY=0.99
    REGULARIZATION_RATE=0.0001
    TRAINING_STEPS=2000
    MOVING_AVERAGE_DECAY=0.99
    
    #定义整个神经网络的结构,也就是向前传播的过程,avg_class为平滑可训练量的类,不传入则不使用平滑
    def inference(input_tensor,avg_class,w1,b1,w2,b2,w3,b3):
      if avg_class==None:
        #第一层隐含层,输入与权重矩阵乘后加上常数传入激活函数作为输出
        layer1=tf.nn.relu(tf.matmul(input_tensor,w1) b1)
        #第二层隐含层,前一层的输出与权重矩阵乘后加上常数作为输出
        layer2=tf.nn.relu(tf.matmul(layer1,w2) b2)
        #返回 第二层隐含层与权重矩阵乘加上常数作为输出
        return tf.matmul(layer2,w3) b3
      else:
        #avg_class.average()平滑训练变量,也就是每一层与上一层的权重
        layer1=tf.nn.relu(tf.matmul(input_tensor,avg_class.average(w1)) avg_class.average(b1))
        layer2=tf.nn.relu(tf.matmul(layer1,avg_class.average(w2)) avg_class.average(b2))
        return tf.matmul(layer2,avg_class.average(w3)) avg_class.average(b3)
    
    def train(data):
      #混洗数据
      np.random.shuffle(data)
      #取钱850个样本为训练样本,后面的全是测试样本,约250个
      data_train_x=data[:850,:315]
      data_train_y=label_change(data[:850,-1])
      data_test_x=data[850:,:315]
      data_test_y=label_change(data[850:,-1])
    
      #定义输出数据的地方,None表示无规定一次输入多少训练样本,y_是样本标签存放的地方
      x=tf.placeholder(tf.float32,shape=[None,INPUT_NODE],name='x-input')
      y_=tf.placeholder(tf.float32,shape=[None,OUTPUT_NODE],name='y-input')
    
      #依次定义每一层与上一层的权重,这里用随机数初始化,注意shape的对应关系
      w1=tf.Variable(tf.truncated_normal(shape=[INPUT_NODE,LAYER1_NODE],stddev=0.1))
      b1=tf.Variable(tf.constant(0.1,shape=[LAYER1_NODE]))
    
      w2=tf.Variable(tf.truncated_normal(shape=[LAYER1_NODE,LAYER2_NODE],stddev=0.1))
      b2=tf.Variable(tf.constant(0.1,shape=[LAYER2_NODE]))
    
      w3=tf.Variable(tf.truncated_normal(shape=[LAYER2_NODE,OUTPUT_NODE],stddev=0.1))
      b3=tf.Variable(tf.constant(0.1,shape=[OUTPUT_NODE]))
    
      #输出向前传播的结果
      y=inference(x,None,w1,b1,w2,b2,w3,b3)
    
      #每训练完一次就会增加的变量
      global_step=tf.Variable(0,trainable=False)
    
      #定义平滑变量的类,输入为平滑衰减率和global_stop使得每训练完一次就会使用平滑过程
      variable_averages=tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY,global_step)
      #将平滑应用到所有可训练的变量,即trainable=True的变量
      variable_averages_op=variable_averages.apply(tf.trainable_variables())
    
      #输出平滑后的预测值
      average_y=inference(x,variable_averages,w1,b1,w2,b2,w3,b3)
    
      #定义交叉熵和损失函数,但为什么传入的是label的arg_max(),就是对应分类的下标呢,我们迟点再说
      cross_entropy=tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y,labels=tf.arg_max(y_,1))
      #计算交叉熵的平均值,也就是本轮训练对所有训练样本的平均值
      cross_entrip_mean=tf.reduce_mean(cross_entropy)
    
      #定义正则化权重,并将其加上交叉熵作为损失函数
      regularizer=tf.contrib.layers.l2_regularizer(REGULARIZATION_RATE)
      regularization=regularizer(w1) regularizer(w2) regularizer(w3)
      loss=cross_entrip_mean regularization
    
      #定义动态学习率,随着训练的步骤增加不断递减
      learning_rate=tf.train.exponential_decay(LEARNING_RATE_BASE,global_step,900,LEARNING_RATE_DECAY)
      #定义向后传播的算法,梯度下降发,注意后面的minimize要传入global_step
      train_step=tf.train.GradientDescentOptimizer(learning_rate).minimize(loss,global_step=global_step)
      #管理需要更新的变量,传入的参数是包含需要训练的变量的过程
      train_op=tf.group(train_step,variable_averages_op)
    
      #正确率预测
      correct_prediction=tf.equal(tf.arg_max(average_y,1),tf.arg_max(y_,1))
      accuracy=tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
    
      with tf.Session() as sess:
        #初始所有变量
        tf.global_variables_initializer().run()
        #训练集输入字典
        validate_feed={x:data_train_x,y_:data_train_y}
        #测试集输入字典
        test_feed={x:data_test_x,y_:data_test_y}
    
        for i in range(TRAINING_STEPS):
          if i00==0:
            validate_acc=sess.run(accuracy,feed_dict=validate_feed)
            print("After %d training step(s),validation accuracy using average model is %g"%(i,validate_acc))
          #每一轮通过同一训练集训练,由于样本太少,没办法了
          sess.run(train_op,feed_dict=validate_feed)
        #用测试集查看模型的准确率
        test_acc=sess.run(accuracy,feed_dict=test_feed)
        print("After %d training step(s),test accuracy using average model is %g"%(TRAINING_STEPS,test_acc))
    train(data)
    

    然后我们来看一下为什么计算交叉熵时要传入样本的下标:

    首先我们知道,输出结点有33个,通过与前面的权重相乘后,则每个结点都会有一个输出,每个输出我们暂且认为是对应每个类的概率,该值越大,我们就越认为该样本为对应的类。logits参数是神经网络的直接输出,也就是未经softmax函数处理的输出,labels传入的是单个值,也就是分类对应的下标,这是由于我们使用的计算交叉熵的函数 tf.nn.sparse_softmax_cross_entropy_with_logits()有关。这个函数对于在只有一个正确分类的模型计算起到加速作用,而这个labels的输入就是“这一个正确的分类”,对应到输出的结点,就是其下标了。我们还有一个没有加速的交叉熵函数:tf.nn.softmax_cross_entropy_with_logis(logis=,labels=)这个时候我们就应该传入本身的labels标签了。

    最后,我们来总结一下提高模型准确率的方法:

    1.使用激活函数。也就是去线性化,这步几乎是必须的。
    2.增加隐含层。就本例而言,单隐含层300个结点,准确率在89%左右;单隐含层400个结点,准确率在93%左右;而双隐含层300结点和100结点,准确率在94%左右。但增加隐含层意味着增加训练时间。
    3.使用动态学习率。这不但可以加快训练的速度,还可以增加神经网络收敛到较低的极小值处的概率,从而增加准确率。
    4.使用平滑模型。主要可以增加模型的健壮性,使其泛化能力更强。
    5.加入正则化或者使用dropout防止过拟合。

    附上训练集

    以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持帮客之家。

    这几天开始学tensorflow,先来做一下学习记录 一.神经网络解决问题步骤: 1.提取...

    这几天开始学tensorflow,先来做一下学习记录

    当使用Tensorflow训练大量深层的神经网络时,我们希望去跟踪神经网络的整个训练过程中的信息,比如迭代的过程中每一层参数是如何变化与分布的,比如每次循环参数更新后模型在测试集与训练集上的准确率是如何的,比如损失值的变化情况,等等。如果能在训练的过程中将一些信息加以记录并可视化得表现出来,是不是对我们探索模型有更深的帮助与理解呢?

    新葡亰496net 1

    一.神经网络解决问题步骤:

    Tensorflow官方推出了可视化工具Tensorboard,可以帮助我们实现以上功能,它可以将模型训练过程中的各种数据汇总起来存在自定义的路径与日志文件中,然后在指定的web端可视化地展现这些信息。

    图中黑色曲线是正常模型,绿色曲线就是overfitting模型。尽管绿色曲线很精确的区分了所有的训练数据,但是并没有描述数据的整体特征,对新测试数据的适应性较差。

    1.提取问题中实体的特征向量作为神经网络的输入。也就是说要对数据集进行特征工程,然后知道每个样本的特征维度,以此来定义输入神经元的个数。

    1. Tensorboard介绍

    一般用于解决过拟合的方法有增加权重的惩罚机制,比如L2正规化,但在本处我们使用tensorflow提供的dropout方法,在训练的时候, 我们随机忽略掉一些神经元和神经联结 , 使这个神经网络变得”不完整”. 用一个不完整的神经网络训练一次.
    到第二次再随机忽略另一些, 变成另一个不完整的神经网络. 有了这些随机 drop 掉的规则, 我们可以想象其实每次训练的时候, 我们都让每一次预测结果都不会依赖于其中某部分特定的神经元. 像l1, l2正规化一样, 过度依赖的 W , 也就是训练参数的数值会很大, l1, l2会惩罚这些大的 参数. Dropout 的做法是从根本上让神经网络没机会过度依赖.

    2.定义神经网络的结构,并定义如何从神经网络的输入得到输出。也就是说定义输入层,隐藏层以及输出层。

    1.1 Tensorboard的数据形式

    本次我们使用之前sklearn中手写数字作为例子来进行。

    3.通过训练数据来调整神经网络中的参数取值,这是训练神经网络的过程。一般来说要定义模型的损失函数,以及参数优化的方法,如交叉熵损失函数和梯度下降法调优等。

    Tensorboard可以记录与展示以下数据形式:
    (1)标量Scalars
    (2)图片Images
    (3)音频Audio
    (4)计算图Graph
    (5)数据分布Distribution
    (6)直方图Histograms
    (7)嵌入向量Embeddings

    加载数据

    from sklearn.datasets import load_digits
    from sklearn.preprocessing import LabelBinarizer
    
    digits = load_digits()
    X = digits.data
    y = digits.target
    
    # 把数值转换成one hot格式,例如:数字4就会被转换成:[0 0 0 0 1 0 0 0 0 0]
    y = LabelBinarizer().fit_transform(y)
    # 拆分数据集,以总量的30%作为测试集
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)
    

    4.利用训练好的模型预测未知的数据。也就是评估模型的好坏。

    1.2 Tensorboard的可视化过程

    添加层

    添加层函数如下:

    import tensorflow as tf
    def add_layer(inputs, in_size, out_size, activation_function=None):
        """
        添加层
        :param inputs: 输入数据
        :param in_size: 输入数据的列数
        :param out_size: 输出数据的列数
        :param activation_function: 激励函数
        :return:
        """
    
        # 定义权重,初始时使用随机变量,可以简单理解为在进行梯度下降时的随机初始点,这个随机初始点要比0值好,因为如果是0值的话,反复计算就一直是固定在0中,导致可能下降不到其它位置去。
        Weights = tf.Variable(tf.random_normal([in_size, out_size]))
        # 偏置shape为1行out_size列
        biases = tf.Variable(tf.zeros([1, out_size])   0.1)
        # 建立神经网络线性公式:inputs * Weights   biases,我们大脑中的神经元的传递基本上也是类似这样的线性公式,这里的权重就是每个神经元传递某信号的强弱系数,偏置值是指这个神经元的原先所拥有的电位高低值
        Wx_plus_b = tf.matmul(inputs, Weights)   biases
        if activation_function is None:
            # 如果没有设置激活函数,则直接就把当前信号原封不动地传递出去
            outputs = Wx_plus_b
        else:
            # 如果设置了激活函数,则会由此激活函数来对信号进行传递或抑制
            outputs = activation_function(Wx_plus_b)
        return outputs
    

    定义placehoder和创建实际的网络结构

    # 定义placeholder
    # 输入的手写数字大小为8*8单位的数据
    xs = tf.placeholder(tf.float32, [None, 8*8])
    # 输出值为one hot结构的数据
    ys = tf.placeholder(tf.float32, [None, 10])
    
    # 添加层
    # 第一层输入为8*8单位的手写输入数字图像,输出设定为100个神经元的层(为了能够看出是overfitting的问题),激活函数一般用tanh比较好
    l1 = add_layer(xs, 8*8, 100, activation_function=tf.nn.tanh)
    # 输出层因为最终是一个one hot的结构,因此输出的大小为10,激活函数用softmax
    prediction = add_layer(l1, 100, 10, activation_function=tf.nn.softmax)
    

    二.训练简单的向前传播神经网络

    (1)首先肯定是先建立一个graph,你想从这个graph中获取某些数据的信息

    定义损失函数

    # 定义损失函数
    cross_entropy = tf.reduce_mean(-tf.reduce_sum(ys * tf.log(prediction), axis=1))
    # 在tensorboard中记录损失函数值
    tf.summary.scalar('loss', cross_entropy)
    # 用梯度下降优化器进行训练
    train_step = tf.train.GradientDescentOptimizer(0.6).minimize(cross_entropy)
    

    一下训练的神经模型是最简单的一类,而且是线性的(也就是说没有用激活函数去线性话),没有反向传播的过程,只是简单的说明神经网络工作的流程。

    (2)确定要在graph中的哪些节点放置summary operations以记录信息
    使用tf.summary.scalar记录标量
    使用tf.summary.histogram记录数据的直方图
    使用tf.summary.distribution记录数据的分布图
    使用tf.summary.image记录图像数据
    ….

    记录损失函数并运行

    sess = tf.Session()
    merged = tf.summary.merge_all()
    # 分别记录训练集的loss和测试集的loss值,目的是为了能够对比训练集和测试集中得拟合情况
    train_writer = tf.summary.FileWriter("D:/todel/data/tensorflow/train", sess.graph)
    test_writer = tf.summary.FileWriter("D:/todel/data/tensorflow/test", sess.graph)
    
    init = tf.global_variables_initializer()
    sess.run(init)
    
    for i in range(500):
        sess.run(train_step, feed_dict={xs:X_train, ys:y_train})
        if i % 50 == 0:
            # 分别用训练集和测试集数据获得损失函数值
            train_result = sess.run(merged, feed_dict={xs:X_train, ys: y_train})
            train_writer.add_summary(train_result, i)
    
            test_result = sess.run(merged, feed_dict={xs:X_test, ys: y_test})
            test_writer.add_summary(test_result, i)
    
    import tensorflow as tf
    
    #定义隐藏层参数,每个w变量是一个tensor(可以当成是n*m的数组,n表示上一层结点个数,m表示本层结点个数)表示上一层与本层的连接权重,这里先随机定义权重
    w1=tf.Variable(tf.random_normal([2,3],stddev=1))
    w2=tf.Variable(tf.random_normal([3,1],stddev=1))
    
    #定义存放输入数据的地方,也就是x向量,这里shape为前一个传入训练的样本个数,后面出入每个样本的维度大小
    x=tf.placeholder(tf.float32,shape=(None,2),name="input")
    #矩阵乘法
    a=tf.matmul(x,w1)
    y=tf.matmul(a,w2)
    
    with tf.Session() as sess:
      #新版本好像不能用这个函数初始化所有变量了
      init_op=tf.initialize_all_variables()
      sess.run(init_op)
      #feed_dict用于向y中的x传入参数,这里传入3个,则y输出为一个3*1的tensor
      print(sess.run(y,feed_dict={x:[[0.7,0.9],[1.0,1.5],[2.1,2.3]]}))
    

    (3)operations并不会去真的执行计算,除非你告诉他们需要去run,或者它被其他的需要run的operation所依赖。而我们上一步创建的这些summary operations其实并不被其他节点依赖,因此,我们需要特地去运行所有的summary节点。但是呢,一份程序下来可能有超多这样的summary 节点,要手动一个一个去启动自然是及其繁琐的,因此我们可以使用tf.summary.merge_all去将所有summary节点合并成一个节点,只要运行这个节点,就能产生所有我们之前设置的summary data。

    完整代码

    from sklearn.datasets import load_digits
    from sklearn.preprocessing import LabelBinarizer
    from sklearn.model_selection import train_test_split
    
    digits = load_digits()
    X = digits.data
    y = digits.target
    
    # 把数值转换成one hot格式,例如:数字4就会被转换成:[0 0 0 0 1 0 0 0 0 0]
    y = LabelBinarizer().fit_transform(y)
    # 拆分数据集,以总量的30%作为测试集
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)
    
    import tensorflow as tf
    def add_layer(inputs, in_size, out_size, activation_function=None):
        """
        添加层
        :param inputs: 输入数据
        :param in_size: 输入数据的列数
        :param out_size: 输出数据的列数
        :param activation_function: 激励函数
        :return:
        """
    
        # 定义权重,初始时使用随机变量,可以简单理解为在进行梯度下降时的随机初始点,这个随机初始点要比0值好,因为如果是0值的话,反复计算就一直是固定在0中,导致可能下降不到其它位置去。
        Weights = tf.Variable(tf.random_normal([in_size, out_size]))
        # 偏置shape为1行out_size列
        biases = tf.Variable(tf.zeros([1, out_size])   0.1)
        # 建立神经网络线性公式:inputs * Weights   biases,我们大脑中的神经元的传递基本上也是类似这样的线性公式,这里的权重就是每个神经元传递某信号的强弱系数,偏置值是指这个神经元的原先所拥有的电位高低值
        Wx_plus_b = tf.matmul(inputs, Weights)   biases
        if activation_function is None:
            # 如果没有设置激活函数,则直接就把当前信号原封不动地传递出去
            outputs = Wx_plus_b
        else:
            # 如果设置了激活函数,则会由此激活函数来对信号进行传递或抑制
            outputs = activation_function(Wx_plus_b)
        return outputs
    
    # 定义placeholder
    # 输入的手写数字大小为8*8单位的数据
    xs = tf.placeholder(tf.float32, [None, 8*8])
    # 输出值为one hot结构的数据
    ys = tf.placeholder(tf.float32, [None, 10])
    
    # 添加层
    # 第一层输入为8*8单位的手写输入数字图像,输出设定为100个神经元的层(为了能够看出是overfitting的问题),激活函数一般用tanh比较好
    l1 = add_layer(xs, 8*8, 100, activation_function=tf.nn.tanh)
    # 输出层因为最终是一个one hot的结构,因此输出的大小为10,激活函数用softmax
    prediction = add_layer(l1, 100, 10, activation_function=tf.nn.softmax)
    
    # 定义损失函数
    cross_entropy = tf.reduce_mean(-tf.reduce_sum(ys * tf.log(prediction), axis=1))
    # 在tensorboard中记录损失函数值
    tf.summary.scalar('loss', cross_entropy)
    # 用梯度下降优化器进行训练
    train_step = tf.train.GradientDescentOptimizer(0.6).minimize(cross_entropy)
    
    sess = tf.Session()
    merged = tf.summary.merge_all()
    # 分别记录训练集的loss和测试集的loss值,目的是为了能够对比训练集和测试集中得拟合情况
    train_writer = tf.summary.FileWriter("D:/todel/data/tensorflow/train", sess.graph)
    test_writer = tf.summary.FileWriter("D:/todel/data/tensorflow/test", sess.graph)
    
    init = tf.global_variables_initializer()
    sess.run(init)
    
    for i in range(500):
        sess.run(train_step, feed_dict={xs:X_train, ys:y_train})
        if i % 50 == 0:
            # 分别用训练集和测试集数据获得损失函数值
            train_result = sess.run(merged, feed_dict={xs:X_train, ys: y_train})
            train_writer.add_summary(train_result, i)
    
            test_result = sess.run(merged, feed_dict={xs:X_test, ys: y_test})
            test_writer.add_summary(test_result, i)
    

    至此,一个用x的每个维度乘以两层权重之后输出单个值得线性神经网络就定义好了。

    (4)使用tf.summary.FileWriter将运行后输出的数据都保存到本地磁盘中

    输出结果

    当我们运行了上面的代码后,会在D:/todel/data/tensorflow/目录下生成tensorboard收集的日志文件,我们可以在那个目录下输入:
    新葡亰496net 2

    最终在tensorboard中显示的图形为:
    新葡亰496net 3

    我们发现,训练集(蓝色的那条曲线)损失值要比测试集(黄色的那条曲线)小,这样就存在过拟合的情况。

    三.定义损失函数以及反向传播算法

    (5)运行整个程序,并在命令行输入运行tensorboard的指令,之后打开web端可查看可视化的结果

    消除过拟合

    为了消除过拟合,我们采用dropout方式来进行。
    首先设置一个保留概率的placeholder,这样在运行时可以通过参数来进行设置

    # 设置保留概率,即我们要保留的结果所占比例,它作为一个placeholder,在run时传入, 当keep_prob=1的时候,相当于100%保留,也就是dropout没有起作用。
    keep_prob = tf.placeholder(tf.float32)
    

    然后在add_tensorflow入门之训练简单的神经网络方法,TensorFlow从入门到入门。layer函数中调用dropout功能:

        # 调用dropout功能
        Wx_plus_b = tf.nn.dropout(Wx_plus_b, keep_prob)
    

    最后在训练时设置保留的概率,但在获得损失值时用全部的数据来进行获取:

    for i in range(500):
        sess.run(train_step, feed_dict={xs:X_train, ys:y_train, keep_prob: 0.7})
        if i % 50 == 0:
            # 分别用训练集和测试集数据获得损失函数值
            train_result = sess.run(merged, feed_dict={xs:X_train, ys: y_train, keep_prob:1})
            train_writer.add_summary(train_result, i)
    
            test_result = sess.run(merged, feed_dict={xs:X_test, ys: y_test, keep_prob:1})
            test_writer.add_summary(test_result, i)
    

    这样全部代码为:

    from sklearn.datasets import load_digits
    from sklearn.preprocessing import LabelBinarizer
    from sklearn.model_selection import train_test_split
    
    digits = load_digits()
    X = digits.data
    y = digits.target
    
    # 把数值转换成one hot格式,例如:数字4就会被转换成:[0 0 0 0 1 0 0 0 0 0]
    y = LabelBinarizer().fit_transform(y)
    # 拆分数据集,以总量的30%作为测试集
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)
    
    import tensorflow as tf
    def add_layer(inputs, in_size, out_size, activation_function=None):
        """
        添加层
        :param inputs: 输入数据
        :param in_size: 输入数据的列数
        :param out_size: 输出数据的列数
        :param activation_function: 激励函数
        :return:
        """
    
        # 定义权重,初始时使用随机变量,可以简单理解为在进行梯度下降时的随机初始点,这个随机初始点要比0值好,因为如果是0值的话,反复计算就一直是固定在0中,导致可能下降不到其它位置去。
        Weights = tf.Variable(tf.random_normal([in_size, out_size]))
        # 偏置shape为1行out_size列
        biases = tf.Variable(tf.zeros([1, out_size])   0.1)
        # 建立神经网络线性公式:inputs * Weights   biases,我们大脑中的神经元的传递基本上也是类似这样的线性公式,这里的权重就是每个神经元传递某信号的强弱系数,偏置值是指这个神经元的原先所拥有的电位高低值
        Wx_plus_b = tf.matmul(inputs, Weights)   biases
        # 调用dropout功能
        Wx_plus_b = tf.nn.dropout(Wx_plus_b, keep_prob)
    
        if activation_function is None:
            # 如果没有设置激活函数,则直接就把当前信号原封不动地传递出去
            outputs = Wx_plus_b
        else:
            # 如果设置了激活函数,则会由此激活函数来对信号进行传递或抑制
            outputs = activation_function(Wx_plus_b)
        return outputs
    
    # 定义placeholder
    # 输入的手写数字大小为8*8单位的数据
    xs = tf.placeholder(tf.float32, [None, 8*8])
    # 输出值为one hot结构的数据
    ys = tf.placeholder(tf.float32, [None, 10])
    # 设置保留概率,即我们要保留的结果所占比例,它作为一个placeholder,在run时传入, 当keep_prob=1的时候,相当于100%保留,也就是dropout没有起作用。
    keep_prob = tf.placeholder(tf.float32)
    
    # 添加层
    # 第一层输入为8*8单位的手写输入数字图像,输出设定为100个神经元的层(为了能够看出是overfitting的问题),激活函数一般用tanh比较好
    l1 = add_layer(xs, 8*8, 100, activation_function=tf.nn.tanh)
    # 输出层因为最终是一个one hot的结构,因此输出的大小为10,激活函数用softmax
    prediction = add_layer(l1, 100, 10, activation_function=tf.nn.softmax)
    
    # 定义损失函数
    cross_entropy = tf.reduce_mean(-tf.reduce_sum(ys * tf.log(prediction), axis=1))
    # 在tensorboard中记录损失函数值
    tf.summary.scalar('loss', cross_entropy)
    # 用梯度下降优化器进行训练
    train_step = tf.train.GradientDescentOptimizer(0.6).minimize(cross_entropy)
    
    sess = tf.Session()
    merged = tf.summary.merge_all()
    # 分别记录训练集的loss和测试集的loss值,目的是为了能够对比训练集和测试集中得拟合情况
    train_writer = tf.summary.FileWriter("D:/todel/data/tensorflow/train", sess.graph)
    test_writer = tf.summary.FileWriter("D:/todel/data/tensorflow/test", sess.graph)
    
    init = tf.global_variables_initializer()
    sess.run(init)
    
    for i in range(500):
        sess.run(train_step, feed_dict={xs:X_train, ys:y_train, keep_prob: 0.7})
        if i % 50 == 0:
            # 分别用训练集和测试集数据获得损失函数值
            train_result = sess.run(merged, feed_dict={xs:X_train, ys: y_train, keep_prob:1})
            train_writer.add_summary(train_result, i)
    
            test_result = sess.run(merged, feed_dict={xs:X_test, ys: y_test, keep_prob:1})
            test_writer.add_summary(test_result, i)
    

    运行后输出tensorboard图形为(记得把之前的文件或目录进行删除并运行tensorboard进行显示图形):
    新葡亰496net 4

    这样训练集和测试集的损失值就比较接近了。

    有了上面的基础,我们可以定义损失函数以及反向传播算法去拟合数据了,非线性数据我们可以定义激活函数去线性化。还有一些细节就是学习率的问题,这次使用的是动态学习率,首先把学习率设定为比较大的值,加速收敛,然后随着迭代次数的增加,学习率不断下降,防止错过局部最小值。还有一个问题,就是防止过拟合。一般神经网络防止过拟合的策略有两种,一种是正则化,一种是dropout,我们暂且不作讨论后者

    2.Tensorboard使用案例

    损失函数:交叉熵

    不出所料呢,我们还是使用最基础的识别手写字体的案例~

    反向传播算法:梯度下降法

    不过本案例也是先不去追求多美好的模型,只是建立一个简单的神经网络,让大家了解如何使用Tensorboard。

    激活函数:relu

    2.1 导入包,定义超参数,载入数据

    # -*- coding: utf-8 -*-
    """
    Created on Fri Aug 18 14:02:19 2017
    
    @author: osT
    """
    import tensorflow as tf 
    import numpy as np
    #导入数据,这里的数据是每一行代表一个样本,每一行最后一列表示样本标签,0-32一共33个类
    data=np.loadtxt('train_data.txt',dtype='float',delimiter=',')
    
    #将样本标签转换成独热编码
    def label_change(before_label):
      label_num=len(before_label)
      change_arr=np.zeros((label_num,33))
      for i in range(label_num):
        #该样本标签原本为0-32的,本人疏忽下32标记成33
        if before_label[i]==33.0:
          change_arr[i,int(before_label[i]-1)]=1
        else:
          change_arr[i,int(before_label[i])]=1
      return change_arr
    
    #定义神经网络的输入输出结点,每个样本为1*315维,以及输出分类结果
    INPUT_NODE=315
    OUTPUT_NODE=33
    
    #定义两层隐含层的神经网络,一层300个结点,一层100个结点
    LAYER1_NODE=300
    LAYER2_NODE=100
    
    #定义学习率,学习率衰减速度,正则系数,训练调整参数的次数以及平滑衰减率
    LEARNING_RATE_BASE=0.5
    LEARNING_RATE_DECAY=0.99
    REGULARIZATION_RATE=0.0001
    TRAINING_STEPS=2000
    MOVING_AVERAGE_DECAY=0.99
    
    #定义整个神经网络的结构,也就是向前传播的过程,avg_class为平滑可训练量的类,不传入则不使用平滑
    def inference(input_tensor,avg_class,w1,b1,w2,b2,w3,b3):
      if avg_class==None:
        #第一层隐含层,输入与权重矩阵乘后加上常数传入激活函数作为输出
        layer1=tf.nn.relu(tf.matmul(input_tensor,w1) b1)
        #第二层隐含层,前一层的输出与权重矩阵乘后加上常数作为输出
        layer2=tf.nn.relu(tf.matmul(layer1,w2) b2)
        #返回 第二层隐含层与权重矩阵乘加上常数作为输出
        return tf.matmul(layer2,w3) b3
      else:
        #avg_class.average()平滑训练变量,也就是每一层与上一层的权重
        layer1=tf.nn.relu(tf.matmul(input_tensor,avg_class.average(w1)) avg_class.average(b1))
        layer2=tf.nn.relu(tf.matmul(layer1,avg_class.average(w2)) avg_class.average(b2))
        return tf.matmul(layer2,avg_class.average(w3)) avg_class.average(b3)
    
    def train(data):
      #混洗数据
      np.random.shuffle(data)
      #取钱850个样本为训练样本,后面的全是测试样本,约250个
      data_train_x=data[:850,:315]
      data_train_y=label_change(data[:850,-1])
      data_test_x=data[850:,:315]
      data_test_y=label_change(data[850:,-1])
    
      #定义输出数据的地方,None表示无规定一次输入多少训练样本,y_是样本标签存放的地方
      x=tf.placeholder(tf.float32,shape=[None,INPUT_NODE],name='x-input')
      y_=tf.placeholder(tf.float32,shape=[None,OUTPUT_NODE],name='y-input')
    
      #依次定义每一层与上一层的权重,这里用随机数初始化,注意shape的对应关系
      w1=tf.Variable(tf.truncated_normal(shape=[INPUT_NODE,LAYER1_NODE],stddev=0.1))
      b1=tf.Variable(tf.constant(0.1,shape=[LAYER1_NODE]))
    
      w2=tf.Variable(tf.truncated_normal(shape=[LAYER1_NODE,LAYER2_NODE],stddev=0.1))
      b2=tf.Variable(tf.constant(0.1,shape=[LAYER2_NODE]))
    
      w3=tf.Variable(tf.truncated_normal(shape=[LAYER2_NODE,OUTPUT_NODE],stddev=0.1))
      b3=tf.Variable(tf.constant(0.1,shape=[OUTPUT_NODE]))
    
      #输出向前传播的结果
      y=inference(x,None,w1,b1,w2,b2,w3,b3)
    
      #每训练完一次就会增加的变量
      global_step=tf.Variable(0,trainable=False)
    
      #定义平滑变量的类,输入为平滑衰减率和global_stop使得每训练完一次就会使用平滑过程
      variable_averages=tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY,global_step)
      #将平滑应用到所有可训练的变量,即trainable=True的变量
      variable_averages_op=variable_averages.apply(tf.trainable_variables())
    
      #输出平滑后的预测值
      average_y=inference(x,variable_averages,w1,b1,w2,b2,w3,b3)
    
      #定义交叉熵和损失函数,但为什么传入的是label的arg_max(),就是对应分类的下标呢,我们迟点再说
      cross_entropy=tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y,labels=tf.arg_max(y_,1))
      #计算交叉熵的平均值,也就是本轮训练对所有训练样本的平均值
      cross_entrip_mean=tf.reduce_mean(cross_entropy)
    
      #定义正则化权重,并将其加上交叉熵作为损失函数
      regularizer=tf.contrib.layers.l2_regularizer(REGULARIZATION_RATE)
      regularization=regularizer(w1) regularizer(w2) regularizer(w3)
      loss=cross_entrip_mean regularization
    
      #定义动态学习率,随着训练的步骤增加不断递减
      learning_rate=tf.train.exponential_decay(LEARNING_RATE_BASE,global_step,900,LEARNING_RATE_DECAY)
      #定义向后传播的算法,梯度下降发,注意后面的minimize要传入global_step
      train_step=tf.train.GradientDescentOptimizer(learning_rate).minimize(loss,global_step=global_step)
      #管理需要更新的变量,传入的参数是包含需要训练的变量的过程
      train_op=tf.group(train_step,variable_averages_op)
    
      #正确率预测
      correct_prediction=tf.equal(tf.arg_max(average_y,1),tf.arg_max(y_,1))
      accuracy=tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
    
      with tf.Session() as sess:
        #初始所有变量
        tf.global_variables_initializer().run()
        #训练集输入字典
        validate_feed={x:data_train_x,y_:data_train_y}
        #测试集输入字典
        test_feed={x:data_test_x,y_:data_test_y}
    
        for i in range(TRAINING_STEPS):
          if i00==0:
            validate_acc=sess.run(accuracy,feed_dict=validate_feed)
            print("After %d training step(s),validation accuracy using average model is %g"%(i,validate_acc))
          #每一轮通过同一训练集训练,由于样本太少,没办法了
          sess.run(train_op,feed_dict=validate_feed)
        #用测试集查看模型的准确率
        test_acc=sess.run(accuracy,feed_dict=test_feed)
        print("After %d training step(s),test accuracy using average model is %g"%(TRAINING_STEPS,test_acc))
    train(data)
    

    (1)首先还是导入需要的包:

    然后我们来看一下为什么计算交叉熵时要传入样本的下标:

    from __future__ import absolute_import
    from __future__ import division
    from __future__ import print_function
    
    import argparse
    import sys
    
    import tensorflow as tf
    
    from tensorflow.examples.tutorials.mnist import input_data
    

    首先我们知道,输出结点有33个,通过与前面的权重相乘后,则每个结点都会有一个输出,每个输出我们暂且认为是对应每个类的概率,该值越大,我们就越认为该样本为对应的类。logits参数是神经网络的直接输出,也就是未经softmax函数处理的输出,labels传入的是单个值,也就是分类对应的下标,这是由于我们使用的计算交叉熵的函数 tf.nn.sparse_softmax_cross_entropy_tensorflow入门之训练简单的神经网络方法,TensorFlow从入门到入门。with_logits()有关。这个函数对于在只有一个正确分类的模型计算起到加速作用,而这个labels的输入就是“这一个正确的分类”,对应到输出的结点,就是其下标了。我们还有一个没有加速的交叉熵函数:tf.nn.softmax_cross_entropy_with_logis(logis=,labels=)这个时候我们就应该传入本身的labels标签了。

    (2)定义固定的超参数,方便待使用时直接传入。如果你问,这个超参数为啥要这样设定,如何选择最优的超参数?这个问题此处先不讨论,超参数的选择在机器学习建模中最常用的方法就是“交叉验证法”。而现在假设我们已经获得了最优的超参数,设置学利率为0.001,dropout的保留节点比例为0.9,最大循环次数为1000.

    最后,我们来总结一下提高模型准确率的方法:

    另外,还要设置两个路径,第一个是数据下载下来存放的地方,一个是summary输出保存的地方。

    1.使用激活函数。也就是去线性化,这步几乎是必须的。
    2.增加隐含层。就本例而言,单隐含层300个结点,准确率在89%左右;单隐含层400个结点,准确率在93%左右;而双隐含层300结点和100结点,准确率在94%左右。但增加隐含层意味着增加训练时间。
    3.使用动态学习率。这不但可以加快训练的速度,还可以增加神经网络收敛到较低的极小值处的概率,从而增加准确率。
    4.使用平滑模型。主要可以增加模型的健壮性,使其泛化能力更强。
    5.加入正则化或者使用dropout防止过拟合。

    max_step = 1000 # 最大迭代次数
    learning_rate = 0.001  # 学习率
    dropout = 0.9  # dropout时随机保留神经元的比例
    
    data_dir = ''  # 样本数据存储的路径
    log_dir = ''  # 输出日志保存的路径
    

    附上训练集

    (3)接着加载数据,下载数据是直接调用了tensorflow提供的函数read_data_sets,输入两个参数,第一个是下载到数据存储的路径,第二个one_hot表示是否要将类别标签进行独热编码。它首先回去找制定目录下有没有这个数据文件,没有的话才去下载,有的话就直接读取。所以第一次执行这个命令,速度会比较慢。

    以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

    mnist = input_data.read_data_sets(data_dir,one_hot=True)
    

    您可能感兴趣的文章:

    • tensorflow学习笔记之简单的神经网络训练和测试
    • 利用TensorFlow训练简单的二分类神经网络模型的方法
    • tensorflow训练中出现nan问题的解决
    • 详解tensorflow训练自己的数据集实现CNN图像分类
    • TensorFlow实现随机训练和批量训练的方法

    2.2 创建特征与标签的占位符,保存输入的图片数据到summary

    (1)创建tensorflow的默认会话:

    sess = tf.InteractiveSession()
    

    (2)创建输入数据的占位符,分别创建特征数据x,标签数据y_

    在tf.placeholder()函数中传入了3个参数,第一个是定义数据类型为float32;第二个是数据的大小,特征数据是大小784的向量,标签数据是大小为10的向量,None表示不定死大小,到时候可以传入任何数量的样本;第3个参数是这个占位符的名称。

    with tf.name_scope('input'):
      x = tf.placeholder(tf.float32, [None, 784], name='x-input')
      y_ = tf.placeholder(tf.float32, [None, 10], name='y-input')
    

    (3)使用tf.summary.image保存图像信息

    特征数据其实就是图像的像素数据拉升成一个1*784的向量,现在如果想在tensorboard上还原出输入的特征数据对应的图片,就需要将拉升的向量转变成28 * 28 * 1的原始像素了,于是可以用tf.reshape()直接重新调整特征数据的维度:

    将输入的数据转换成[28 * 28 * 1]的shape,存储成另一个tensor,命名为image_shaped_input。

    为了能使图片在tensorbord上展示出来,使用tf.summary.image将图片数据汇总给tensorbord。

    tf.summary.image()中传入的第一个参数是命名,第二个是图片数据,第三个是最多展示的张数,此处为10张

    with tf.name_scope('input_reshape'):
      image_shaped_input = tf.reshape(x, [-1, 28, 28, 1])
      tf.summary.image('input', image_shaped_input, 10)
    

    2.3 创建初始化参数的方法,与参数信息汇总到summary的方法

    (1)在构建神经网络模型中,每一层中都需要去初始化参数w,b,为了使代码简介美观,最好将初始化参数的过程封装成方法function。

    创建初始化权重w的方法,生成大小等于传入的shape参数,标准差为0.1,正态分布的随机数,并且将它转换成tensorflow中的variable返回。

    def weight_variable(shape):
      """Create a weight variable with appropriate initialization."""
      initial = tf.truncated_normal(shape, stddev=0.1)
      return tf.Variable(initial)
    

    创建初始换偏执项b的方法,生成大小为传入参数shape的常数0.1,并将其转换成tensorflow的variable并返回

    def bias_variable(shape):
      """Create a bias variable with appropriate initialization."""
      initial = tf.constant(0.1, shape=shape)
      return tf.Variable(initial)
    

    (2)我们知道,在训练的过程在参数是不断地在改变和优化的,我们往往想知道每次迭代后参数都做了哪些变化,可以将参数的信息展现在tenorbord上,因此我们专门写一个方法来收录每次的参数信息。

    def variable_summaries(var):
      """Attach a lot of summaries to a Tensor (for TensorBoard visualization)."""
      with tf.name_scope('summaries'):
       # 计算参数的均值,并使用tf.summary.scaler记录
       mean = tf.reduce_mean(var)
       tf.summary.scalar('mean', mean)
    
       # 计算参数的标准差
       with tf.name_scope('stddev'):
        stddev = tf.sqrt(tf.reduce_mean(tf.square(var - mean)))
       # 使用tf.summary.scaler记录记录下标准差,最大值,最小值
       tf.summary.scalar('stddev', stddev)
       tf.summary.scalar('max', tf.reduce_max(var))
       tf.summary.scalar('min', tf.reduce_min(var))
       # 用直方图记录参数的分布
       tf.summary.histogram('histogram', var)
    

    2.4 构建神经网络层

    (1)创建第一层隐藏层
    创建一个构建隐藏层的方法,输入的参数有:
    input_tensor:特征数据
    input_dim:输入数据的维度大小
    output_dim:输出数据的维度大小(=隐层神经元个数)
    layer_name:命名空间
    act=tf.nn.relu:激活函数(默认是relu)

    def nn_layer(input_tensor, input_dim, output_dim, layer_name, act=tf.nn.relu):
      """Reusable code for making a simple neural net layer.
      It does a matrix multiply, bias add, and then uses relu to nonlinearize.
      It also sets up name scoping so that the resultant graph is easy to read,
      and adds a number of summary ops.
      """
      # 设置命名空间
      with tf.name_scope(layer_name):
       # 调用之前的方法初始化权重w,并且调用参数信息的记录方法,记录w的信息
       with tf.name_scope('weights'):
        weights = weight_variable([input_dim, output_dim])
        variable_summaries(weights)
       # 调用之前的方法初始化权重b,并且调用参数信息的记录方法,记录b的信息
       with tf.name_scope('biases'):
        biases = bias_variable([output_dim])
        variable_summaries(biases)
       # 执行wx b的线性计算,并且用直方图记录下来
       with tf.name_scope('linear_compute'):
        preactivate = tf.matmul(input_tensor, weights)   biases
        tf.summary.histogram('linear', preactivate)
       # 将线性输出经过激励函数,并将输出也用直方图记录下来
       activations = act(preactivate, name='activation')
       tf.summary.histogram('activations', activations)
    
       # 返回激励层的最终输出
       return activations
    

    调用隐层创建函数创建一个隐藏层:输入的维度是特征的维度784,神经元个数是500,也就是输出的维度。

    hidden1 = nn_layer(x, 784, 500, 'layer1')
    

    (2)创建一个dropout层,,随机关闭掉hidden1的一些神经元,并记录keep_prob

    with tf.name_scope('dropout'):
      keep_prob = tf.placeholder(tf.float32)
      tf.summary.scalar('dropout_keep_probability', keep_prob)
      dropped = tf.nn.dropout(hidden1, keep_prob)
    

    (3)创建一个输出层,输入的维度是上一层的输出:500,输出的维度是分类的类别种类:10,激活函数设置为全等映射identity.(暂且先别使用softmax,会放在之后的损失函数中一起计算)

    y = nn_layer(dropped, 500, 10, 'layer2', act=tf.identity)
    

    2.5 创建损失函数

    使用tf.nn.softmax_cross_entropy_with_logits来计算softmax并计算交叉熵损失,并且求均值作为最终的损失值。

    with tf.name_scope('loss'):
      # 计算交叉熵损失(每个样本都会有一个损失)
      diff = tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y)
      with tf.name_scope('total'):
       # 计算所有样本交叉熵损失的均值
       cross_entropy = tf.reduce_mean(diff)
    
    tf.summary.scalar('loss', cross_entropy)
    

    2.6 训练,并计算准确率

    (1)使用AdamOptimizer优化器训练模型,最小化交叉熵损失

    with tf.name_scope('train'):
      train_step = tf.train.AdamOptimizer(learning_rate).minimize(
        cross_entropy)
    

    (2)计算准确率,并用tf.summary.scalar记录准确率

    with tf.name_scope('accuracy'):
      with tf.name_scope('correct_prediction'):
       # 分别将预测和真实的标签中取出最大值的索引,弱相同则返回1(true),不同则返回0(false)
       correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
      with tf.name_scope('accuracy'):
       # 求均值即为准确率
       accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
    tf.summary.scalar('accuracy', accuracy)
    

    2.7 合并summary operation, 运行初始化变量

    将所有的summaries合并,并且将它们写到之前定义的log_dir路径

    # summaries合并
    merged = tf.summary.merge_all()
    # 写到指定的磁盘路径中
    train_writer = tf.summary.FileWriter(log_dir   '/train', sess.graph)
    test_writer = tf.summary.FileWriter(log_dir   '/test')
    
    # 运行初始化所有变量
    tf.global_variables_initializer().run()
    

    2.8 准备训练与测试的两个数据,循环执行整个graph进行训练与评估

    (1)现在我们要获取之后要喂人的数据.
    如果是train==true,就从mnist.train中获取一个batch样本,并且设置dropout值;
    如果是不是train==false,则获取minist.test的测试数据,并且设置keep_prob为1,即保留所有神经元开启。

    def feed_dict(train):
      """Make a TensorFlow feed_dict: maps data onto Tensor placeholders."""
      if train:
       xs, ys = mnist.train.next_batch(100)
       k = dropout
      else:
       xs, ys = mnist.test.images, mnist.test.labels
       k = 1.0
      return {x: xs, y_: ys, keep_prob: k}
    

    (2)开始训练模型。
    每隔10步,就进行一次merge, 并打印一次测试数据集的准确率,然后将测试数据集的各种summary信息写进日志中。
    每隔100步,记录原信息
    其他每一步时都记录下训练集的summary信息并写到日志中。

    for i in range(max_steps):
      if i % 10 == 0: # 记录测试集的summary与accuracy
       summary, acc = sess.run([merged, accuracy], feed_dict=feed_dict(False))
       test_writer.add_summary(summary, i)
       print('Accuracy at step %s: %s' % (i, acc))
      else: # 记录训练集的summary
       if i % 100 == 99: # Record execution stats
        run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
        run_metadata = tf.RunMetadata()
        summary, _ = sess.run([merged, train_step],
                   feed_dict=feed_dict(True),
                   options=run_options,
                   run_metadata=run_metadata)
        train_writer.add_run_metadata(run_metadata, 'stepd' % i)
        train_writer.add_summary(summary, i)
        print('Adding run metadata for', i)
       else: # Record a summary
        summary, _ = sess.run([merged, train_step], feed_dict=feed_dict(True))
        train_writer.add_summary(summary, i)
     train_writer.close()
     test_writer.close()
    

    2.9 执行程序,tensorboard生成可视化

    (1)运行整个程序,在程序中定义的summary node就会将要记录的信息全部保存在指定的logdir路径中了,训练的记录会存一份文件,测试的记录会存一份文件。

    (2)进入linux命令行,运行以下代码,等号后面加上summary日志保存的路径(在程序第一步中就事先自定义了)

    tensorboard --logdir=
    

    新葡亰496net,执行命令之后会出现一条信息,上面有网址,将网址在浏览器中打开就可以看到我们定义的可视化信息了。:

    Starting TensorBoard 41 on port 6006
    (You can navigate to http://127.0.1.1:6006)
    

    将在浏览器中打开,成功的话如下:

    新葡亰496net 5

    于是我们可以从这个web端看到所有程序中定义的可视化信息了。

    2.10 Tensorboard Web端解释

    看到最上面橙色一栏的菜单,分别有7个栏目,都一一对应着我们程序中定义信息的类型。

    (1)SCALARS

    展示的是标量的信息,我程序中用tf.summary.scalars()定义的信息都会在这个窗口。

    回顾本文程序中定义的标量有:准确率accuracy,dropout的保留率,隐藏层中的参数信息,已经交叉熵损失。这些都在SCLARS窗口下显示出来了。

    点开accuracy,红线表示test集的结果,蓝线表示train集的结果,可以看到随着循环次数的增加,两者的准确度也在通趋势增加,值得注意的是,在0到100次的循环中准确率快速激增,100次之后保持微弱地上升趋势,直达1000次时会到达0.967左右

    新葡亰496net 6

    点开dropout,红线表示的测试集上的保留率始终是1,蓝线始终是0.9

    新葡亰496net 7

    点开layer1,查看第一个隐藏层的参数信息。

    新葡亰496net 8 

    以上,第一排是偏执项b的信息,随着迭代的加深,最大值越来越大,最小值越来越小,与此同时,也伴随着方差越来越大,这样的情况是我们愿意看到的,神经元之间的参数差异越来越大。因为理想的情况下每个神经元都应该去关注不同的特征,所以他们的参数也应有所不同。

    第二排是权值w的信息,同理,最大值,最小值,标准差也都有与b相同的趋势,神经元之间的差异越来越明显。w的均值初始化的时候是0,随着迭代其绝对值也越来越大。

    点开layer2

    新葡亰496net 9

    点开loss,可见损失的降低趋势。

    新葡亰496net 10

    (2)IMAGES

    在程序中我们设置了一处保存了图像信息,就是在转变了输入特征的shape,然后记录到了image中,于是在tensorflow中就会还原出原始的图片了:

    新葡亰496net 11 

    整个窗口总共展现了10张图片(根据代码中的参数10)

    (3)AUDIO

    这里展示的是声音的信息,但本案例中没有涉及到声音的。

    (4)GRAPHS

    这里展示的是整个训练过程的计算图graph,从中我们可以清洗地看到整个程序的逻辑与过程。

    新葡亰496net 12 

    单击某个节点,可以查看属性,输入,输出等信息

    新葡亰496net 13 

    单击节点上的“ ”字样,可以看到该节点的内部信息。

    新葡亰496net 14 

    另外还可以选择图像颜色的两者模型,基于结构的模式,相同的节点会有同样的颜色,基于预算硬件的,同一个硬件上的会有相同颜色。

    新葡亰496net 15

    (5)DISTRIBUTIONS

    这里查看的是神经元输出的分布,有激活函数之前的分布,激活函数之后的分布等。

    新葡亰496net 16

    (6)HISTOGRAMS

    也可以看以上数据的直方图

    新葡亰496net 17

    (7)EMBEDDINGS

    展示的是嵌入向量的可视化效果,本案例中没有使用这个功能。之后其他案例中再详述。

    本文主要使用手写数字识别的小案例来讲解了如何初步使用Tensorflow的可视化工具Tensorboard。

    以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

    您可能感兴趣的文章:

    • Tensorflow 自带可视化Tensorboard使用方法(附项目代码)

    本文由新葡亰496net发布于奥门新萄京娱乐场,转载请注明出处:tensorflow入门之训练简单的神经网络方法,Tensor

    关键词:

上一篇:寻找总分最高的学习者,MOOC期终战绩

下一篇:没有了