[tensorflow] 通过Class的形式实现网络的创建、加深理解graph和session

一.理解graph和session

  对tensorflow中的graph和session进行更深入的了解,能够帮助理解tensorflow的运行机制,使得可以在一个运行程序中调用不同的神经网络。总而言之,是深入学习必须掌握的东西。

  • 在程序一开始,tensorflow会自动生成一个默认的graph。如果不显示的指定graph,所有的操作(添加张量、节点)都会自动加入默认图。
  • 可以通过g=tf.Graph()显示获得一个图的变量。然后通过 with g.as_default():上下文管理器,在后文中进行网络的搭建工作。当然也有将g直接显示申明为默认图的函数,我忘记了,以后看见了来添加。但是不推荐显示申明为默认图,因为考虑到以后有多张图存在的情况下,显示申明会让逻辑处理起来很混乱,还是按照前一种方式规范操作来得好。
  • 一个图可以有多个session,但是一个session只能执行一个指定图里的操作。
import tensorflow as tf

tf.reset_default_graph()#复位初始图
g=tf.Graph()#获得图的对象
with g.as_default():
    a=tf.Variable(‘a‘)
    sess=tf.Session()
    sess.run(tf.global_variables_initializer())
    print(sess.run(a))#这里正常输出‘a‘
b=tf.Variable(‘b‘)
with sess.as_default():
    sess.run(tf.global_variables_initializer())
    print(sess.run(b))#这里报错“ is not an element of this graph ”

    上述代码中,第一个print正常执行,正常输出张量a。但是定义张量b时,是定义在了全局默认的图中,并非在g中。而session对应的图是g,不是默认图,所以出错。

import tensorflow as tf

tf.reset_default_graph()#复位初始图
g=tf.Graph()#获得图的对象
with g.as_default():
    a=tf.Variable(‘a‘)
    sess=tf.Session()
    sess.run(tf.global_variables_initializer())
    print(sess.run(a))
b=tf.Variable(‘b‘)
with tf.Session() as sess2:
    sess2.run(tf.global_variables_initializer())
    print(sess2.run(b))

    代码修改过后,则能正常执行第二个print,输出张量b。因为以当前的默认graph重新申明了session来执行该操作。


二.通过class方式实现一个卷积网络

   此种方式生卷积网络的类。目标是可以新建多个类的实例进行训练等操作,而不相互影响。此时就应该注重管理graph和session。

  实现代码如下:

# -*- coding: utf-8 -*-
"""
Created on Fri Feb 16 12:31:04 2018

@author: FC
"""
import tensorflow as tf
import input_data
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
class ConvNet():
    def __init__(self,layers=[‘c‘,‘p‘,‘c‘,‘p‘],datain=[784],ind=[28,28,1],outd=[10]):
        self.layers=layers  #每一层的属性
        self.ind=ind        #图片的属性
        self.outd=outd      #输入的标记样本数组维度
        self.datain=datain  #输入的数据样本数组维度
        self.convkernelsize=3#卷积核大小
        self.midchannels=24 #中间层每层的通道数
        self.net={}         #层的集合
        self.__NetInit()
    def __weight_variable(self,shape,name=‘w‘):
        initial = tf.truncated_normal(shape, stddev=0.1)
        return tf.Variable(initial,name=name)
    def __bias_variable(self,shape,name=‘b‘):
        initial = tf.constant(0.1, shape=shape)
        return tf.Variable(initial,name=name)

    def __AddInlayer(self,x,name=‘In-Layer‘):
        #输入处理层
        with tf.name_scope(name):
            x_reshape=tf.reshape(x, [-1]+self.ind)
            w=self.__weight_variable([self.convkernelsize,self.convkernelsize
                                      ,self.ind[2],self.midchannels])
            b=self.__bias_variable([self.midchannels])
            conv=tf.nn.conv2d(x_reshape, w, strides=[1, 1, 1, 1], padding=‘SAME‘)
            net=tf.nn.relu(conv+b,name=name)
        return net

    def __AddConvLayer(self,x,layertype=‘c‘,name=‘Mid_ConvLayer‘):
        if ((layertype!=‘c‘) and (layertype!=‘p‘)):
            #只能是池化或者卷积层
            return
        if (layertype==‘p‘):
            with tf.name_scope(name+layertype):
                net = tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
                            strides=[1, 2, 2, 1], padding=‘SAME‘)
            return net
        if (layertype==‘c‘):
            with tf.name_scope(name+layertype):
                w=self.__weight_variable([self.convkernelsize,self.convkernelsize
                                      ,self.midchannels,self.midchannels])
                b=self.__bias_variable([self.midchannels])
                conv=tf.nn.conv2d(x, w, strides=[1, 1, 1, 1], padding=‘SAME‘)
                net=tf.nn.relu(conv+b,name=name+layertype)
            return net

    def __AddFcLayer(self,x,name=‘Out-FcLayer‘):
        #全连接输出层
        inshape=x.shape
        width=inshape[1]*inshape[2]*inshape[3]
        width=tf.cast(width,tf.int32)
#        print(type(width))
        with tf.name_scope(name):
            w1=self.__weight_variable([width,1024],name=‘w1‘)
            b1=self.__bias_variable([1024],name=‘b1‘)
            x_flat=tf.reshape(x,[-1,width],name=‘x_flat‘)
            fc1=tf.nn.relu(tf.matmul(x_flat,w1)+b1,name=‘fc1‘)

            w2=self.__weight_variable([1024]+self.outd,name=‘w2‘)
            b2=self.__bias_variable(self.outd,name=‘b2‘)
            net=tf.nn.softmax(tf.matmul(fc1,w2)+b2,name=name)
        return net
    def __AddTrainstep(self,y,y_,name=‘Training‘):
        with tf.name_scope(name):
            cross_entropy = -tf.reduce_sum(y_*tf.log(y))
            train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
            correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))
            accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
        return train_step,accuracy
    def __NetInit(self):
        #由实际输入决定
        tf.reset_default_graph()#复位初始图
        self.Graph=tf.Graph()
        #如果在一个进程中创建了多个Graph,则需要创建不同的Session来加载每个Graph
        #而每个Graph则可以加载在多个Session中进行计算。
        #上下文管理器
        with self.Graph.as_default():
            #1. 初始化网络结构
            self.x=tf.placeholder("float",[None]+self.datain,name=‘x-input‘)
            self.y_=tf.placeholder("float", [None]+self.outd,name=‘y-input‘)

            #添加网络
            self.net[0]=self.__AddInlayer(self.x)
            for i in range(len(self.layers)):
                self.net[i+1]=self.__AddConvLayer(self.net[i],layertype=self.layers[i])
            self.outnet=self.__AddFcLayer(self.net[len(self.layers)])
            self.trainstep,self.accuracy=self.__AddTrainstep(self.outnet,self.y_)
            self.sess=tf.Session()
            #2. 初始化图中变量
            self.sess.run(tf.global_variables_initializer())
    def Train(self,datax,datay):
        self.sess.run(self.trainstep,feed_dict={self.x:datax, self.y_:datay})
#        for i in range(1000):
#            batch = mnist.train.next_batch(64)
#            if i%1000 == 0:
#                train_accuracy = self.sess.run(self.accuracy,feed_dict={self.x:batch[0], self.y_: batch[1]})
#                print ("step %d, training accuracy %g"%(i, train_accuracy))
#            self.sess.run(self.trainstep,feed_dict={self.x: batch[0], self.y_: batch[1]})
#
#        print ("test accuracy %g"%self.sess.run(self.accuracy,feed_dict={
#            self.x: mnist.test.images, self.y_: mnist.test.labels}))
    def GetAccuracy(self,datax,datay):
        return self.sess.run(self.accuracy,feed_dict={self.x: datax, self.y_: datay})
    def SaveGraph(self):
        #调用此函数,可通过tensorboard查看网络形状
        with self.Graph.as_default():
            merge = tf.summary.merge_all()
            writer = tf.summary.FileWriter(‘./log‘,self.sess.graph)
    def Close(self):
        self.sess.close()
if __name__==‘__main__‘:
    net1=ConvNet(layers=[‘c‘,‘c‘,‘p‘,‘c‘,‘c‘,‘p‘])
#    net1.SaveGraph()
    for i in range(1000):
        batch = mnist.train.next_batch(64)
        net1.Train(batch[0],batch[1])
    net2=ConvNet(layers=[‘c‘,‘c‘,‘p‘,‘c‘,‘c‘,‘p‘,‘c‘])
    print("net2 accuracy: %g%%"%(100*net2.GetAccuracy(mnist.test.images,mnist.test.labels)))
    print("net1 accuracy: %g%%"%(100*net1.GetAccuracy(mnist.test.images,mnist.test.labels)))  
  1. 上述代码中,定义了一个ConvNet类。
  2. 训练的样本集合是mnist。
  3. 在使用时,创建了两个实例:net1和net2。
  4. 对net1输入了样本训练。
  5. 同时输入出net1和net2的预测准确率,如下所示:
net2 accuracy: 9.81%
net1 accuracy: 97.08%

  证明两个实例是相互独立的,对一个实例的训练并没有影响到另一个。


后续:

  后续的实验应该是两个实例同时进行训练,保存准确率较高的实例的参数,作为下一次训练共同的初始化数据。

原文地址:https://www.cnblogs.com/fangzhuan/p/8469988.html

时间: 2024-09-29 12:11:31

[tensorflow] 通过Class的形式实现网络的创建、加深理解graph和session的相关文章

【GCN】图卷积网络初探——基于图(Graph)的傅里叶变换和卷积

[GCN]图卷积网络初探——基于图(Graph)的傅里叶变换和卷积 2018年11月29日 11:50:38 夏至夏至520 阅读数 5980更多 分类专栏: # MachineLearning 版权声明:本文为博主原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接和本声明. 本文链接:https://blog.csdn.net/qq_41727666/article/details/84622965 本文为从CNN到GCN的联系与区别——GCN从入门到精(fang)通(qi

Unity带有网络功能——创建服务,并连接到一个特定的服务

游戏本身需要在网络上创建服务,然后其他的游戏能够连接到这个服务,此外真实场景现在玩同样的游戏效果一起. 该方法是创建一个服务呼叫Network.InitializeServer( ): 是Network.Connect( ). 本文说明了这两个方法在实例中的使用方式. 版权声明:本文博客原创文章,博客,未经同意,不得转载.

Unity自带网络功能——创建服务,以及连接指定服务

游戏本身需要在网络上创建一个服务,然后其它游戏才能连接到这个服务,进而实现在同一游戏场景中一同玩耍的效果. 创建服务调用的方法是Network.InitializeServer( ): 连接指定服务调用的方法是Network.Connect( ): 本文说明了这两个方法在实例中的使用方式.

安装kali 开机登陆 Ping 主机可达 Ctrl+c键来强行终止 ifconfig 查看网络状态 创建一个用户,并将其纳入root组,然后将用户删除 创建用户, 创建文件夹,文件夹中创建一些文件,将文件夹打包,最后解包到另一个文件中 创建一个文件。

安装linus操作系统 直接按回车确定 Live(amd64),就可以直接自动安装进入操作系统 安装完成后,进入界面. 创建用户zfh,密码123456 将用户zfh删除 利用ifconfig查看网络状态 创建zfh17文件夹,在文件夹里面创建17.txt,和18.txt. 利用rm,删除17.txt 利用ps-ef显示进程 查看磁盘容量 显示目录中所有文件的大小 在zfh200里面创建两个文件夹zfh201和zfh202,将zfh201压缩到zfh202中 解压缩 windows操作系统命令使

TensorFlow 学习(二)—— tf Graph tf Session 与 tf Session run

session: with tf.Session() as sess:/ tf.InteractiveSession() 初始化: tf.global_variables_initializer() with tf.Session() as sess: sess.run(tf.global_variables_initializer()) 1 2 0. tf.Graph 命名空间与 operation name(oper.name 获取操作名): c_0 = tf.constant(0, nam

AFNetworking形式-与-NSURLConnection形式的网络请求

一:NSURLConnection网络请求 NSOperationQueue *queue = [[NSOperationQueue alloc] init]; // 异步方法 [NSURLConnection sendAsynchronousRequest:urlRequest queue:queue completionHandler:^(NSURLResponse *response, NSData *data, NSError *connectionError) { NSString *

Tensorflow的MNIST进阶教程CNN网络参数理解

背景 问题说明 分析 LeNet5参数 MNIST程序参数 遗留问题 小结 背景 之前博文中关于CNN的模型训练功能上是能实现,但是研究CNN模型内部结构的时候,对各个权重系数w,偏差b的shape还是存在疑惑,为什么要取1024,为什么取7*7*64,最近找到了一些相关资料,对这个问题有了新的理解,下面和大家分享一下. 问题说明 # Input Layer x = tf.placeholder('float',[None,784]) y_ = tf.placeholder('float',[N

利用tensorflow训练简单的生成对抗网络GAN

对抗网络是14年Goodfellow Ian在论文Generative Adversarial Nets中提出来的. 原理方面,对抗网络可以简单归纳为一个生成器(generator)和一个判断器(discriminator)之间博弈的过程.整个网络训练的过程中, 两个模块的分工 判断器,直观来看就是一个简单的神经网络结构,输入就是一副图像,输出就是一个概率值,用于判断真假使用(概率值大于0.5那就是真,小于0.5那就是假) 生成器,同样也可以看成是一个神经网络模型,输入是一组随机数Z,输出是一个

TensorFlow(十四):谷歌图像识别网络inception-v3下载与查看结构

上代码: import tensorflow as tf import os import tarfile import requests #inception模型下载地址 inception_pretrain_model_url = 'http://download.tensorflow.org/models/image/imagenet/inception-2015-12-05.tgz' # inception_pretrain_model_url = 'http://download.te