威尼斯人线上娱乐

tensorflow神经网络,TensorFlow从入门到入门

14 4月 , 2019  

在机械学习中恐怕会存在过拟合的题材,表现为在磨练集上显现很好,但在测试集中表现不及磨炼集中的那么好。

  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%20 == 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 i%50 == 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 i%50 == 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 i%50 == 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数据完结测试分类器,程序中根本新的上学点有一.
    MNIST数据采纳。2.优化目的函数中的交叉熵函数 三.
    陶冶方法选取梯度降低法

    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 i%50 == 0:
                print(compute_accuracy(mnist.test.images, mnist.test.labels))
    
  12. 过于拟合(Overfitting),过度学习。在拍卖具体难题的时候,数据出自是不可控的。总会现身对机器学习神经互联网不利的数目,来源至关首要能够分为,度量截断误差,文化背景,外界滋扰。总计起来便是机械学习的神经网络自设计之初就处理不了的多少。对于由于过分拟合人们找到了优化神经网络的笔触。

    1. 充实数据量,机器学习的结果来自数据的盘算。数据量大了,有八个半个的不胜数据也就不算什么了,或是出现周旋的数来抵消(小可能率数据)。未有增进神经网络的成色。
    2. 正规化。
      1.修改标称误差总计函数,使得神经互连网获得分歧程度的汇报。原始的 cost
      相对误差是如此总结, cost = 预测值-真实值的平方。要是 W 变得太大,
      大家就让 cost 也随即变大, 变成一种惩罚机制. 所以大家把 W
      自个儿思索进来. 那里 abs 是纯属值. 这1种样式的 正规化, 叫做 l一正规化. L贰 行业内部和 l壹 类似, 只是纯属值换到了平方. 别的的l三, l4也都以换到了立方和八遍方等等. 格局类似.
      用那些点子,大家就能保障让学出来的线条不会过度扭曲.(引用https://morvanzhou.github.io/tutorials/machine-learning/tensorflow/5-02-A-overfitting/)

      1. dropout。1种专门用在神经网络的标准的秘籍。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 visualization\n')
    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神经互连网

这几天初阶学tensorflow,先来做一下学习记录

壹.神经网络消除难题步骤:

一.领取难点中实体的特征向量作为神经互连网的输入。也正是说要对数据集进行特色工程,然后知道各类样本的性状维度,以此来定义输入神经元的个数。

二.定义神经网络的协会,并定义怎样从神经网络的输入获得输出。也正是说定义输入层,隐藏层以及输出层。

三.由此练习多少来调动神经互连网中的参数取值,那是练习神经网络的长河。1般的话要定义模型的损失函数,以及参数优化的艺术,如交叉熵损失函数和梯度下跌法调优等。

肆.使用陶冶好的模子预测未知的数码。也正是评估模型的高低。

贰.陶冶不难的迈入传播神经互连网

1晃教练的神经模型是最简便易行的一类,而且是线性的(也便是说未有用激活函数去线性话),未有反向传播的长河,只是简单来表达神经互联网工作的流程。

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个用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 i%1000==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)

威尼斯人线上娱乐 ,下一场大家来看一下为何总结交叉熵时要传播样本的下标:

先是大家领略,输出结点有三贰13个,通过与日前的权重相乘后,则每一种结点都会有三个出口,每种输出大家姑且认为是对应每一种类的票房价值,该值越大,大家就越认为该样本为相应的类。logits参数是神经网络的一贯出口,相当于未经softmax函数处理的输出,labels传入的是单个值,也正是分类对应的下标,那是出于我们运用的计量交叉熵的函数
tf.nn.sparse_softmax_cross_tensorflow神经网络,TensorFlow从入门到入门。entropy_with_logits()有关。那些函数对于在只有3个不利分类的模子测算起到加快效能,而这么些labels的输入就是“那四个不易的归类”,对应到输出的结点,就是其下标了。大家还有叁个尚未加快的接力熵函数:tf.nn.softmax_cross_entropy_with_logis(logis=,labels=)那一年大家就应当传入自个儿的labels标签了。

末段,大家来总括一下拉长模型准确率的方法:

一.行使激活函数。也正是去线性化,那步差不离是必须的。
贰.日增隐含层。就本例而言,单隐含层300个结点,准确率在8玖%左右;单隐含层400个结点,准确率在玖3%左右;而双隐含层300结点和100结点,准确率在⑨四%左右。但扩大隐含层意味着扩大磨练时间。
三.使用动态学习率。那不单能够加速训练的快慢,仍是能够扩张神经互连网收敛到较低的非常小值处的可能率,从而扩张准确率。
四.行使平滑模型。主要能够增添模型的健壮性,使其泛化能力更加强。
五.投入正则化或许选拔dropout防止过拟合。

附上磨练集

上述正是本文的全体内容,希望对大家的求学抱有支持,也可望咱们多多扶助帮客之家。

这几天起先学tensorflow,先来做一下学学记录 壹.神经网络化解难点步骤:
一.提取…

威尼斯人线上娱乐 1

Tensorflow官方推出了可视化学工业具Tensorboard,能够扶持大家兑现上述功效,它可以将模型磨炼进度中的各样数码汇总起来存在自定义的不二等秘书籍与日志文件中,然后在内定的web端可视化地突显这一个音讯。

图中浅绛红曲线是正规模型,深红曲线正是overfitting模型。就算淡白紫曲线很可信的界别了颇具的教练多少,可是并未描述数据的完全特点,对新测试数据的适应性较差。

1. Tensorboard介绍

1般用于化解过拟合的法子有扩充权重的惩治机制,比如L2正规化,但在本处大家利用tensorflow提供的dropout方法,在教练的时候,
大家随便忽略掉1部分神经元和神经联结 , 使这几个神经互联网变得”不完整”.
用四个不完全的神经互联网练习叁回.
到第三遍再轻易忽略另1对, 变成另四个不完全的神经网络. 有了那一个随机 drop
掉的条条框框, 我们得以想象其实每次练习的时候,
我们都让每贰遍预测结果都不会凭借于当中某有个别特定的神经元. 像l一,
l二标准1样, 过度依靠的 W , 也等于教练参数的数值会不小, l一,
l2会处以这一个大的 参数. Dropout 的做法是从根本上让神经互连网没机会过度注重.

1.一 Tensorboard的多少方式

本次大家选用在此之前sklearn中手写数字作为例子来拓展。

Tensorboard能够记录与展现以下数据格局:
(1)标量Scalars
(2)图片Images
(3)音频Audio
(4)计算图Graph
(伍)数据分布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)

一.二 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)

(3)operations并不会去真正进行计算,除非您告知她们供给去run,或许它被别的的内需run的operation所依靠。而我们上一步创制的那个summary
operations其实并不被此外节点正视,由此,大家要求特地去运维具有的summary节点。不过呢,一份程序下来大概有超多那样的summary
节点,要手动2个一个去运营自然是会同繁琐的,因而大家得以选择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)

(4)使用tf.summary.FileWriter将运维后输出的数量都封存到本地球磁性盘中

出口结果

当我们运维了地点的代码后,会在D:/todel/data/tensorflow/目录下生成tensorboard收集的日志文件,大家得以在非凡目录下输入:
威尼斯人线上娱乐 2

最终在tensorboard中显得的图形为:
威尼斯人线上娱乐 3

咱俩发现,锻练集(绛紫的那条曲线)损失值要比测试集(中灰的那条曲线)小,那样就存在过拟合的情况。

(5)运营总体程序,并在命令行输入运转tensorboard的吩咐,之后打开web端可查阅可视化的结果

破除过拟合

为了排除过拟合,大家使用dropout格局来拓展。
率先设置多少个保存概率的placeholder,那样在运营时得以透过参数来展开安装

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

然后在add_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实行体现图形):
威尼斯人线上娱乐 4

这么陶冶集和测试集的损失值就比较像样了。

2.Tensorboard应用案例

意料之中吗,大家还是采用最基础的分辨手写字体的案例~

但是本案例也是先不去追求多美好的模型,只是建立3个粗略的神经互连网,让大家通晓什么利用Tensorboard。

2.一 导入包,定义超参数,载入数据

(一)首先还是导入必要的包:

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

(二)定义固定的超参数,方便待使用时一直传入。假若您问,这些超参数为何要如此设定,如何抉择最优的超参数?那么些题材此处先不斟酌,超参数的选项在机器学习建立模型中最常用的办法正是“交叉验证法”。而近年来只要我们早已取得了最优的超参数,设置学利率为0.00一,dropout的保留节点比例为0.玖,最大循环次数为1000.

除此以外,还要设置三个途径,第伍个是多少下载下来存放的地点,一个是summary输出保存的地点。

max_step = 1000 # 最大迭代次数
learning_rate = 0.001  # 学习率
dropout = 0.9  # dropout时随机保留神经元的比例

data_dir = ''  # 样本数据存储的路径
log_dir = ''  # 输出日志保存的路径

(三)接着加载数据,下载数据是向来调用了tensorflow提供的函数read_data_sets,输入三个参数,第2个是下载到数据存款和储蓄的路径,第贰个one_hot表示是或不是要将品种标签实行独热编码。它首先回去找制定目录下有未有这些数据文件,未有的话才去下载,有的话就直接读取。所以首先次实践那个命令,速度会相比慢。

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

2.二 创造特征与标签的占位符,保存输入的图形数据到summary

(一)创制tensorflow的私下认可会话:

sess = tf.InteractiveSession()

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

在tf.placeholder()函数中传播了一个参数,第二个是定义数据类型为float3二;第3个是数量的分寸,特征数据是深浅78四的向量,标签数据是高低为10的向量,None表示不定死大小,到时候能够流传任何数据的样书;首个参数是以此占位符的称谓。

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保存图像消息

特点数据实际上就是图像的像素数量拉升成叁个一*784的向量,未来壹旦想在tensorboard上还原出输入的表征数据对应的图片,就需求将拉升的向量转变成2八
* 28 *
1的原始像素了,于是能够用tf.reshape()直接重新调整特征数据的维度:

将输入的多寡转换成[28 * 28 *
1]的shape,存款和储蓄成另叁个tensor,命名称为image_shaped_input。

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

tf.summary.image()中传唱的首先个参数是命名,第四个是图片数据,第多个是最多展现的张数,此处为十张

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.三 创立早先化参数的方法,与参数消息汇总到summary的方法

(一)在创设神经互联网模型中,每一层中都亟需去初叶化参数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)

二.4 构建神经网络层

(一)创造第二层隐藏层
制造八个构建隐藏层的办法,输入的参数有:
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

调用隐层成立函数创制八个隐藏层:输入的维度是特色的维度7八肆,神经元个数是500,相当于出口的维度。

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

(二)创设2个dropout层,,随机关闭掉hidden一的有个别神经元,并记录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)

(叁)成立二个输出层,输入的维度是上一层的出口:500,输出的维度是分类的花色种类:10,激活函数设置为全等映射identity.(临时先别使用softmax,会放在之后的损失函数中壹起总结)

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

2.伍 创立损失函数

使用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)

二.陆 磨炼,并总括准确率

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

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

(二)总结准确率,并用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.七 合并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()

二.八 准备练习与测试的多个数据,循环执行总体graph举办训练与评估

(壹)以后我们要拿走之后要喂人的数据.
若果是train==true,就从mnist.train中收获3个batch样本,并且安装dropout值;
假假诺不是train==false,则获得minist.test的测试数据,并且安装keep_prob为一,即保留全体神经元开启。

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步,就开始展览1遍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, 'step%03d' % 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()

二.玖 执行顺序,tensorboard生成可视化

(一)运转总体程序,在先后中定义的summary
node就会即将记录的新闻全体封存在钦命的logdir路径中了,演习的笔录会存一份文件,测试的记录会存一份文件。

(二)进入linux命令行,运转以下代码,等号前边加上summary日志保存的不二等秘书诀(在先后第三步中就先行自定义了)

tensorboard --logdir=

执行命令之后会出现一条新闻,上边有网站,将网站在浏览器中开拓就足以看出我们定义的可视化音讯了。:

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

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

威尼斯人线上娱乐 5

于是大家得以从那个web端看到有着程序中定义的可视化音信了。

2.10 Tensorboard Web端解释

总的来看最下边紫褐一栏的菜系,分别有几个栏目,都相继对应着我们先后中定义务消防队息的档次。

(1)SCALARS

来得的是标量的音信,笔者先后中用tf.summary.scalars()定义的信息都会在那几个窗口。

回顾本文程序中定义的标量有:准确率accuracy,dropout的保留率,隐藏层中的参数消息,已经陆续熵损失。这个都在SCLA翼虎S窗口下显得出来了。

点开accuracy,红线表示test集的结果,蓝线表示train集的结果,可以看出随着循环次数的加码,两者的准确度也在通趋势扩展,值得注意的是,在0到九17遍的循环中准确率火速增加产量,玖拾4回未来保持微弱地升起势头,直达1000次时会到达0.967左右

威尼斯人线上娱乐 6

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

威尼斯人线上娱乐 7

点开layer一,查看第二个隐藏层的参数新闻。

威尼斯人线上娱乐 8 

以上,第三排是偏执项b的消息,随着迭代的加重,最大值越来越大,最小值越来越小,与此同时,也陪同着方差更加大,那样的情况是我们愿意看看的,神经元之间的参数差别越来越大。因为优质的事态下各类神经元都应有去关爱分裂的表征,所以她们的参数也应有所分歧。

第3排是权值w的音信,同理,最大值,最小值,标准差也都有与b相同的方向,神经元之间的出入越来越无不侧目。w的均值初叶化的时候是0,随着迭代其相对值也愈加大。

点开layer2

威尼斯人线上娱乐 9

点开loss,可知损失的减退趋势。

威尼斯人线上娱乐 10

(2)IMAGES

在先后中大家设置了一处保存了图像消息,正是在扭转了输入特征的shape,然后记录到了image中,于是在tensorflow中就会还原出原始的图样了:

威尼斯人线上娱乐 11 

整整窗口总共彰显了十张图片(遵照代码中的参数拾)

(3)AUDIO

此间体现的是声音的新闻,但本案例中未有涉及到声音的。

(4)GRAPHS

此间显得的是壹体锻练进程的揣测图graph,从中大家得以洗涤地看看全体程序的逻辑与经过。

威尼斯人线上娱乐 12 

单击有个别节点,能够查阅属性,输入,输出等新闻

威尼斯人线上娱乐 13 

单击节点上的“+”字样,能够看看该节点的内部音信。

威尼斯人线上娱乐 14 

别的还足以选用图像颜色的两端模型,基于结构的方式,相同的节点会有相同的颜料,基于预算硬件的,同3个硬件上的会有同样颜色。

威尼斯人线上娱乐 15

(5)DISTRIBUTIONS

此处查看的是神经元输出的遍布,有激活函数在此以前的分布,激活函数之后的遍布等。

威尼斯人线上娱乐 16

(6)HISTOGRAMS

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

威尼斯人线上娱乐 17

(7)EMBEDDINGS

来得的是停放向量的可视化效果,本案例中未有行使那么些职能。之后其余案例中再详述。

本文首要使用手写数字识其他小案例来讲解了什么样开首使用Tensorflow的可视化学工业具Tensorboard。

上述正是本文的全部内容,希望对我们的读书抱有协助,也希望大家多多协理脚本之家。

您只怕感兴趣的篇章:

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


相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图