深度学习框架 订阅
在开始深度学习项目之前,选择一个合适的框架是非常重要的,因为选择一个合适的框架能起到事半功倍的作用。研究者们使用各种不同的框架来达到他们的研究目的,侧面印证出深度学习领域百花齐放。全世界最为流行的深度学习框架有PaddlePaddle、Tensorflow、Caffe、Theano、MXNet、Torch和PyTorch。 展开全文
在开始深度学习项目之前,选择一个合适的框架是非常重要的,因为选择一个合适的框架能起到事半功倍的作用。研究者们使用各种不同的框架来达到他们的研究目的,侧面印证出深度学习领域百花齐放。全世界最为流行的深度学习框架有PaddlePaddle、Tensorflow、Caffe、Theano、MXNet、Torch和PyTorch。
信息
特    点
开源
本    质
作    用
降低了深度学习研究的入门门槛
中文名
深度学习框架
基本释义
用于深度学习的框架
外文名
Deep learning framework
深度学习框架概述
在深度学习初始阶段,每个深度学习研究者都需要写大量的重复代码。为了提高工作效率,这些研究者就将这些代码写成了一个框架放到网上让所有研究者一起使用。接着,网上就出现了不同的框架。随着时间的推移,最为好用的几个框架被大量的人使用从而流行了起来。 [1]  全世界最为流行的深度学习框架有PaddlePaddle、Tensorflow、Caffe、Theano、MXNet、Torch和PyTorch。
收起全文
精华内容
参与话题
问答
  • 深度学习框架Tensorflow案例实战视频培训课程概况: Tensorflow是谷歌开源的深度学习(包括机器学习)框架,伴随着人工智能业的兴盛其大名早已响彻云霄。本课程从Tensorflow安装开始讲起,从基本计算结构到深度学习...
  • TF学习——TensorFlow:深度学习框架TensorFlow & TensorFlow-GPU的简介、安装详细攻略 相关文章TF学习——DL框架之Tensorflow:Tensorflow的简介、安装、使用方法之详细攻略 目录 TensorFlow的简介 ...

    TF学习——TensorFlow:深度学习框架TensorFlow & TensorFlow-GPU的简介、安装详细攻略

     

     

    目录

    TensorFlow的简介

    TensorFlow的安装

    1、tensorflow的安装

    20190514更新

    20190514-1851更新

    20200529更新后成功

    2、tensorflow-gpu的安装

    20180928-2128 更新

    20181010更新


     

    相关文章
    TF学习——DL框架之Tensorflow:Tensorflow的简介、安装、使用方法之详细攻略

     

    TensorFlow的简介

          TensorFlow 是一种采用数据流图(data flow graphs),用于数值计算的开源软件库。其中 Tensor 代表传递的数据为张量(多维数组),Flow 代表使用计算图进行运算。数据流图用「结点」(nodes)和「边」(edges)组成的有向图来描述数学运算。「结点」一般用来表示施加的数学操作,但也可以表示数据输入的起点和输出的终点,或者是读取/写入持久变量(persistent variable)的终点。边表示结点之间的输入/输出关系。这些数据边可以传送维度可动态调整的多维数据数组,即张量(tensor)。

     

    TensorFlow的安装

    1、tensorflow的安装

    tensorflow:https://pypi.org/project/tensorflow/

    pip install tensorflow

    20190514更新

    pip install --upgrade tensorflow

    更新后的结果

     

    20190514-1851更新

    pip install tensorflow==1.10.0
    pip install --user tensorflow==1.10.0    #出即错误,即采用绝对权限下载

    20200529更新后成功

    pip install --user tensorflow-1.11.0-cp36-cp36m-win_amd64.whl

     

     

    2、tensorflow-gpu的安装

    tensorflow-gpu:https://pypi.org/project/tensorflow-gpu/#files

    pip install --upgrade tensorflow-gpu

     

    20180928-2128 更新

    因为'tensorflow.python.keras' has no attribute 'Model'的原因升级tensorflow
    卸载tensorflow-1.8.0升级到tensorflow-1.11.0

    Win+R运行命令窗口,然后cmd进入dos环境,输入命令
    pip install tensorflow-gpu
    pip3 install --upgrade tensorflow-gpu

    20181010更新

    因为采用TF的GPU加速原因进行升级TensorFlow-GPU=1.11.0
    pip install -U tensorflow-gpu

     


    安装请参考:Py之TF/Cuda/Cudnn:Win10下安装深度学习框架Tensorflow+Cuda+Cudnn最简单最快捷最详细攻略

     

     

     

    展开全文
  • 深度学习框架Tensorflow学习

    千次阅读 2018-05-23 10:46:40
    1.基于Windows平台的Tensorflow安装2.Tensorflow优化器(1)在Tensorflow中一共有7种优化器,这7种优化器分别为: tf.train.GradientDescentOptimizer:对于初学者来说,使用该种方法就可以了; tf.train....

    1.基于Windows平台的Tensorflow安装

        在Windows平台下进行Tensorflow的安装,需要打开Windows PowerShell,在我的计算机上安装的Tensorflow版本为1.1.0rc2,网址为 https://pypi.org/project/tensorflow/1.1.0rc2/,安装时在Windows PowerShell下面输入pip install tensorflow==1.1.0rc2,进行自动安装,当缺少相关组件时,进行相应的安装。安装成功后,如下图所示:


        此时可以对是否安装成功进行测试,在Windows PowerShell下输入Python,进行Python工作环境,输入import tensorflow,如果安装成功,此时将不会出现错误信息。


    2.Tensorflow入门教程

       通过寻找函数的权值和偏置,从而来学习Tensorflow。在tensorflow中定义变量要用tf.Variable(),因此在利用Tensorflow进行训练时的步骤为:

        (1)定义损失函数;(2)定义优化器;(3)最小化损失函数;(4)初始化所有参数;(5)创建会话;(6)进行训练

       完整代码如下所示


    3.Tensorflow Session会话

        在Tensorflow中,Session特别重要,Session是用来进行命令执行的语句。本次通过矩阵相乘的例子来解释Session的会话。

    首先创建两个矩阵,之后利用tf.matmul进行矩阵的运算,创建Session,此时通过print(sess.run(result))可以打印出最后的结果,如果仅仅为print(result),打印不出来最后的结果,只能打印出结果的结构,由于两个矩阵分别为1*2和2*1因此最后结果为1*1,结果的类型为int型。

    完整代码如下所示:


    4.Tensorflow Variable变量

        在Tensorflow中,只有将变量定义为变量后,该变量才为变量,只有将常量定义为常量后,该常量才为常量,当在Tensorflow中定义了变量后,一定要进行初始化操作,并且对于变量的赋值,要利用tf.assign函数进行数值的叠加操作。具体代码如下所示。

    5.Tensorflow placeholder

        Tensorflow中的placeholder是变量的占位符,当利用了placeholder后,要在sess的run方法中,增加feed_dict字段,传入数值。具体的代码如下所示。


    6.Tensorflow activation_function 激励函数

        为了解决非线性问题,在Tensorflow中有如下的激励函数:Linear function,Step function,Ramp function,Softmax function等。其中relu为当输入小于0时,值为0,输入大于0时,为线性;dropout为了解决过拟合以及欠拟合问题;sigmoid常用于分类问题。


    7.Tensorflow 添加神经网络层

    添加神经网络函数,在该函数中,定义了权值,偏置以及激活函数的设置,最后返回定义完成后的神经网络参数。


    8.Tensorflow 建立神经网络

    本节利用第7节添加的神经网络层建立一个神经网络,在创建神经网络的时候会出现如下的问题:

    1.数据类型不匹配

        由于不同版本的Tensorflow会进行函数的更新,因此,会出现float64与float32数据格式不匹配的情况,此时要对数据进行格式转换,格式转换用numpy.float32()函数进行格式的转换。

    2.训练后的损失值为NAN

        这是由于loss计算后的值过小,同时选择的激活函数不适合,因此此时需要调整损失值的计算方式或者是更换激活函数或者是减小学习率,我这个是由于将tf.square()错打成了tf.sqrt()进行发现的这个问题。

        

    第一个红色的框是进行的格式转换,第二个红色的框是进行的输入数据格式的转换,第三个框是确保加入的噪声的维度与输入数据的维度相同。

    完整的代码如下所示:


    9.Tensorflow结果显示

        对于结果的显示,仅仅需要在8的所有代码里面加入下面方框中的语句就可以进行结果的显示,该结果的显示是动态进行显示的,为了能够进行动态的显示,使用plt.ion()函数,如果仅仅使用plt.show()函数,将仅仅会有静态的图像。
        首先需要通过x_data预测出数据,通过ax.plot()将预测的数据与x_data画出来,参数‘r-’代表红色的连线,线段的宽度为5,通过plt.pause()进行时间的暂停。首先删除原有的线,之后增加新的线。由于开始时没有线,会报错,因此采用try捕捉错误,捕捉后不进行任何的操作。

        注意,当在jupyter中进行如上操作时,会报错。


    因此,使用PyCharm进行如上的操作,结果如下所示。


    10.Tensorflow优化器

    (1)在Tensorflow中一共有7种优化器,这7种优化器分别为:   

       tf.train.GradientDescentOptimizer:对于初学者来说,使用该种方法就可以了;

        tf.train.AdadeltaOptimizer 

        tf.train.MomentumOptimizer:该种优化方法经常被用到,该种方法开始时也许会向错误的方向走,它是综合考虑上一步的结果。

        tf.train.AdagradOptimizer

        tf.train.AdamOptimizer:该种优化方法经常被用到

        tf.train.FtrlOptimizer

        tf.train.RMSPropOptimizer

    11.可视化神经网络----使用Tensorboard可视化 

    通过Tensorboard可视化神经网络的结构。首先看一下最后的结果,通过观看结果进行接下来的分析。


    在图中有五个大的节点,通过with tf.name_scope('layer'):定义节点with tf.name_scope('inputs'):节点的名字写在括号中间。将图的结构通过writer = tf.summary.FileWriter(r'G:/tmp/tensorflow/logs',graph=sess.graph)写到自己的路径中,由于Tensorflow版本升级,tf.train.SummaryWriter()被取消了,不同的版本函数会有不同,这点一定要注意,并且还要注意的是,这个最好是在PyCharm等编译器中进行编译,例如jupyter不能调出这个图。还要注意的是,通过Windows PowerShell输入如下的命令加载图结构:


    需要特别注意的是,不一定输入http://0.0.0.0:6060就可以,最好是输入http://localhost:6006/

    如果要对变量进行名字的赋值,在变量后面加上名字即可:


    最后每一部分的图像如下图所示




    12.可视化神经网络----使用Tensorboard可视化训练过程

     在利用Tensorflow进行可视化的过程中,新版本对可视化过程函数进行了名称的改变:

    tf.merge_all_summaries()改变为tf.summary.merge_all()

    tf.histogram_summary()改变为tf.summary.histogram()

    tf.scalar_summary()改变为tf.summary.scalar()

    tf.scalar_summary()改变为tf.summary.image()

    在新版本的Tensorflow中,可以观看如下的训练过程:


    如果想要观看SCALARS即观察模型的loss,需要做如下的事情:


    如果想要看DISTRIBUTIONS以及HISTOGRAMS,需要添加如下代码:


    最后要将所有的histogram进行打包操作:


    本文结果如下图所示:


    总结利用Tensorboard进行结果可视化的过程:

    (1)定义每一层:tf.name_scope(层的名字)

    (2)定义每一层中变量的名字:在定义的变量后面加上name字段

    (3)观察权值以及偏重的变化:tf.summary.histogram(随意名字,值)

    (4)观察训练时的损失值:tf.summary.scalar(随意名字,值)

    (5)将所有的值打包:merge = tf.summary.merge_all()

    (6)写入本地文件:write = tf.summary.FileWriter(路径,graph = sess.graph)

    (7)动态加载数据:result = sess.run(merge,feed_dict={xs:x_data,ys:y_data})

    (8)写入文件:write.add_summary(result,i)

    13.Tensorflow 分类学习

        以上所有说的都跟回归相关,下面要利用Tensorflow进行分类学习,分类学习用的是很老的数据库,分类学习的Hello World,MNIST数据库。

        代码如下:


        需要在路径的位置换成自己的路径,如果没有数据库的话,将会进行下载。


        定义了输入数据和输出数据,输入数据xs:28*28为原始数据中,每一个数据的大小,ys:10为采用one-hot编码的标签,本文使用softmax作为激励函数,激励函数输出的是概率值,最后定义损失函数。


    采用随机梯度下降法进行训练,最后每隔50个batch输出一次准确率,计算正确率的函数是compute_accuracy(),首先令prediction为全局变量,通过输入数据v_xs输出一个预测值,之后与真实值进行比较,得到最后的真正的预测值,其中tf.argmax(y_predict,1)为按照行进行查找,tf.cast(correct_predict,tf.float32)为将数据转换为浮点类型,最后得到数据的准确率。最终的准确率如下所示:


    14.Tensorflow 解决Overfitting问题

       为了避免机器学习中,出现过拟合以及欠拟合问题,使用dropout来解决Overfitting问题。  没有进行dropout的结果如下所示:


        加入了dropout之后的结果,dropout = 0.5:


        在利用Tensorboard进行结果显示的时候,有的时候会出现图形很乱的情况,如下所示:


        这个时候,需要我们重新在Window PowerShell中重新输入tensorboard --logdir = logs


        同时将原有生成的日志文件清除干净,重新打开网址,则恢复正常。

    15.Tensorflow CNN

        通过神经网络对MNIST进行训练,最高只能达到88%左右,这样的正确率明显不能满足现实的需要,因此采用卷积神经网络的方式对MNIST进行测试。

        在创建CNN时,需要进行权值的设定,偏置的设定,卷积层的设定,池化层的设定以及为了能够解决过拟合而进行的dropout,接下来分别对以上进行设定。

        (1)权值的设定

    def weightVariable(shape):
        init = tf.random_normal(shape,stddev=0.01)
    return tf.Variable(init)         

        (2)偏置的设定

    def biasVariable(shape):
        init = tf.random_normal(shape)
    return tf.Variable(init)

        (3)卷积层的设定

    def conv2d(x,W):
        return tf.nn.conv2d(x,W,strides=[1,1,1,1],padding='SAME')

        我们要注意的是,对于strides里面的参数设定,第一个参数一定是1,最后一个也一定是1,否则将会出现问题,即设定的形式为:[1,x_movement,y_movement,1]

        (4)池化层的设定

    def maxpool(x):
        return tf.nn.max_pool(x,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')

        我们要注意的是,对于maxpool里面的strides参数的设定,第一个以及最后一个参数一定是1,即设定形式为[1,x_movement,y_movement,1],对于池化方式来说,有最大值池化方式以及平均值池化方式,同时对于padding来说也有两种padding的方式。

        (5)dropout

    def dropout(x,keep):
        return tf.nn.dropout(x,keep)

        dropout是为了克服过拟合问题,因此通过采用dropout的方式进行,通过选择一部分神经元设定为不工作的方式来进行参数的设定。

        在进行了基本的参数功能设定后,搭建卷积神经网络: 

    def cnnLayer(classnum):
        #第一层
        W1 = weightVariable([3,3,3,32])#即卷积核为3*3大小,输入为3通道,输出为32通道
        b1 = biasVariable([32])#对应32个输出通道
        conv1 = tf.nn.relu(conv2d(x,W1)+b1)
        pool1 = maxPool(conv1)
        drop1 = dropout(pool1,keep_prob_5)
        #第二层
      W2 = weightVariable([3,3,32,64])#即卷积核为3*3大小,输入为32通道,输出为64通道
      b2 = biasVariable([64])#对应64个输出通道
      conv2 = tf.nn.relu(conv2d(drop1,W2)+b2)
      pool2 = maxPool(conv2)
      drop2 = dropout(pool2,keep_prob_5)
      #第三层
    W3 = weightVariable([3,3,64,64])#即卷积核为3*3大小,输入为64通道,输出为64通道
    b3 = biasVariable([64])#对应64个输出通道
    conv3 = tf.nn.relu(conv2d(drop2,W3)+b3)
    pool3 = maxPool(conv3)
    drop3 = dropout(pool3,keep_prob_75)
    在我们的程序中,需要对输入神经元与输出神经元的神经网络节点进行设置,输入图片为64*64大小的彩色图像,因此input = 64*64*3,将输入的图片进过第
    一层神经网络,设置第一层网络的卷积核大小为3*3,由于是彩色图像,因此图像的通道数为RGB,3通道,如果是灰度图像,此时的输入将为1通道的灰度图像,设
    置输出为32,即32个特征,之后将提取后的特征进行线性相加后进行非线性映射,之后对非线性映射后的结果,进行池化操作,池化操作的模板为2*2,进行最大值
    池化,为了防止过拟合,使用dropout的方式,最后经过以上的步骤后,图像变为了32*32*32;将32*32*32规模大小的图像输入第二层神经网络,同样经过以上的步
    骤,最后输出图像的规模大小为16*16*64,将第二层输出的图像输入到第三层神经网络,第三层神经网络的输入图片大小为16*16*64,经过同样的处理方式,结果
    为8*8*64,经过三次神经网络的处理,由原始的64*64*3的图像变为了8*8*64大小规模的图像。接下来,我们将8*8*64大小的图像输入到全连接层,全连接层的输
    
    入神经元个数为8*8*64,即4096个神经元,全连接神经元的输出为512个神经元,将512神经元网络进行reshape,成为1行512列的数据,之后输入分类层,分类层
    的输入为512,输入为将要分类的类别数。
        #全连接层,最后将drop3的结果输入到全连接层,在全连接层后面最后加入一个分类的层 
       Wf = weightVariable([8*8*64,512])
        bf = biasVariable([512])
        drop3_flat = tf.reshape(drop3,[-1,8*8*64])
        dense = tf.nn.relu(tf.matmul(drop3_flat,Wf)+bf)
        dropf = dropout(dense,keep_prob_75)
        #输出层
        Wout = weightVariable([512,classnum])
        bout = biasVariable([classnum])
        out = tf.add(tf.matmul(dropf,Wout),bout)
        return out

        对于上面红色字体标明的地方特别的重要,要仔细的进行理解。

        本文使用的网络模型为:input->conv1->maxpool1->conv2->maxpool2->conv3->maxpool3->全连接层->输出层

        对于每一层图像规模大小为:

    网络名称卷积模板(padding = ‘SAME’)图像规模
    input
    64*64*3
    conv13*364*64*32
    maxpool12*232*32*32
    conv23*332*32*64
    maxpool22*216*16*64
    conv33*316*16*64
    maxpool32*28*8*64
    全连接层
    reshape(4096)
    分类层
    类别个数

        利用以上的网络结构,进行数据的分类。

        在第13节,我们已经定义了传统的神经网络进行MNIST的识别,通过结果我们可以发现,最终的正确率仅仅能够达到88%左右,通过将传统的神经网络进行替换,替换成我们的CNN模型,利用CNN模型进行训练以及识别,我们可以发现,正确率明显高于浅层神经网络。为了防止过拟合问题,在每一层神经网络增加dropout,其中卷积层dropout = 0.5,全连接层dropout = 0.75。

        与第13的程序相比,程序变动的地方很少,为了能够将原始数据输入到神经网络中,需要将原始数据进行转换:

        xs = tf.placeholder(tf.float32,[None,28*28])
        之后对数据做如下处理
        x_image = tf.reshape(xs,[-1,28,28,1])

        由于增加了dropout,因此需要添加相应的代码如下:

        keep_prob_5 = tf.placeholder(float32)
        keep_prob_75 = tf.placeholder(float32)
        最后调用神经网络结构:
        prediction = cnnLayer(xs_image,keep_prob_5,keep_prob_75,classnum)

        由于增加了dropout,因此需要在训练的feed_dict中增加相应的属性参数,设置的属性参数如下:

        sess.run(train,feed_dict={xs:batch_xs,ys:batch_ys,keep_prob_5:0.5,keep_prob_75:0.75})

        对于其他的均不用更换。

        在实际的应用中,也许会出现最终的识别正确率并不改变,并且很小,这个时候,我们要对我们的网络进行调节,在我的实践中,发现正确率不变,由于没有在最后的分类层添加上非线性的约束,即

    tf.nn.Softmax(tf.add(tf.matmul(dropf,Wout),bout))

    训练轮数为20000轮,每50轮打印一次结果,但是由于电脑采用CPU的方式进行训练,训练很慢,因此需要花费很长的时间,通过结果我们可以发现,在前面的10个输出结果,正确率很低,在50%以下,随着训练轮数的增加,正确率有了显著地提升,当训练轮数为35*50之后,正确率与传统的一样,之后,随着训练轮数的增加,正确率有了提升,优于传统的方法,最后可以达到

        最终的结果如下所示:

    ->->->

        通过结果可以发现,当准确率达到97.7%之后,结果正确率上升将会更加的困难,因此最后正确率可以达到97%以上。

    16.Tensorflow 模型的保存以及读取

        在利用数据进行训练后,生成模型,对模型进行保存,模型文件如下所示:


        第一个文件为保存点文件,第三个文件为模型的数据文件,保存训练后的参数,第四个文件为保存的图结构。为了对模型文件进行调用,使用如下的函数进行调用:

        首先要恢复网络的图结构

    saver = tf.train.import_meta_graph('./mnist_model.ckpt.meta')

        接下来将训练后的参数进行加载

    saver.restore(sess,'./mnist_model.ckpt')

        这样就可以进行模型的调用,注意,在进行模型的加载时,需要重新加载网络的模型,对于本网络来说,网络的训练代码如下所示:

    import tensorflow as tf
    from tensorflow.examples.tutorials.mnist import input_data
    
    mnist = input_data.read_data_sets(r'G:\tmp\data',one_hot=True)
    
    xs = tf.placeholder(tf.float32,[None,28*28])#原始的输入为28*28像素大小
    ys = tf.placeholder(tf.float32,[None,10])#标签为10个
    xs_image = tf.reshape(xs,[-1,28,28,1])
    keep_prob_5 = tf.placeholder(tf.float32)
    keep_prob_75 = tf.placeholder(tf.float32)
    
    def weightVariable(shape,name):
        init = tf.random_normal(shape,stddev=0.01)
        return tf.Variable(init,name)
    
    def biasVariable(shape,name):
        init = tf.constant(0.1,shape=shape)
        return tf.Variable(init,name)
    
    def conv2d(x,W):
        return tf.nn.conv2d(x,W,strides=[1,1,1,1],padding='SAME')
    
    def maxpool(x):
        return tf.nn.max_pool(x,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')
    
    def dropout(x,keep):
        return tf.nn.dropout(x,keep)
    
    def cnnLayer(xs_image,keep_prob_5,keep_prob_75,classnum):
        #第一层
        W1 = weightVariable([5,5,1,32],name='W1')#原始图像是灰度图像
        b1 = biasVariable([32],name='b1')
        conv1 = tf.nn.relu(conv2d(xs_image,W1)+b1)
        pool1 = maxpool(conv1)
        drop1 = dropout(pool1,keep_prob_5) #经过处理后结果为14*14*32
        #第二层
        W2 = weightVariable([5,5,32,64],name='W2')
        b2 = biasVariable([64],name='b2')
        conv2 = tf.nn.relu(conv2d(drop1,W2)+b2)
        pool2 = maxpool(conv2)
        drop2 = dropout(pool2,keep_prob_5) #经过处理后结果为7*7*64
        #全连接层
        Wf = weightVariable([7*7*64,1024],name='Wf')
        bf = biasVariable([1024],name='bf')
        drop2_flat = tf.reshape(drop2,[-1,7*7*64])
        dense = tf.nn.relu(tf.matmul(drop2_flat,Wf)+bf)
        dropf = dropout(dense,keep_prob_75)#经过处理后结果为1*512
        #分类层
        Wout = weightVariable([1024,classnum],name='Wout')
        bout = biasVariable([classnum],name='bout')
        out = tf.nn.softmax(tf.add(tf.matmul(dropf,Wout),bout))
        return out
    
    prediction = cnnLayer(xs_image,0.5,0.75,10)
    
    cross_entropy = tf.reduce_mean(-tf.reduce_sum(ys*tf.log(prediction),reduction_indices=[1]))
    
    train = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
    sess =tf.Session()
    sess.run(tf.global_variables_initializer())
    
    saver = tf.train.Saver()
    
    def compute_accuracy(v_xs,v_ys):
        global prediction
        y_predict = sess.run(prediction,feed_dict = {xs:v_xs,keep_prob_5:1.0,keep_prob_75:1.0})
        correct_predict = tf.equal(tf.argmax(y_predict,1),tf.argmax(v_ys,1))
        accuracy = tf.reduce_mean(tf.cast(correct_predict,tf.float32))
        result = sess.run(accuracy,feed_dict={xs:v_xs,ys:v_ys,keep_prob_5:1.0,keep_prob_75:1.0})
        return result
    
    for i in range(4000):
        batch_xs , batch_ys = mnist.train.next_batch(100)
        sess.run(train,feed_dict = {xs:batch_xs,ys:batch_ys,keep_prob_5:0.5,keep_prob_75:0.75})
        if i%50 == 0:
            print(compute_accuracy(mnist.test.images,mnist.test.labels))
    
    save_path = saver.save(sess,'./mnist_model.ckpt')

        加载训练后的模型进行预测的代码如下所示:

    import tensorflow as tf
    import numpy as np
    from PIL import Image
    
    xs = tf.placeholder(tf.float32,[None,28*28])#原始的输入为28*28像素大小
    xs_image = tf.reshape(xs,[-1,28,28,1])
    keep_prob_5 = tf.placeholder(tf.float32)
    keep_prob_75 = tf.placeholder(tf.float32)
    
    def weightVariable(shape,name):
        init = tf.random_normal(shape,stddev=0.01)
        return tf.Variable(init,name)
    
    def biasVariable(shape,name):
        init = tf.random_normal(shape)
        return tf.Variable(init,name)
    
    def conv2d(x,W):
        return tf.nn.conv2d(x,W,strides=[1,1,1,1],padding='SAME')
    
    def maxpool(x):
        return tf.nn.max_pool(x,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')
    
    def dropout(x,keep):
        return tf.nn.dropout(x,keep)
    
    def cnnLayer(xs_image,keep_prob_5,keep_prob_75,classnum):
        #第一层
        W1 = weightVariable([5,5,1,32],name='W1')#原始图像是灰度图像
        b1 = biasVariable([32],name='b1')
        conv1 = tf.nn.relu(conv2d(xs_image,W1)+b1)
        pool1 = maxpool(conv1)
        drop1 = dropout(pool1,keep_prob_5) #经过处理后结果为14*14*32
        #第二层
        W2 = weightVariable([5,5,32,64],name='W2')
        b2 = biasVariable([64],name='b2')
        conv2 = tf.nn.relu(conv2d(drop1,W2)+b2)
        pool2 = maxpool(conv2)
        drop2 = dropout(pool2,keep_prob_5) #经过处理后结果为7*7*64
        #全连接层
        Wf = weightVariable([7*7*64,1024],name='Wf')
        bf = biasVariable([1024],name='bf')
        drop2_flat = tf.reshape(drop2,[-1,7*7*64])
        dense = tf.nn.relu(tf.matmul(drop2_flat,Wf)+bf)
        dropf = dropout(dense,keep_prob_75)#经过处理后结果为1*512
        #分类层
        Wout = weightVariable([1024,classnum],name='Wout')
        bout = biasVariable([classnum],name='bout')
        out = tf.nn.softmax(tf.add(tf.matmul(dropf,Wout),bout))
        return out
    
    cnnLayer = cnnLayer(xs_image,1,1,10)
    
    init_op = tf.global_variables_initializer()
    
    saver = tf.train.import_meta_graph('./mnist_model.ckpt.meta')
    with tf.Session() as sess:
        sess.run(init_op)
        saver.restore(sess,'./mnist_model.ckpt')
    
        image_path = r'G:\tmp\picturedata\originalPicture\14.bmp'
        img = Image.open(image_path).convert('L')
        image_shape = np.reshape(img,28*28)
        real_x = np.array([1-image_shape])
        y = sess.run(cnnLayer,feed_dict={xs:real_x,keep_prob_5:1,keep_prob_75:1})
        print(np.argmax(y[0]))
    

        注意观察这两个代码,将会将相同的部分标红,也就是重新在预测网络时重新加载的网络结构。最终的结果如下所示:


        在实际的测试中,我发现了一个问题,就是不知道如何设置dropout的数值,以及在什么地方设置dropout的数值,并且由于训练的轮数较少,因此识别的正确率不高,并且对于同一图像,识别的结果也不完全相同,但是我发现,在进行模型的训练时,正确率却很高,这是一个还没有解决的问题。至少应该可以知道如何设置dropout以及在什么地方设置dropout,并且识别的准确率提高,即使识别的准确率不高,对于同一副图像也应该是相同的识别结果,而不应该总是进行变化,但是本节仅仅是学习如何进行模型的调用。

        为了能够更加清晰地说明模型的保存以及模型的调用,使用如下的例子进行讲解:


        对于当前版本的模型调用,需要加载网络的图结构,加载完成网络的图结构后,加载训练后的数据,便可以很好的进行模型的加载。

    17.Tensorflow RNN 循环神经网络

        卷积神经网络告一段落,对于网络的熟练应用,就是要能够多次使用,接下来,将要学习RNN即循环神经网络。

    18.Tensorflow Autoencoder

        Autoencoder是一种非监督的学习方式。未完待续

    19.Tensorflow scope命名方式

        未完待续

    20.Tensorflow Batch normalization批标准化

        未完待续


        在学习了Tensorflow基础知识后,将会利用Tensorflow实现一些应用,以及算法的实现。


    展开全文
  • TensorFlow 是世界上最受欢迎的开源机器学习框架,它具有快速、灵活并适合产品级大规模应用等特点,让每个开发者和研究者都能方便地使用人工智能来解决多样化的挑战。 什么是TensorFlowTensorFlow能够让你直接...

    TensorFlow 是世界上最受欢迎的开源机器学习框架,它具有快速、灵活并适合产品级大规模应用等特点,让每个开发者和研究者都能方便地使用人工智能来解决多样化的挑战。

    什么是TensorFlow?

    TensorFlow能够让你直接解决各种机器学习任务。目标就是在一般情况下,无论你遇到什么问题,TensorFlow都可以在一定程度上提供API的支持。
    总的来说TensorFlow就是为了快而设计的,所以它针对你实际使用的硬件和平台做了优化。
    其中在机器学习框架方面,TensorFlow的真正独特之处在于,能够在5行或者10行代码中构建模型。然后应用这个模型,进行扩展做出产品。
    因此,你能够在几十甚至几百个机器的簇上进行训练。从而用该模型进行非常低的延迟预测。
    我们在这里稍微展开说一下什么是模型。以及机器学习是怎样与模型相关联的。
    这里有个简单的预测问题,判断一张图片中包含的是猫还是狗。这用传统的编程方法很难甚至不可能解决。因为很难制定出一系列规则,来决定什么是猫什么是狗。最重要该如何把握所有的变量,比如品种、姿势、亮度、以及比例等等。

    本人通过在b站上面搜索TensorFlow(没想到吧,b站居然还可以学习,我开始慌了!!!)
    排名前两个的视频教程!!!本人都看过(只看过,没完全看完,目前还在看)总体来说莫烦的视频教程,莫烦本人英俊潇洒,讲话更加有趣生动,动画等的设置挺好的,学习时长短,大家可以看看,我自己也完全看完了。

    在这里插入图片描述
    然而,我想大力推荐的是综合排序第一的那个视频教程,总体来说(咳咳)如下(哈哈):
    1、对初学者友好(没错,就是我,因为基本上这位老铁已经标注了所以代码的对应功能,非常的清晰)
    2、虽然不是很生动,但是干货慢慢的感觉
    3、没错,男人的直觉(信我没错的)
    在这里插入图片描述
    在这里插入图片描述
    废话不多说了,网址给你
    https://www.bilibili.com/video/av20542427/?p=11
    代码和课程的笔记也给你了
    https://github.com/Parker-Lyu/TensorFLow-Learning
    在这里插入图片描述
    欢迎关注和订阅AI算法与图像处理公众号(AI_study)

    不定期更新和分享高质量的文章和学习资料,让我们一起进步吧,fighting!!!
    在这里插入图片描述

    展开全文
  • 分布式深度学习框架TensorFlowOnSpark

    千次阅读 2017-12-05 18:21:12
    TensorFlowOnSpark分析 TensorFlowOnSpark(https://github.com/yahoo/TensorFlowOnSpark)项目是由Yahoo开源的一个软件包,能将TensorFlow(https://github.com/tensorflow/tensorflow)与Spark结合在一起使用,为...

    TensorFlowOnSpark分析

    TensorFlowOnSparkhttps://github.com/yahoo/TensorFlowOnSpark)项目是由Yahoo开源的一个软件包,能将TensorFlowhttps://github.com/tensorflow/tensorflow)与Spark结合在一起使用,为ApacheHadoopApacheSpark集群带来可扩展的深度学习功能。使Spark能够利用TensorFlow拥有深度学习和GPU加速计算的能力。传统情况下处理数据需要跨集群(深度学习集群和Hadoop/Spark集群),Yahoo为了解决跨集群传递数据的问题开发了TensorFlowOnSpark项目。TensorFlowOnSpark目前被用于雅虎私有云中的Hadoop集群,主要进行大规模分布式深度学习使用。


    TensorFlowOnSpark在内部实现了与Tensorflow集群类似的可扩展性。在下图中可以看出,SparkDriver端程序并不会参与TensorFlow内部相关的计算和处理,其设计思路像是一个TensorFlow集群运行在了Spark上,在每个Sparkexecutor中启动TensorFlow组件,然后通过gRPCRDMA 方式进行数据传递与交互。


    TensorFlowOnSpark程序运行时会通过如下步骤创建并管理TensorFlow集群(Spark程序会创建一个TensorFlow集群,TensorFlow的相关组件运行在Sparkexecutor内):

    • Reservation 为每个TensorFlowexecutor预留端口,并启动“数据/控制消息”的监听程序。

    • Startup 启动TensorFlow的主程序

    • Data ingestion

      • Readers &QueueRunners 利用TensorFlowReader机制直接从HDFS读取数据文件。

      • Feeding -使用HadoopInputFormat/OutputFormat 访问HDFS上的TFRecords数据,然后利用feed_dict机制将SparkRDD数据发送到TensorFlow节点。

    • Shutdown -关闭executor上的Tensorflowworker上的线程和ParameterServer节点。


    官方给出TensorFlowOnSpark目前支持的特性如下:

    • 轻松迁移所有现有的TensorFlow程序,修改代码小于10;

    • 支持所有TensorFlow功能:同步/异步训练,模型/数据并行,inferencingTensorBoard;

    • Server端到Server端直接通信提升处理速度(RDMA启用时);

    • 允许由Spark分发或由TensorFlow拉取HDFS和其他资源上的数据;

    • 轻松整合现有的数据处理流程和机器学习算法(如MLlibCaffeOnSpark;

    • 轻松在云或内部部署:CPU& GPU, Ethernet and Infiniband.


    我们可以使用两种方法来提取训练数据和预测:

    • TensorFlowQueueRunnersTensorFlowOnSpark利用TensorFlow的文件读取器和QueueRunners直接从HDFS文件读取数据。Spark不涉及访问数据。

    • Spark Feeding:通过SparkRDD将数据传输到每个Sparkexecutor,然后通过feed_dict将数据传输到TensorFlowgraph中。


    开发的TFoSTensorFlowOnSpark)程序可以直接使用SparkSpark-submit命令提交到集群上,在提交时程序时,用户可以指定Sparkexecutor的个数,每个executor上有几个GPU,“参数服务器(ParameterServer)”的个数。另外用户还可以指定TensorBoardRDMA是否使用,命令如下:

    sparksubmit
    
    –master${MASTER} \
    
    ${TFoS_HOME}/examples/slim/train_image_classifier.py\
    
    –model_nameinception_v3 \
    
    –train_dirhdfs://default/slim_train \
    
    –dataset_dirhdfs://default/data/imagenet \
    
    –dataset_nameimagenet \
    
    –dataset_split_nametrain \
    
    –cluster_size${NUM_EXEC} \
    
    –num_gpus${NUM_GPU} \
    
    –num_ps_tasks${NUM_PS} \
    
    –sync_replicas\
    
    –replicas_to_aggregate${NUM_WORKERS} \
    
    –tensorboard\
    
    –rdma


    另外TFoS还提供了更高级的PythonAPI

    • reserve() … construct aTensorFlow cluster from Sparkexecutors

    • start() … launch Tensorflowprogram on the executors

    • train() or TFCluster.inference()… feed RDD data to TensorFlowprocesses

    • TFCluster.shutdown() … shutdown Tensorflow execution onexecutors


    优点

    • Yahoo已经在自己的云上实践并使用,可以用于生产

    • 轻松整合现有的数据处理流程和机器学习算法

    • 支持所有TensorFlow功能

    • 轻松移植现有TensorFlow程序到Spark集群上

    • 学习成本较低

    缺点

    • 缺少相关文档与使用教程

    • 代码刚开源,社区反馈与支持力度未知


    展开全文
  • 最底层的API是Tensorflow core,推荐给机器学习的研究者或者那些想对模型有更好的掌控的大神们用~较高层的API是在Tensorflow core的基础上封装建立的,肯定比Tensorflow core要更易学,更易使用啦~另外,较高层的A
  • 炼数成金-深度学习框架TensorFlow

    千次阅读 2018-05-16 19:56:08
    2015年年底推出GPU速度一般比CPU快几十倍

空空如也

1 2 3 4 5 ... 20
收藏数 203,402
精华内容 81,360
关键字:

深度学习框架