精华内容
下载资源
问答
  • 可视化分析和诊断工具,有助于机器学习模型的选择。 什么是黄砖? Yellowbrick是一套称为“ Visualizers”的视觉诊断工具,可扩展scikit-learn API以允许人工操纵模型选择过程。 简而言之,Yellowbrick按照scikit-...
  • ML:根据不同机器学习模型输出的预测值+且与真实值相减得到绝对误差对比+误差可视化 目录 输出结果 实现代码 输出结果 实现代码 # -*- coding: utf-8 -*- #ML:根据不同机器学习模型输出的...

    ML:根据不同机器学习模型输出的预测值+且与真实值相减得到绝对误差对比+误差可视化

     

     

     

    目录

    输出结果

    实现代码


     

     

     

    输出结果

     

    实现代码

    # -*- coding: utf-8 -*-
    
    
    #ML:根据不同机器学习模型输出的预测值+且与真实值相减得到绝对误差对比+误差可视化
    
    #Model_comparison_error_Plot()函数:根据不同模型预测值输出绝对误差对比且可视化
    def Model_comparison_error_Plot(list_str01,list_str02,list_num00, Xlabel,Ylabel,title):
        #数字列表相减功能:将两个字符串列表改为数字列表并相减
        #(1)、依次将两个字符串列表改为数字列表
        import numpy as np
        list_num01 = list(map(float, list_str01))
        list_num02 = list(map(float, list_str02))
        
        #(2)、列表内数字相减求差
        #T1、利用array方法
        list_array01 = np.array(list_num01)
        list_array02 = np.array(list_num02)
        list_array00 = np.array(list_num00)     #定义标准列表
        
        list_subtraction01 = list_array00 - list_array01
        list_subtraction02 = list_array00 - list_array02
        print(list_array00)
        print('list_subtraction01', list_subtraction01)
        print('list_subtraction02', list_subtraction02)
        
        #T2、利用列表的for循环指针对应取出法
        error01 = []
        error02 = []
        for i in range(len(list_num00)):
            error01.append(round (list_num01[i] - list_num00[i],3) )
            error02.append(round (list_num02[i] - list_num00[i],3) )
        print(error01)
        print(error02)
        
        #(3)、绘制error曲线
        import matplotlib.pyplot as plt
         
        x = range(0,len(list_subtraction01))
        y1 = list_subtraction01
        y2 = list_subtraction02
        y_zero = [0 for x in range(0, len(list_subtraction01))]
    
        plt.plot(x,y_zero,'r--',label='zero') 
        plt.plot(x,y1,'g',label='STD-DTR')                      
        plt.plot(x,y2,'b',label='STD-XGBR')
         
        plt.xlabel(Xlabel)
        plt.ylabel(Ylabel)
        plt.title(title)
         
        plt.legend(loc=1)   
        plt.show()
    
    
    DTR_list =  ['67.330', '66.794', '65.319', '65.435', '67.903', '67.743', '63.994', '62.466', '67.581', '67.505', '64.196', '63.726', '66.749', '67.363', '65.962', '65.630', '66.602', '66.956', '63.730', '63.858', '67.370', '66.902', '63.392', '63.408', '64.428', '73.083', '72.952', '73.561', '73.148', '73.258', '72.558']
    XGBR_list =  ['66.398', '66.308', '66.197', '66.323', '66.388', '66.388', '65.761', '65.074', '65.516', '65.448', '65.534', '65.530', '64.163', '64.097', '62.860', '62.860', '63.771', '63.926', '62.667', '62.902', '62.981', '62.981', '62.987', '62.897', '66.465', '72.292', '71.947', '71.947', '71.947', '71.947', '71.928']
    real_list = [64, 68, 64, 68, 65, 65, 63, 63, 66, 65, 65, 65, 64, 65, 61, 62, 64, 63, 66, 60, 66, 62, 64, 61, 71, 75, 73, 73, 73, 73, 73]
    title = 'Comparisons and Visualization of Absolute Errors in Output of Predicted Values of Different Models'
    Xlabel = 'working condition'
    Ylabel = 'Absolute Error Value'
    Model_comparison_error_Plot(DTR_list,XGBR_list,real_list,Xlabel,Ylabel,title)
    
    

     

     

     

     

     

    展开全文
  • 理解和可视化机器学习中的数据迭代摘要绪论背景及相关工作理解数据迭代为什么要迭代数据数据迭代常用方法 摘要 成功的机器学习(ML)应用程序需要对建模和底层数据进行迭代。虽然先前的ML可视化工具主要集中在建模上...

    论文地址: Understanding and Visualizing Data Iteration in Machine Learning

    概览

    在这里插入图片描述

    绪论

    在这里插入图片描述
    一个传统的机器学习过程包括模型迭代和数据迭代,ML中有句俗语:垃圾输入,垃圾输出,说明了数据对于模型的重要性,机器学习研究人员经常通过迭代数据来提高模型性能,本文的研究主要集中在数据迭代上。

    背景及相关工作

    在本文中,我们将数据探索可视化技术扩展到随着模型开发时间的变化而变化的机器学习数据集,包括一种新的可视化方法,用于显示包含模型性能和支持数据版本比较的特征分布。

    理解数据迭代

    为什么要迭代数据

    • 数据引导建模
    • 数据提高性能
    • 世界在变,数据也在变

    数据迭代常用方法

    • Add
      • 添加采样实例
      • 添加特定实例
      • 添加合成实例
      • 添加标签
    • Remove
      • 移除实例
    • Modify
      • 修改特征、标签

    数据迭代的挑战

    • 跟踪试验和迭代历史
    • 何时"解冻"数据版本
    • 何时停止收集数据
    • 手动故障案例分析
    • 创建数据黑名单

    可视化数据迭代:动机和任务

    动机:用交互式可视化来了解数据演化如何影响模型性能
    任务

    • 跟踪和追溯数据版本上的数据迭代和模型度量
    • 属性模型度量更改为数据迭代
    • 通过训练、测试分割,性能(例如,正确的v.错误的预测)和数据版本(C2、C3、C5)来比较特征分布
    • 了解数据版本对模型的敏感性

    CHAMELEON: 不断变化数据的可视化分析

    在这里插入图片描述

    • 数据版本时间线:随时间变化的数据迭代
    • 特征视图:可视化演化分布
      在这里插入图片描述
    • 侧栏:可视化演化实例预测
      在这里插入图片描述
      A. 聚合嵌入:通过数据降维输出的离散化摘要图显示主数据版本,此图为用户提供了数据集的概述,对于发现类似实例的潜在集群非常有用
      B. 预测变化矩阵:显示了两个版本中存在的实例子集,并通过它们的预测正确性和版本对它们进行了划分
      C. 灵敏度直方图:显示了数据实例对所选版本范围内版本的预测敏感度
      在这里插入图片描述

    未来数据迭代工具的商机

    • 数据和模型迭代的接口
    • 帮助实验性切换的数据迭代工具
    • 数据作为跨用户专业技能的共享连接
    • 从数据编程中可视化概率标签
    • 限制:其他数据类型的可视化
    展开全文
  • Manifold是用于机器学习的与模型无关的视觉调试工具。 考虑到ML算法固有的不透明性,了解ML模型的性能和行为是一个不容易的过程。 性能摘要统计信息(如AUC,RMSE和其他统计信息)对于识别模型出了什么问题或如何...
  • 该项目包含一个干净优美的图形用户界面(GUI),该界面通过使用不同的Python库与8种机器学习模型和数据可视化工具进行交互。 在Rutgers,我们了解到Python是一种很棒的通用语言,它为所有专业的开发人员提供了极大的...
  • tensorboard的可视化及模型可视化

    万次阅读 2017-08-15 10:14:03
    待整理How to Check-Point Deep ...Tensorboard 中文社区谷歌发布TensorBoard API,让你自定义机器学习中的可视化 查找tensorflow安装的位置pip show tensorflow-gpuName: tensorflow-gpu Version: 1.0.1 Summary: Tens

    待整理

    How to Check-Point Deep Learning Models in Keras


    LossWise
    Tensorboard 中文社区


    谷歌发布TensorBoard API,让你自定义机器学习中的可视化


    查找tensorflow安装的位置


    pip show tensorflow-gpu
    Name: tensorflow-gpu
    Version: 1.0.1
    Summary: TensorFlow helps the tensors flow
    Home-page: http://tensorflow.org/
    Author: Google Inc.
    Author-email: opensource@google.com
    License: Apache 2.0
    Location: /home/bids/.local/lib/python2.7/site-packages
    Requires: mock, numpy, protobuf, wheel, six

    或者

    python
    import tensorflow
    tensorflow.__path__
    dir(tensorflow)

    终止某个程序的进程

    pkill -f "tensorboard"

    什么是 TensorBoard


    TensorBoard 是 TensorFlow 上一个非常酷的功能,神经网络很多时候就像是个黑盒子,里面到底是什么样,是什么样的结构,是怎么训练的,可能很难搞清楚。而 TensorBoard 的作用就是可以把复杂的神经网络训练过程给可视化,可以更好地理解,调试并优化程序。
    TensorBoard可以将训练过程中的各种绘制数据展示出来,包括标量(scalars),图片(images),音频(Audio),计算图(graph),数据分布,直方图(histograms)和嵌入式向量。

    在 scalars 下可以看到 accuracy,cross entropy,dropout,layer1 和 layer2 的 bias 和 weights 等的趋势。
    在 images 和 audio 下可以看到输入的数据。展示训练过程中记录的图像和音频。
    在 graphs 中可以看到模型的结构。
    在 histogram 可以看到 activations,gradients 或者 weights 等变量的每一步的分布,越靠前面就是越新的步数的结果。展示训练过程中记录的数据的分布图
    distribution 和 histogram 是两种不同的形式,可以看到整体的状况。
    在 embedding 中可以看到用 PCA 主成分分析方法将高维数据投影到 3D 空间后的数据的关系。
    Event: 展示训练过程中的统计数据(最值,均值等)变化情况

    使用TensorBoard展示数据,需要在执行Tensorflow就算图的过程中,将各种类型的数据汇总并记录到日志文件中。然后使用TensorBoard读取这些日志文件,解析数据并生产数据可视化的Web页面,让我们可以在浏览器中观察各种汇总数据。


    汇总数据的日志--callbacks回调执行结果


    log_filepath = '/tmp/keras_log' 
    
    model.compile(loss='categorical_crossentropy', optimizer=SGD(lr=0.001), metrics=['accuracy'])    
    tb_cb = keras.callbacks.TensorBoard(log_dir=log_filepath, write_images=1, histogram_freq=1)  
    # 设置log的存储位置,将网络权值以图片格式保持在tensorboard中显示,设置每一个周期计算一次网络的  
    #权值,每层输出值的分布直方图  
    cbks = [tb_cb]  
    history = model.fit(X_train, Y_train, batch_size=batch_size, nb_epoch=nb_epoch,   
    verbose=1, callbacks=cbks, validation_data=(X_test, Y_test))  
    

    tensorboard 默认的slcar一栏只记录了训练集和验证集上的loss,如何想记录展示其他指标,在model.compile的metric中进行添加,例如:

    model.compile(  
          loss = 'mean_squared_error',  
          optimizer = 'sgd',  
          metrics= c('mae', 'acc')  # 可视化mae和acc  
        )  
    

    而在keras的call back模块中,tensorborad class类实现源码可以看出,keras默认将模型的所有层的所有weights, bias以及每一层输出的distribution, histogram等传送到tensorborad,方便在浏览器中观察网络的运行情况。实现源码如下:

        def set_model(self, model):  
            self.model = model  
            self.sess = K.get_session()  
            if self.histogram_freq and self.merged is None:  
                for layer in self.model.layers:  
    
                    for weight in layer.weights:  
                        tf.summary.histogram(weight.name, weight)  
                        if self.write_images:  
                            w_img = tf.squeeze(weight)  
                            shape = w_img.get_shape()  
                            if len(shape) > 1 and shape[0] > shape[1]:  
                                w_img = tf.transpose(w_img)  
                            if len(shape) == 1:  
                                w_img = tf.expand_dims(w_img, 0)  
                            w_img = tf.expand_dims(tf.expand_dims(w_img, 0), -1)  
                            tf.summary.image(weight.name, w_img)  
    
                    if hasattr(layer, 'output'):  
                        tf.summary.histogram('{}_out'.format(layer.name),  
                                             layer.output)  
            self.merged = tf.summary.merge_all()  

    可视化结果


    python /home/bids/.local/lib/python2.7/site-packages/tensorboard/tensorboard.py --logdir='/tmp/keras_log'
    Starting TensorBoard 54 at http://bids:6006
    (Press CTRL+C to quit)

    训练误差和测试误差在同一个图中(tensorflow)


    具体参看Windows下tensorflow的tensorboard的使用

    TensorBoard: Visualizing Learning

    使用Tensorboard查看训练过程

    TensorFlow深度学习笔记 Tensorboard入门
    Tensorflow 自带可视化Tensorboard使用方法 附项目代码

    学习TensorFlow,TensorBoard可视化网络结构和参数

    tensorflow中如何进行可视化和减轻过拟合

    TensorFlow-7-TensorBoard Embedding可视化

    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  
    
    FLAGS = None  
    
    
    def train():  
      # Import data  
      mnist = input_data.read_data_sets(FLAGS.data_dir,  
                                        one_hot=True,  
                                        fake_data=FLAGS.fake_data)  
    
      sess = tf.InteractiveSession()  
      # Create a multilayer model.  
    
      # Input placeholders  
      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')  
    
      with tf.name_scope('input_reshape'):  
        image_shaped_input = tf.reshape(x, [-1, 28, 28, 1])  
        tf.summary.image('input', image_shaped_input, 10)  
    
      # We can't initialize these variables to 0 - the network will get stuck.  
      def weight_variable(shape):  
        """Create a weight variable with appropriate initialization."""  
        initial = tf.truncated_normal(shape, stddev=0.1)  
        return tf.Variable(initial)  
    
      def bias_variable(shape):  
        """Create a bias variable with appropriate initialization."""  
        initial = tf.constant(0.1, shape=shape)  
        return tf.Variable(initial)  
    
      def variable_summaries(var):  
        """Attach a lot of summaries to a Tensor (for TensorBoard visualization)."""  
        with tf.name_scope('summaries'):  
          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.scalar('stddev', stddev)  
          tf.summary.scalar('max', tf.reduce_max(var))  
          tf.summary.scalar('min', tf.reduce_min(var))  
          tf.summary.histogram('histogram', var)  
    
      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.  
        """  
        # Adding a name scope ensures logical grouping of the layers in the graph.  
        with tf.name_scope(layer_name):  
          # This Variable will hold the state of the weights for the layer  
          with tf.name_scope('weights'):  
            weights = weight_variable([input_dim, output_dim])  
            variable_summaries(weights)  
          with tf.name_scope('biases'):  
            biases = bias_variable([output_dim])  
            variable_summaries(biases)  
          with tf.name_scope('Wx_plus_b'):  
            preactivate = tf.matmul(input_tensor, weights) + biases  
            tf.summary.histogram('pre_activations', preactivate)  
          activations = act(preactivate, name='activation')  
          tf.summary.histogram('activations', activations)  
          return activations  
    
      hidden1 = nn_layer(x, 784, 500, 'layer1')  
    
      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)  
    
      # Do not apply softmax activation yet, see below.  
      y = nn_layer(dropped, 500, 10, 'layer2', act=tf.identity)  
    
      with tf.name_scope('cross_entropy'):  
        # The raw formulation of cross-entropy,  
        #  
        # tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(tf.softmax(y)),  
        #                               reduction_indices=[1]))  
        #  
        # can be numerically unstable.  
        #  
        # So here we use tf.nn.softmax_cross_entropy_with_logits on the  
        # raw outputs of the nn_layer above, and then average across  
        # the batch.  
        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('cross_entropy', cross_entropy)  
    
      with tf.name_scope('train'):  
        train_step = tf.train.AdamOptimizer(FLAGS.learning_rate).minimize(  
            cross_entropy)  
    
      with tf.name_scope('accuracy'):  
        with tf.name_scope('correct_prediction'):  
          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)  
    
      # Merge all the summaries and write them out to /tmp/tensorflow/mnist/logs/mnist_with_summaries (by default)  
      merged = tf.summary.merge_all()  
      train_writer = tf.summary.FileWriter(FLAGS.log_dir + '/train', sess.graph)  
      test_writer = tf.summary.FileWriter(FLAGS.log_dir + '/test')  
      tf.global_variables_initializer().run()  
    
      # Train the model, and also write summaries.  
      # Every 10th step, measure test-set accuracy, and write test summaries  
      # All other steps, run train_step on training data, & add training summaries  
    
      def feed_dict(train):  
        """Make a TensorFlow feed_dict: maps data onto Tensor placeholders."""  
        if train or FLAGS.fake_data:  
          xs, ys = mnist.train.next_batch(100, fake_data=FLAGS.fake_data)  
          k = FLAGS.dropout  
        else:  
          xs, ys = mnist.test.images, mnist.test.labels  
          k = 1.0  
        return {x: xs, y_: ys, keep_prob: k}  
    
      for i in range(FLAGS.max_steps):  
        if i % 10 == 0:  # Record summaries and test-set 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:  # Record train set summaries, and train  
          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()  
    
    
    def main(_):  
      if tf.gfile.Exists(FLAGS.log_dir):  
        tf.gfile.DeleteRecursively(FLAGS.log_dir)  
      tf.gfile.MakeDirs(FLAGS.log_dir)  
      train()  
    
    
    if __name__ == '__main__':  
      parser = argparse.ArgumentParser()  
      parser.add_argument('--fake_data', nargs='?', const=True, type=bool,  
                          default=False,  
                          help='If true, uses fake data for unit testing.')  
      parser.add_argument('--max_steps', type=int, default=1000,  
                          help='Number of steps to run trainer.')  
      parser.add_argument('--learning_rate', type=float, default=0.001,  
                          help='Initial learning rate')  
      parser.add_argument('--dropout', type=float, default=0.9,  
                          help='Keep probability for training dropout.')  
      parser.add_argument('--data_dir', type=str, default='/tmp/tensorflow/mnist/input_data',  
                          help='Directory for storing input data')  
      parser.add_argument('--log_dir', type=str, default='/tmp/tensorflow/mnist/logs/mnist_with_summaries',  
                          help='Summaries log directory')  
      FLAGS, unparsed = parser.parse_known_args()  
      tf.app.run(main=main, argv=[sys.argv[0]] + unparsed)

    上面是官方给出的例子实现,下面我给出要修改的地方:

        parser.add_argument('--log_dir', type=str, default='/tmp/tensorflow/mnist/logs/mnist_with_summaries',  
                             help='Summaries log directory')  

    修改后的代码:

    parser.add_argument('--log_dir', type=str, default='C:/tmp/tensorflow/mnist/logs/mnist_with_summaries',
                          help='Summaries log directory')

    这里目录取决你放在哪个盘,这里我放在C盘,打开cmd。在终端输入,如下图:

    tensorboard --logdir= C:\tmp\tensorflow\mnist\logs\mnist_with_summaries

    打开Google Chrome输入localhost:6006,结果如下图

    这里写图片描述


    Display Deep Learning Model Training History in Keras


    model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
    # Fit the model
    history = model.fit(X, Y, validation_split=0.33, epochs=150, batch_size=10, verbose=0)
    # list all data in history
    print(history.history.keys())
    # summarize history for accuracy
    plt.plot(history.history['acc'])
    plt.plot(history.history['val_acc'])
    plt.title('model accuracy')
    plt.ylabel('accuracy')
    plt.xlabel('epoch')
    plt.legend(['train', 'test'], loc='upper left')
    plt.tight_layout()
    plt.savefig('accuracyVSepoch.png')
    plt.show()
    # summarize history for loss
    plt.plot(history.history['loss'])
    plt.plot(history.history['val_loss'])
    plt.title('model loss')
    plt.ylabel('loss')
    plt.xlabel('epoch')
    plt.legend(['train', 'test'], loc='upper left')
    plt.tight_layout()
    plt.savefig('lossVSepoch.png')
    plt.show()

    就会得到如下类似的图

    这里写图片描述

    这里写图片描述


    Keras输出的loss,val这些值如何保存到文本中去


    hist=model.fit(train_set_x,train_set_y,batch_size=256,shuffle=True,nb_epoch=nb_epoch,validation_split=0.1)
    with open('log_sgd_big_32.txt','w') as f:
        f.write(str(hist.history))

    同时可视化多个模型运行结果


    第一个模型的运行结果

    log_filepath = '/tmp/keras_log/run_a' 
    
    model.compile(loss='categorical_crossentropy', optimizer=SGD(lr=0.001), metrics=['accuracy'])    
    tb_cb = keras.callbacks.TensorBoard(log_dir=log_filepath, write_images=1, histogram_freq=1)  
    # 设置log的存储位置,将网络权值以图片格式保持在tensorboard中显示,设置每一个周期计算一次网络的  
    #权值,每层输出值的分布直方图  
    batch_size=10,
    cbks = [tb_cb],  
    history = model.fit(X_train, Y_train, batch_size=batch_size, nb_epoch=nb_epoch,   
    verbose=1, callbacks=cbks, validation_data=(X_test, Y_test))  

    第二个模型的运行结果

    log_filepath = '/tmp/keras_log/run_b' 
    
    model.compile(loss='categorical_crossentropy', optimizer=adam(lr=0.001), metrics=['accuracy'])    
    tb_cb = keras.callbacks.TensorBoard(log_dir=log_filepath, write_images=1, histogram_freq=1)  
    # 设置log的存储位置,将网络权值以图片格式保持在tensorboard中显示,设置每一个周期计算一次网络的  
    #权值,每层输出值的分布直方图
    batchsize=8  
    cbks = [tb_cb],  
    history = model.fit(X_train, Y_train, batch_size=batch_size, nb_epoch=nb_epoch,   
    verbose=1, callbacks=cbks, validation_data=(X_test, Y_test))  

    可视化结果

    python /home/bids/.local/lib/python2.7/site-packages/tensorboard/tensorboard.py --logdir='/tmp/keras_log'
    Starting TensorBoard 54 at http://bids:6006
    (Press CTRL+C to quit)

    就会看到如下类似的图像
    这里写图片描述


    实时可视化


    jiandanjinxin-tensorflow-mnist-tutorial
    没有博士学位如何玩转TensorFlow和深度学习

    Visualizing MNIST: An Exploration of Dimensionality Reduction
    Visualizing Representations: Deep Learning and Human Beings


    Hyperparameter Search


    jiandanjinxin-tf-dev-summit-tensorboard-tutoria

    TensorFlow-dev-summit:TF发展历史以及有趣的应用


    经典示例 1


    #-*- coding: UTF-8 -*-
    from __future__ import division
    from __future__ import print_function
    from __future__ import unicode_literals
    
    import gzip
    import struct
    import numpy as np
    from sklearn.linear_model import LogisticRegression
    from sklearn import preprocessing
    from sklearn.metrics import accuracy_score
    import tensorflow as tf
    
    # MNIST data is stored in binary format, 
    # and we transform them into numpy ndarray objects by the following two utility functions
    def read_image(file_name):
        with gzip.open(file_name, 'rb') as f:
            buf = f.read()
            index = 0
            magic, images, rows, columns = struct.unpack_from('>IIII' , buf , index)
            index += struct.calcsize('>IIII')
    
            image_size = '>' + str(images*rows*columns) + 'B'
            ims = struct.unpack_from(image_size, buf, index)
    
            im_array = np.array(ims).reshape(images, rows, columns)
            return im_array
    
    def read_label(file_name):
        with gzip.open(file_name, 'rb') as f:
            buf = f.read()
            index = 0
            magic, labels = struct.unpack_from('>II', buf, index)
            index += struct.calcsize('>II')
    
            label_size = '>' + str(labels) + 'B'
            labels = struct.unpack_from(label_size, buf, index)
    
            label_array = np.array(labels)
            return label_array
    
    
    print("Start processing MNIST handwritten digits data...")
    train_x_data = read_image("MNIST_data/train-images-idx3-ubyte.gz")
    print(type(train_x_data),train_x_data.dtype, train_x_data.shape)
    print(train_x_data.max(), train_x_data.min()) 
    train_y_data = read_label("MNIST_data/train-labels-idx1-ubyte.gz")
    print(type(train_y_data),train_y_data.dtype, train_y_data.shape)
    print(train_y_data.max(), train_y_data.min())
    test_x_data = read_image("MNIST_data/t10k-images-idx3-ubyte.gz")
    print(type(test_x_data),test_x_data.dtype, test_x_data.shape)
    print(test_x_data.max(), test_x_data.min()) 
    test_x_data = test_x_data.reshape(test_x_data.shape[0], -1).astype(np.float32)
    print(type(test_x_data),test_x_data.dtype, test_x_data.shape)
    print(test_x_data.max(), test_x_data.min()) 
    test_y_data = read_label("MNIST_data/t10k-labels-idx1-ubyte.gz")
    print(type(test_y_data),test_y_data.dtype, test_y_data.shape)
    print(test_y_data.max(), test_y_data.min())
    train_x_minmax = train_x_data / 255.0
    test_x_minmax = test_x_data / 255.0
    # We evaluate the softmax regression model by sklearn first
    eval_sklearn = True
    if eval_sklearn:
        print("Start evaluating softmax regression model by sklearn...")
        reg = LogisticRegression(solver="lbfgs", multi_class="multinomial")
        reg.fit(train_x_minmax, train_y_data)
        #np.savetxt('coef_softmax_sklearn.txt', reg.coef_, fmt='%.6f')  # Save coefficients to a text file
        test_y_predict = reg.predict(test_x_minmax)
        print("Accuracy of test set: %f" % accuracy_score(test_y_data, test_y_predict))
    
    eval_tensorflow = True
    batch_gradient = False
    
    def variable_summaries(var):
        with tf.name_scope('summaries'):
            mean = tf.reduce_mean(var)
            tf.summary.scalar('mean', mean)
            stddev = tf.sqrt(tf.reduce_mean(tf.square(var - mean)))
            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)
    
    if eval_tensorflow:
        print("Start evaluating softmax regression model by tensorflow...")
        # reformat y into one-hot encoding style
        lb = preprocessing.LabelBinarizer()
        lb.fit(train_y_data)
        train_y_data_trans = lb.transform(train_y_data)
        test_y_data_trans = lb.transform(test_y_data)
    
        x = tf.placeholder(tf.float32, [None, 784])
        with tf.name_scope('weights'):
            W = tf.Variable(tf.zeros([784, 10]))
            variable_summaries(W)
        with tf.name_scope('biases'):
            b = tf.Variable(tf.zeros([10]))
            variable_summaries(b)
        with tf.name_scope('Wx_plus_b'):
            V = tf.matmul(x, W) + b
            tf.summary.histogram('pre_activations', V)
        with tf.name_scope('softmax'):
            y = tf.nn.softmax(V)
            tf.summary.histogram('activations', y)
    
        y_ = tf.placeholder(tf.float32, [None, 10])
    
        with tf.name_scope('cross_entropy'):
            loss = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))
            tf.summary.scalar('cross_entropy', loss)
    
        with tf.name_scope('train'):
            optimizer = tf.train.GradientDescentOptimizer(0.5)
            train = optimizer.minimize(loss)
    
        with tf.name_scope('evaluate'):
            with tf.name_scope('correct_prediction'):
                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)
    
        init = tf.global_variables_initializer()
    
        sess = tf.Session()
        sess.run(init)
    
        merged = tf.summary.merge_all()
        train_writer = tf.summary.FileWriter('/tmp/log/train', sess.graph)
        test_writer = tf.summary.FileWriter('/tmp/log/test')
    
        if batch_gradient:
            for step in range(300):
                sess.run(train, feed_dict={x: train_x_minmax, y_: train_y_data_trans})
                if step % 10 == 0:
                    print("Batch Gradient Descent processing step %d" % step)
            print("Finally we got the estimated results, take such a long time...")
        else:
            for step in range(1000):
                if step % 10 == 0:
                    summary, acc = sess.run([merged, accuracy], feed_dict={x: test_x_minmax, y_: test_y_data_trans})
                    test_writer.add_summary(summary, step)
                    print("Stochastic Gradient Descent processing step %d accuracy=%.2f" % (step, acc))
                else:
                    sample_index = np.random.choice(train_x_minmax.shape[0], 100)
                    batch_xs = train_x_minmax[sample_index, :]
                    batch_ys = train_y_data_trans[sample_index, :]
                    summary, _ = sess.run([merged, train], feed_dict={x: batch_xs, y_: batch_ys})
                    train_writer.add_summary(summary, step)
    
        #np.savetxt('coef_softmax_tf.txt', np.transpose(sess.run(W)), fmt='%.6f')  # Save coefficients to a text file
        print("Accuracy of test set: %f" % sess.run(accuracy, feed_dict={x: test_x_minmax, y_: test_y_data_trans}))

    转自:TensorFlow学习笔记(7):TensorBoard——Tensor与Graph可视化


    经典示例 2


    import tensorflow as tf
    import numpy as np
    
    tf.set_random_seed(1)
    np.random.seed(1)
    
    # fake data
    x = np.linspace(-1, 1, 100)[:, np.newaxis]          # shape (100, 1)
    noise = np.random.normal(0, 0.1, size=x.shape)
    y = np.power(x, 2) + noise                          # shape (100, 1) + some noise
    
    with tf.variable_scope('Inputs'):
        tf_x = tf.placeholder(tf.float32, x.shape, name='x')
        tf_y = tf.placeholder(tf.float32, y.shape, name='y')
    
    with tf.variable_scope('Net'):
        l1 = tf.layers.dense(tf_x, 10, tf.nn.relu, name='hidden_layer')
        output = tf.layers.dense(l1, 1, name='output_layer')
    
        # add to histogram summary
        tf.summary.histogram('h_out', l1)
        tf.summary.histogram('pred', output)
    
    loss = tf.losses.mean_squared_error(tf_y, output, scope='loss')
    train_op = tf.train.GradientDescentOptimizer(learning_rate=0.5).minimize(loss)
    tf.summary.scalar('loss', loss)     # add loss to scalar summary
    
    sess = tf.Session()
    sess.run(tf.global_variables_initializer())
    
    writer = tf.summary.FileWriter('./log', sess.graph)     # write to file
    merge_op = tf.summary.merge_all()                       # operation to merge all summary
    
    for step in range(100):
        # train and net output
        _, result = sess.run([train_op, merge_op], {tf_x: x, tf_y: y})
        writer.add_summary(result, step)
    

    Tensorflow-Tutorial/tutorial-contents/305_tensorboard.py


    逐层可视化


    卷积神经网络实战(可视化部分)——使用keras识别猫咪
    Visualizing parts of Convolutional Neural Networks using Keras and Cats
    All code is on Github: https://github.com/erikreppel/visualizing_cnns

    这里写图片描述

    这张图长400像素宽320像素,有三个通道(rgb)的颜色。
    那么经过一层卷积运算之后会变成什么样子呢?

    这里写图片描述

    这是用一个3*3的卷积核和三个滤波器处理的效果(如果我们有超过3个的滤波器,那么我可以画出猫的2d图像。更高维的话就很难处理)
    我们可以看到,图中的猫非常的模糊,因为我们使用了一个随机的初始值,而且我们还没有训练网络。他们都在彼此的顶端,即使每层都有细节,我们将无法看到它。但我们可以制作出与眼睛和背景相同颜色的猫的区域。如果我们将内核大小增加到10x10,会发生什么呢?

    这里写图片描述

    我们可以看到,由于内核太大,我们失去了一些细节。还要注意,从数学角度来看,卷积核越大,图像的形状会变得越小。
    如果我们把它压扁一点,我们可以更好的看到色彩通道会发生什么?

    这里写图片描述

    这张看起来好多了!现在我们可以看到我们的过滤器看到的一些事情。看起来红色替换掉了黑色的鼻子和黑色眼睛,蓝色替换掉了猫边界的浅灰色。我们可以开始看到图层如何捕获照片中的一些更重要的细节。

    这里写图片描述

    如果我们增加内核大小,我们得到的细节就会越来越明显,当然图像也比其他两个都小。

    增加一个激活层

    这里写图片描述

    我们通过添加一个relu,去掉了很多不是蓝色的部分。

    增加一个池化层

    我们添加一个池化层(摆脱激活层最大限度地让图片更加更容易显示)。

    这里写图片描述

    正如预期的那样,猫咪变成了斑驳的,而我们可以让它更加斑驳。

    这里写图片描述

    现在图片大约成了原来的三分之一。

    激活和最大池化

    这里写图片描述

    LeNet

    如果我们将猫咪的图片放到LeNet模型中做卷积和池化,那么效果会怎么样呢?

    这里写图片描述

    ConvNets功能强大,因为它们能够提取图像的核心特征,并使用这些特征来识别包含其中的特征的图像。即使我们的两层CNN,我们也可以开始看到网络正在对猫的晶须,鼻子和眼睛这样的地区给予很多的关注。这些是让CNN将猫与鸟区分开的特征的类型。
    CNN是非常强大的,虽然这些可视化并不完美,但我希望他们能够帮助像我这样正在尝试更好地理解ConvNets的人。


    可视化模型


    keras.utils.vis_utils模块提供了画出Keras模型的函数(利用graphviz)

    该函数将画出模型结构图,并保存成图片:

    from keras.utils import plot_model
    plot_model(model, to_file='model.png')

    plot_model接收两个可选参数:

    show_shapes:指定是否显示输出数据的形状,默认为False
    show_layer_names:指定是否显示层名称,默认为True
    

    我们也可以直接获取一个pydot.Graph对象,然后按照自己的需要配置它,例如,如果要在ipython中展示图片

    from IPython.display import SVG
    from keras.utils.vis_utils import model_to_dot
    
    SVG(model_to_dot(model).create(prog='dot', format='svg'))

    【Tips】依赖 pydot-ng 和 graphviz,若出现错误,用命令行输入pip install pydot-ng & brew install graphviz


    keras回调函数中的Tensorboard


    keras.callbacks.TensorBoard(log_dir='./Graph', histogram_freq=0,  
              write_graph=True, write_images=True)
    
    tbCallBack = keras.callbacks.TensorBoard(log_dir='./Graph', histogram_freq=0, write_graph=True, write_images=True)
    ...
    model.fit(...inputs and parameters..., callbacks=[tbCallBack])
    tensorboard --logdir path_to_current_dir/Graph 

    或者

    from keras.callbacks import TensorBoard
    
    tensorboard = TensorBoard(log_dir='./logs', histogram_freq=0,
                              write_graph=True, write_images=False)
    # define model
    model.fit(X_train, Y_train,
              batch_size=batch_size,
              epochs=nb_epoch,
              validation_data=(X_test, Y_test),
              shuffle=True,
              callbacks=[tensorboard])

    https://stackoverflow.com/questions/42112260/how-do-i-use-the-tensorboard-callback-of-keras


    参考文献


    Display Deep Learning Model Training History in Keras

    Edward-Tensorboard

    详解TensorBoard如何调参
    https://gist.github.com/dandelionmane/4f02ab8f1451e276fea1f165a20336f1#file-mnist-py

    TensorFlow深度学习笔记 Tensorboard入门

    Keras中文文档-模型可视化
    极客学院-TensorBoard:可视化学习

    Tensorboard 可视化之图层

    Tensorboard 可视化之训练过程

    TensorBoard可视化详解

    TensorFlow学习笔记(七):TensorBoard可视化助手

    https://www.tensorflow.org/get_started/summaries_and_tensorboard
    https://www.tensorflow.org/get_started/summaries_and_tensorboard
    https://www.youtube.com/watch?v=eBbEDRsCmv4

    How do I use the Tensorboard callback of Keras?
    keras tensorboard的使用, 设置GPU使用的内存
    tensorboard的一些问题
    模型可视化
    Keras中文文档

    卷积神经网络实战(可视化部分)——使用keras识别猫咪
    Visualizing parts of Convolutional Neural Networks using Keras and Cats
    All code is on Github: https://github.com/erikreppel/visualizing_cnns

    展开全文
  • Netron 是神经网络、深度学习与机器学习模型可视化工具。 1.在网页端直接使用(适合使用模型结构脚本文件) Step1.输入网址:https://lutzroeder.github.io/netron/ 网页加载... 完成后见到如下界面: Step2....

    Netron 是神经网络、深度学习与机器学习模型的可视化工具。

    1.在网页端直接使用(适合使用模型结构脚本文件)

    Step1.输入网址:https://lutzroeder.github.io/netron/

    网页加载...

    完成后见到如下界面:

    Step2.点击 Open Model,上传模型结构脚本文件

    即可见到清晰的网络结构图,点击可查看详细参数信息。

    点击左上角菜单,可以输出png图片格式的网络结构图文件。

    2.下载程序,离线使用

    适用于加载较大的模型文件,操作与网页版相同。

    各个操作系统(支持Ubantu,Mac,Windows)对应的安装方法见github项目主页的README.

    Github 项目 - https://github.com/lutzroeder/Netron
    作者:lutzroeder
    官网:https://www.lutzroeder.com/ai/

     

    Netron 支持的框架和文件类型

    ONNX (.onnx, .pb, .pbtxt),
    Keras (.h5, .keras),
    Core ML (.mlmodel),
    Caffe (.caffemodel, .prototxt),
    Caffe2 (predict_net.pb),
    Darknet (.cfg),
    MXNet (.model, -symbol.json),
    Barracuda (.nn), ncnn (.param),
    Tengine (.tmfile),
    TNN (.tnnproto),
    UFF (.uff) ,
    TensorFlow Lite (.tflite).

     

    正在开发中,相应的支持可能不太稳定。

    TorchScript (.pt, .pth),
    PyTorch (.pt, .pth),
    Torch (.t7),
    Arm NN (.armnn),
    BigDL (.bigdl, .model),
    Chainer (.npz, .h5),
    CNTK (.model, .cntk),
    Deeplearning4j (.zip),
    MediaPipe (.pbtxt),
    ML.NET (.zip),
    MNN (.mnn),
    PaddlePaddle (.zip, _model_),
    OpenVINO (.xml),
    scikit-learn (.pkl),
    TensorFlow.js (model.json, .pb),
    TensorFlow (.pb, .meta, .pbtxt, .ckpt, .index).

    展开全文
  • 前不久,JetBrains团队发布了Datalore,这是一款基于云的web应用程序,用于构建机器学习模型并在Python中创建丰富的可视化。最新的测试版本旨在简化构建机器学习模型的流程,并帮助开发人员进行数据分析。由于...
  • 我们的Web应用程序为研究人员提供了一个“无需编写代码,无需安装”的平台,可以上传图像并将聚类结果与流行的机器学习模型和多种学习算法进行比较,从而减少了使用ML进行实验和原型制作的时间。 当前没有可用于快速...
  • 机器学习模型应用以及模型优化的一些思路

    万次阅读 多人点赞 2017-03-09 19:55:45
    本文会介绍如何应用机器学习模型来构建一个智能应用的通用的过程以及过程中每个环节一些实践性的思路,包括问题界定和定义、 label标注的定义、 数据样本的筛选和构造、 选择机器学习算法、 确定模型性能的度量...
  • 深度学习-71: Tensorflow的架构、模型可视化和案例库。文本介绍Tensorflow的架构,Tensorflow内置数据集,Tensorflow内置模型、内置可视化支持和相关在线资源。Tensorflow一个高度模块化的神经网络库,支持GPU和...
  • 它使机器学习研究人员和数据科学家可以大量使用平行绘图来分析相关性并观察高维数据中的模式。 HiPlot:高维可视化变得容易 什么是平行图? 平行图是将高维或多元数据可视化的便捷方法之一。 · 对于n个...
  • 深度学习-72: PyTorch的架构、模型可视化和案例库。文本介绍PyTorch的架构,PyTorch内置数据集,PyTorch内置模型、PyTorch的可视化支持和相关在线资源。PyTorch(Caffe2)通过混合前端,分布式训练以及工具和库生态...
  • 机器学习模型训练全流程!

    千次阅读 2020-08-09 22:03:47
    Datawhale干货译者:张峰,安徽工业大学,Datawhale成员周末在家无聊闲逛github,发现一个很有趣的开源项目,作者用手绘图的方式讲解了机器学习模型构建的全流程,逻辑...
  • 机器学习模型可解释性的详尽介绍

    千次阅读 多人点赞 2019-11-26 12:22:00
    机器之心平台来源:腾讯技术工程模型可...本文对机器学习模型可解释性相关资料汇总survey。综述机器学习业务应用以输出决策判断为目标。可解释性是指人类能够理解决策原因的程度。机器学习模型的可解释性越高,人...
  • 多元线性回归程序示例 类似的,我们也可以实现多元线性回归。这里,我们需要创建多个特征(x),我们也可以像之前程序那样,随机生成多个特征,不过,这里,我们使用sklearn库提供的更方面的方法。 from sklearn....
  • 2、线性分类器的实现原理3、设计线性分类器的主要步骤4、Fisher线性判别二、例题1–鸢尾花数据集的分类可视化及预测1、准备鸢尾花数据集2、打开jupyter进行python环境创建3、编写鸢尾花数据集的分类可视化代码4、...
  • 提高机器学习模型性能的五个关键方法

    万次阅读 多人点赞 2018-09-08 11:52:10
    如何提高机器学习模型性能, 可从五个关键方面入手。 1. 数据预处理 2. 特征工程 3. 机器学习算法 4. 模型集成与融合 5. 数据增强 以下是各个方面的具体分析和方法: [ 说明:1、这里主要是各个关键方法的...
  • 有助于理解模型的实用工具 这是完整的代码:只需复制并粘贴到Jupyter Notebook或Python脚本中,替换为您的数据并运行: from sklearn.datasets import load_iris iris = load_iris() # 模型(也可以使用单一决策...
  • 机器学习15】决策树模型详解

    千次阅读 多人点赞 2020-09-19 20:12:26
    模型基本流程二、熵的作用三、决策树构造实例四、信息增益率和gini系数五、剪枝方法六、分类、回归任务七、树模型可视化展示八、决策边界展示分析九、决策树预剪枝常用参数十、回归树模型总结 前言 随着人工智能...
  • 可视化图表让机器学习更简单:特征分析
  • 使用机器学习模型自动进行思想聚类 ML设计应用程序: 头脑风暴词嵌入聚类 该项目的主要目的是开发和优化单词嵌入的聚类模型,以协助头脑风暴任务。 预训练词嵌入 Busca mejores alternativas para modelos ...
  • 创建一个Web应用程序可视化方式与使用机器学习检测到的对象进行交互 在此代码模式中,我们将使用来自的之一,在该交易所中,开发人员可以找到并尝试使用开源深度学习模型。 具体来说,我们将使用创建一个Web应用...
  • 前言:本人也是刚刚入门机器学习,就像入门很多语言一样,第一个程序总是Hello World 。机器学习也不然,入门机器学习的第一个程序就是感知机啦。感知机是二类线性分类模型,输出的值为{+1, -1}两种类型,感知机是...
  • 机器学习模型部署的三种方法

    千次阅读 2020-08-13 10:49:29
    “企业机器学习需要从数据工程和数据平台的角度看待大局[...],”贾斯汀·诺曼(Justin Norman)在今年巴塞罗那的DataWorks峰会上关于机器学习模型的部署的演讲中说。实际上,工业机器学习系统是庞大数据基础架构的...
  • 在python中使用SageMaker Debugger进行机器学习模型的开发调试 如果你从事软件开发,你就会知道 Bug 是生活的一部分。当你开始你的项目时,Bug 就可能存在,当你把你的产品交付给客户时,Bug 也可能存在。在过去的...
  • Model Builder是一个简单的UI工具,可在本地运行,以供开发人员在应用程序中构建,训练和运送自定义机器学习模型。 。 没有ML专业知识的开发人员可以使用此简单的可视化界面连接到他们存储在文件,SQL Server等中的...
  • RapidFlow可用于使用已实现的功能(无需编写代码)来创建,配置和部署机器学习模型,并在几分钟内启动API。 它可用于将模型实时应用于来自连接对象的各种数据源,数据库或流。 RapidFlow使用Jupyter作为其后端...
  • Interview:机器学习算法工程师求职九大必备技能之【数学基础、工程能力、特征工程、模型评估、优化算法、机器学习基本概念、经典机器学习模型、深度学习模型、业务与应用】(建议收藏,持续更新) 目录 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 37,355
精华内容 14,942
关键字:

机器学习模型可视化程序