TensorFlow

时间  2019-11-16
标签 tensorflow 繁體版
原文   原文链接

TensorFlow

tensorflow 

1、Basic

TensorFlow是以图做为核心，数据的流动构成一张图，对图进行相应的计算。html

Graph:

matrix1 = tf.constant([[3., 3.]])
matrix2 = tf.constant([[2.],[2.]])
product = tf.matmul(matrix1 , matrix2)

这样，建立了三个结点，两个constant op，一个mutmul op。python

Session:

Graph须要载入Session中才能够运行。数组

sess = tf.Session()
sess.run(product)
sess.close()

在计算结束后，须要关闭session以释放资源。或者使用with 子句，在结束后会自动释放：浏览器

with tf.Session() as sess:
    sess.run(product)

指定设备：

"/cpu:0" :计算机的 CPU ;
"/gpu:0" :计算机的第一个 GPU ,若是可用;
"/gpu:1" :计算机的第二个 GPU ,以此类推。网络

with tf.Session() as sess:
    with tf.device("/gpu:1"):
        sess.run(product)

ConfigProto

在配置Session时，能够设置config，常见配置项以下：session

  • log_device_placement
  • allow_soft_placement
  • gpu_options.allow_growth: 是否采用增加的方式分配显存。若是这个值为True，那么分配器不会预分配整个指定的GPU显存空间，而是开始分配一小部分显存，而后随着须要而增长。

详细配置项：https://www.jianshu.com/p/b9a442bcfd2e数据结构

例子：
log_device_placement=True打印使用相关的设备信息：app

config=tf.ConfigProto(log_device_placement=True, allow_soft_placement=True)
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)

Tensor:

你能够把 TensorFlow 的张量看做是一个 n 维的数组或列表 . 一个 tensor
包含一个静态类型 rank, 和一个 shape.dom

Variable:

变量维持了图执行过程当中的状态信息。机器学习

state = tf.Variable(0, name="counter")
one = tf.constant(1)
new_value = tf.add(state, one)
update_value = tf.assign(state, new_value)
init_op = tf.initialize_all_variables()
with tf.Session() as sess:
    with tf.device("/gpu:0"):
        sess.run(init_op)
        for _ in range(3):
            sess.run(update_value)

变量初始化：

# random_normal
weights = tf.Variable(tf.random_normal(shape=[784, 200], stddev=0.35), name="weights")

# zeros
biases = tf.Variable(tf.zeros(shape=[200]), name="biases")

# 使用其它变量
weigths2 = tf.Variable(weights.initialized_value(), name='weights2')

# 手动初始化
weights3 = tf.Variable([1.0, 2.0, 5.0, 3.5], name='weights3')

note: tf函数的shape都是以列表为参数[3, 4], 如tf.zeros([3, 4])；而numpy中函数的shape参数多数以元组形式(3, 4)，如np.zeros((3, 4));

2、Function

tf.group

建立一个op组合多个操做，sess.run(group)时能够执行group中全部的操做，当全部操做都完成，op输出结果为None。

b = tf.random_uniform([2,3], minval = 10, maxval = 11)
w = tf.random_uniform([2,3], minval = 10, maxval = 11)
mul = tf.multiply(w, 2)
add = tf.add(w, 2)
group = tf.group(mul, add)
print sess.run(group)
#输出:None

tf.train.ExponentialMovingAverage

tf.train.ExponentialMovingAverage(decay, steps)
tf.train.ExponentialMovingAverage这个函数用于更新参数，就是采用滑动平均的方法更新参数。这个函数初始化须要提供一个衰减速率（decay），用于控制模型的更新速度。这个函数还会维护一个影子变量（也就是更新参数后的参数值），这个影子变量的初始值就是这个变量的初始值，影子变量值的更新方式以下：
shadow_variable = decay * shadow_variable + (1-decay) * variable
shadow_variable是影子变量，variable表示待更新的变量，也就是变量被赋予的值，decay为衰减速率。decay通常设为接近于1的数（0.99,0.999）。decay越大模型越稳定，由于decay越大，参数更新的速度就越慢，趋于稳定。
tf.train.ExponentialMovingAverage这个函数还提供了本身更新decay的计算方式：
decay= min（decay，（1+steps）/（10+steps））
steps是迭代的次数，能够本身设定或者默认。

self.ema = tf.train.ExponentialMovingAverage(decay=0.9999)
self.averages_op = self.ema.apply(tf.trainable_variables())
with tf.control_dependencies([self.optimizer]):
    self.train_op = tf.group(self.averages_op)

tf.control_dependencies

在有些机器学习程序中咱们想要指定某些操做执行的依赖关系，这时咱们可使用tf.control_dependencies()来实现。
control_dependencies(control_inputs)返回一个控制依赖的上下文管理器，使用with关键字可让在这个上下文环境中的操做都在control_inputs 执行。

with g.control_dependencies([a, b, c]):
# `d` and `e` 在 `a`, `b`, and `c` 执行完后运行
d = ...
e = ...

tf.trainable_variables

tf.trainable_variables返回的是须要训练的变量列表
tf.all_variables返回的是全部变量的列表

import tensorflow as tf;    
import numpy as np;    
import matplotlib.pyplot as plt;    
  
v = tf.Variable(tf.constant(0.0, shape=[1], dtype=tf.float32), name='v')  
v1 = tf.Variable(tf.constant(5, shape=[1], dtype=tf.float32), name='v1')  
 # trainable = False
global_step = tf.Variable(tf.constant(5, shape=[1], dtype=tf.float32), name='global_step', trainable=False)  
ema = tf.train.ExponentialMovingAverage(0.99, global_step)  
  
for ele1 in tf.trainable_variables():  
    print ele1.name  
for ele2 in tf.all_variables():  
    print ele2.name

输出：
v:0
v1:0

v:0
v1:0
global_step:0

分析：
上面获得两个变量，后面的一个获得上三个变量，由于global_step在声明的时候说明不是训练变量，用来关键字trainable=False。

placeholder, feed
二者结合使用，先用placeholder定义占位符，以后使用feed传入真实的数据。

# define hld, None means batch_size
x_hld = tf.placeholder(tf.float, [None, 320, 240, 3], name='x_hld')
y_hld = tf.placeholder(tf.int64, [None, nb_classes], name='y_hld')

sess.run([train_op], feed_dict={x_hld: X, y_hld: y})

tf.Graph.finalize
做用：结束（Finalizes）这个图，使其只读（read-only）.调用这个函数以后，就没有操做可以添加到这个图里面去了。这个方法是确保当这个图被多个线程共享的时候，没有操做可以添加进去。

tf.pad()

#t=[[2,3,4],[5,6,7]]， paddings=[[1,2],[2,3]],mode="CONSTANT"
sess.run(tf.pad(t,paddings,"CONSTANT"))

[[1, 2], [2, 3]]表示上面pad 1, 下面pad 2, 左面pad 2, 右面pad 3，最后造成：

result

result

CONSTANT表示pad的数是0, 还有REFLECT和SYMMETRIC方式，详情见(http://blog.csdn.net/zhang_bei_qing/article/details/75090203)。

optimizer

optimizer = tf.train.GradientDescentOptimizer(learning_rate)
train_op = optimizer.minimize(loss)
sess.run([train_op], feed_dict={x_batch: x[i\*batch_size:(i+1)*batch_size], y_batch: y[i\*batch_size:(i+1)\*batch_size]})

常见优化器以下：

GradientDescentOptimizer
AdagradOptimizer
AdagradDAOptimizer
MomentumOptimizer
AdamOptimizer
FtrlOptimizer
RMSPropOptimizer

arg_scope:

tf.contrib.framework.arg_scope(list_ops_or_scope, **kwargs)
#或者
tf.contrib.slim.arg_scope(list_ops_or_scope, **kwargs)

# 为给定的 list_ops_or_scope 存储默认的参数

如：

with slim.arg_scope([slim.conv2d, slim.fully_connected],
	activation_fn=leaky_relu(alpha),
	weights_initializer=tf.truncated_normal_initializer(0.0, 0.01),
	weights_regularizer=slim.l2_regularizer(0.0005)):

对conv2d，fully_connected层分别加上activation_fn, weights_initializer, weights_regularizer等默认属性。

accuracy计算:

acc = tf.equal(pred.argmax(), y.argmax())
acc_f = tf.cast(acc, tf.float32)
acc_op = tf.reduce_sum(acc_f)

reduce_sum:

在哪一个维度上操做，哪一个维度的大小就变为1.
(2, 3) reduce_sum(arr, 0, keep_dim=True) => (1, 3)
(2, 3) reduce_sum(arr, 1, keep_dim=True) => (2, 1) #使用keep_dim，不然会变成(1, 2)

reduce_sum若是不加维度的话，默认是在全部维度上进行，加上维度就只在特定给定上执行求和操做：

reduce_sum(arr, 0)  # 对第0维操做，即对0维求和
reduce_mean(arr, 1) #对第1维操做，即对1维求平均

concat:
和reduce_sum类型，在哪一个维度上操做，哪一个维度的大小就变

# t1 with shape [2, 3], t2 with shape [2, 3]
tf.shape(tf.concat([t1, t2], 0))  # => [4, 3]
tf.shape(tf.concat([t1, t2], 1))  # => [2, 6]

以下， t1, t2没法使用concta链接第二维，由于对应的shape只有一个维度，固然不能在第二维上连了，虽然实际中两个向量能够在行上连，可是放在程序里是会报错的。须要使用expand_dim来扩展出第二维

t1=tf.constant([1,2,3])  
t2=tf.constant([4,5,6])  
# tf.concat([t1, t2], 1)

t1 = tf.expand_dims(tf.constant([1, 2 ,3]), 1)
t2 = tf.expand_dims(tf.constant([4, 5, 6]), 1)
tf.concat([t1, t2], 1) # [[1]]

expand_dims:

有时，2维的矩阵想变成3维的矩阵，如(2, 3)的矩阵想变为(2, 3, 1)就须要使用expand_dim，固然使用tf.reshape也能够进行变换，但tf.reshape对于tf.placeholder变量会报错，这个时候仍是要使用tf.expand_dims。

# 假设value维度为(2, 3)

tf.expand_dims(value, 0)  # (2, 3) => (1, 2, 3)
tf.expand_dims(value, 1)  # (2, 3) => (2, 1, 3)
tf.expand_dims(value, 2)  # (2, 3) => (2, 3, 1)
tf.expand_dims(value, -1)  #-1表示在扩展最后一维 (2, 3) => (2, 3, 1)

tf.shape:
返回张量的形状，而且shape返回的也是张量，在tensorflow中须要sess.run才能看到值：

slim.losses:

若是不使用tf提供的loss函数，而本身实现loss计算时，又想使用tensorflow的loss管理机制，可使用slim.losses.add_loss()来添加loss，并使用slim.losses.get_total_loss()来获得最后的loss。

exponential_decay:

tf.train.exponential_decay主要用来对学习率进行动态调整，前期可使用较大的学习率，后期能够调小学习率。

lr = tf.train.exponential_decay(initial_learning_rate, glob_step, decay_steps, decay_rate)

例子：

initial_learning_rate: 初始学习率，如 0.001
glob_step: 当前迭代数，如 0, 1, 2, 3...
decay_steps: 衰减一次decay_rate须要的迭代次数， 如 3000，就是须要3000次缩减到decay_rate倍
decay_rate: 衰减的系数, 如0.1

那么初始学习率为0.001，以下两个迭代时的学习率计算方式：

glob_step=0, 那么有: lr = 0.001 * 0.1 ^ (0 / 3000) = 0.001
glob_step=3000, 那么有: lr = 0.001 * 0.1 ^ (3000 / 3000) = 0.0001

可见，越到后面学习率越小。

另外一种思路，设置stair_case=True，能够调小decay_steps，调大decay_rate，这样能够在decay_steps的整数倍迭代时，乘以一个decay_rate。

lr = tf.train.exponential_decay(initial_learning_rate=0.001, glob_step=i, decay_steps = 100, decay_rate=0.96, stair_case=True)

iter 0: lr = 0.001 * 0.96 ^ (0 / 100) = 0.001
iter 99: lr = 0.001 * 0.96 ^ (99 / 100) = 0.001
iter 100: lr = 0.001 * 0.96 ^ (100 / 100) = 0.0096
iter 200: lr = 0.001 * 0.96 ^ (100 / 100) = 0.009216

也就是对(glob_step / decay_steps)取整数，每decay_steps迭代乘以0.96。

若是staircase=True, decay_rate=0.1, decay_steps=10000，那么学习率每10000次缩小10倍。

batch normalization:

实现：

# convolution with batch norm
net = slim.conv2d(net, 32, 5, padding='SAME', activation_fn=tf.nn.relu, normalizer_fn=slim.batch_norm, scope='conv1')

#dependency
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) 
with tf.control_dependencies(update_ops): 
    train_step = tf.train.GradientDescentOptimizer(0.01).minimize(total_loss)

使用batch normaliztion:
那BN究竟是什么原理呢？说到底仍是为了防止“梯度弥散”。在神经网络训练时遇到收敛速度很慢，或梯度爆炸等没法训练的情况时能够尝试BN来解决。另外，在通常使用状况下也能够加入BN来加快训练速度，提升模型精度。

下面是分别没有使用BN和使用BN的结果，能够看到使用BN在相同迭代次数下BN结果更优。

not using BN

not using BN

using BN

using BN

Random:

random_normal: 是使生成的数据服从正态分布

truncated_normal: 若是数据大于(mean +/- 2 * std)范围就从新取值

random_uniform: 产生于low和high之间，产生的值是均匀分布的。

tf.random_shuffle(value, seed=None, name=None)： 打乱Tensor的第0维，即行

a1 = [[1, 2], [3, 4], [5, 6]]
a2 = tf.randem_shuffle(a1) #=> 以行随机，可能结果[[3, 4], [1, 2], [5, 6]]

casting:

tf.to_double([1, 2])
tf.to_float([1, 2])
tf.to_int32()
tf.to_int64()
tf.cast([1, 2], dtype=int32)
tf.cast([1, 2], dtype=float32)

注意： 这里，使用tf.to_float，但使用tf.cast(1, dtype=tf.float32)必须使用float32，不然会报错。

rank:

求Tensor是几维张量。

tf.rank(a1)
tf.shape(a1)
tf.size(a1)
tf.reshape(a1, [1, 2])

tfrecoder:

tensorflow中可使用tfrecoder进行数据的读写。tensorflow中提供tf.train.Example，其是使用protobuf进行定义的，以下：

message Example {
 Features features = 1;
};

message Features{
 map<string,Feature> featrue = 1;
};

message Feature{
    oneof kind{
        BytesList bytes_list = 1;
        FloatList float_list = 2;
        Int64List int64_list = 3;
    }
};

能够看到Example中包括一个features成员，而features又是一个字符串与Feature类型的map，这样咱们就能够存储"label", "img"这样的数据了，一个Example就是一个数据样例。

利用以下方法将数据存储到tfrecode文件中：

def test_write_to_tfrecords(filename):
    writer = tf.python_io.TFRecordWriter(filename)

    #循环将每一个数据写入
    for i in range(100):
        img_raw = np.random.random_integers(0,255,size=(7,30)) # 建立7*30，取值在0-255之间随机数组
        img_raw = img_raw.tostring()
        example = tf.train.Example(features=tf.train.Features(
                feature={
                'label': tf.train.Feature(int64_list = tf.train.Int64List(value=[i])),     
                'img_raw':tf.train.Feature(bytes_list = tf.train.BytesList(value=[img_raw]))
                }))
        writer.write(example.SerializeToString()) #将数据序列化写入

    writer.close()

文件的读取须要使用tf.train.string_input_producer生成一个解析队列，再调用tf.TFRecordReader的tf.parse_single_example解析器进行解析。

tfrecords_filename = "train.tfrecords"
    test_write_to_tfrecords(tfrecords_filename)
    filename_queue = tf.train.string_input_producer([tfrecords_filename],) #读入流中
    reader = tf.TFRecordReader()
    _, serialized_example = reader.read(filename_queue)   #返回文件名和文件
    features = tf.parse_single_example(serialized_example,
                                       features={
                                           'label': tf.FixedLenFeature([], tf.int64),
                                           'img_raw' : tf.FixedLenFeature([], tf.string),
                                       })  #取出包含image和label的feature对象
    image = tf.decode_raw(features['img_raw'], tf.int64)
    image = tf.reshape(image, [7,30])
    label = tf.cast(features['label'], tf.int64)
    with tf.Session() as sess: #开始一个会话
        init_op = tf.initialize_all_variables()
        sess.run(init_op)
        coord=tf.train.Coordinator()
        threads= tf.train.start_queue_runners(coord=coord)
        for i in range(20):
            example, l = sess.run([image,label])#在会话中取出image和label
            img=Image.fromarray(example, 'RGB')#这里Image是以前提到的
            img.save('./'+str(i)+'_''Label_'+str(l)+'.jpg')#存下图片
            print(example, l)

        coord.request_stop()
        coord.join(threads)

注意，在运行任何训练步骤以前，须要调用tf.train.start_queue_runners函数，不然tensorflow将一直挂起。

coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord)

取出数据时，也要使用sess.run才能真正取出：

example, l = sess.run([image,label])

上面代码读取的是单个的image和label，而在tensorflow训练时，通常是采起batch的方式去读入数据。tensorflow提供了两种方式，一种是shuffle_batch（tf.train.shuffle_batch），这种主要是用在训练中，随机选取样本组成batch。另一种就是按照数据在tfrecord中的前后顺序生成batch（tf.train.batch）。
这里采用tf.train.shuffle_batch方式, capacity是可载入的样本数；min_after_dequeue是在出队列操做后最少生关死劫的样本数，小于这个数就须要读入新的样本；batch_size一次取出的样本数；num_threads线程数：

img_batch, label_batch = tf.train.shuffle_batch([img,label], batch_size=18, capacity=2000, min_after_dequeue=100, num_threads=2)

总体代码以下：

import tensorflow as tf   
import scipy.misc as misc
import os

def write_binary():  
    cwd = os.getcwd()

# all_files = os.listdir(cwd)

    classes=['a','b','c']
    writer = tf.python_io.TFRecordWriter('data.tfrecord')  
    for index, name in enumerate(classes):
        class_path = os.path.join(cwd,name)
# if tf.gfile.Exists(class_path):
# tf.gfile.DeleteRecursively(class_path)
# tf.gfile.MakeDirs(class_path)
        for img_name in os.listdir(class_path):
            img_path = os.path.join(class_path , img_name)
            img = misc.imread(img_path)
            img1 = misc.imresize(img,[250,250,3])
            img_raw = img1.tobytes()              #将图片转化为原生bytes
            example = tf.train.Example(features=tf.train.Features(feature={
                    'img_raw': tf.train.Feature(bytes_list=tf.train.BytesList(value=[img_raw])),
                "label": tf.train.Feature(int64_list=tf.train.Int64List(value=[index]))}
                ))  # 将数据整理成 TFRecord 须要的数据结构 

    #序列化 
            serialized = example.SerializeToString()  
    #写入文件 
            writer.write(serialized)  
    writer.close()  

def read_and_decode(filename):  
    #建立文件队列,不限读取的数量 
    filename_queue = tf.train.string_input_producer([filename],shuffle=False)  
    # create a reader from file queue 
    reader = tf.TFRecordReader()  
    #reader从 TFRecord 读取内容并保存到 serialized_example 中 
    _, serialized_example = reader.read(filename_queue)  

    features = tf.parse_single_example(     # 读取 serialized_example 的格式 
        serialized_example,  
        features={  
            'label': tf.FixedLenFeature([], tf.int64),  
            'img_raw': tf.FixedLenFeature([], tf.string)      
        }  
    )  # 解析从 serialized_example 读取到的内容 
    img=tf.decode_raw(features['img_raw'],tf.uint8)
    img = tf.reshape(img, [250, 250, 3])
    label = tf.cast(features['label'], tf.int32)
    return img,label  


#write_binary() 

img,label = read_and_decode('data.tfrecord')  

img_batch, label_batch = tf.train.shuffle_batch([img,label], batch_size=18, capacity=2000, min_after_dequeue=100, num_threads=2)  
## 
# sess 
init = tf.global_variables_initializer()

with tf.Session() as sess:
    sess.run(init)  
    coord = tf.train.Coordinator()  #建立一个协调器，管理线程
    #启动QueueRunner, 此时文件名队列已经进队。
    threads=tf.train.start_queue_runners(sess=sess,coord=coord)  

    img, label = sess.run([img_batch, label_batch])  
    #for i in range(18):
    # cv2.imwrite('%d_%d_p.jpg'%(i,label[i]),img[i])
    coord.request_stop()
    coord.join(threads)

http://blog.csdn.net/happyhorizion/article/details/77894055
http://blog.csdn.net/ei1990/article/details/76575935

tf.app.run:
利用tensorflow的FLAGS解析功能。

tf.app.flags.DEFINE_boolean("self_test", False, "True if running a self test.")  
tf.app.flags.DEFINE_boolean('use_fp16', False,  
                            "Use half floats instead of full floats if True.")  
FLAGS = tf.app.flags.FLAGS  

def main():
    # using FLAGS.self_test

if __name__ == '__main__':
    tf.app.run()

tf.app.run源码定义以下，主要解析参数，并调用main函数:

import sys
from tensorflow.python.platform import flags  
    
def run(main=None):  
  f = flags.FLAGS  
  f._parse_flags()  
  main = main or sys.modules['__main__'].main  
  sys.exit(main(sys.argv))

3、Debug

使用TensorFlow的Debugger并不困难，大体总结起来有这么几个流程：
1.import要使用的TensorFlow的调试模块

from tensorflow.python import debug as tfdbg

2.使用调试模块的会话对象包装原有的Session对象

with tf.Session(config=config) as sess: 
	sess = tfdbg.LocalCLIDebugWrapperSession(sess)

3.加入异常值对应的过滤器

sess.add_tensor_filter("has_inf_or_nan", tfdbg.has_nan_or_inf)

4.运行代码，并在带过滤器的状况下运行

r -f has_inf_or_nan

5.跟踪异常值产生的节点，并找到异常值来源在源码中的位置（这个比较灵活，有些可能须要回溯几个节点，有些直接可查）

ni -t Discrim/add_2

官方连接：
https://www.tensorflow.org/programmers_guide/debugger#wrapping_tensorflow_sessions_with_tfdbg

4、TensorBoard

使用tensorboard来可视化训练过程。

  1. 使用scalar, histogram, image等表示须要记录的变量：

    tf.summary.scalar("train_loss", loss_op)
 tf.summary.scalar("train_acc", acc_op)

  2. 建立summary_op与summarywriter

    sum_op = tf.summary.merge_all()
 writer = tf.summary.fileWriter('./logs/test_cnn/', flush_secs=60)

  3. 能够添加Graph：

    writer.add_graph(tf.get_default_graph())

  4. 运行时添加summary

    sum_str, _ = sess.run([sum_op, train_op], feed_dict={...})
 writer.add(sum_str)

  5. 使用tensorboard可视化

    tensorboard --logdir=logs/test_cnn/

会提示访问的ip地址，浏览器中打开能够看到可视化结果。

由于tensorflow可能生成较多的结点，这样可视化起来特别复杂。能够将多个结点放到一个名称域里，这样在可视化的时候，只有最上层的结点展现出来，双击能够打开这个名称域。

5、保存模型

TensorFlow保存模型使用tf.train.Saver():

saver = tf.train.Saver()
with tf.Session as sess:
    for i in range(100):
        sess.run([], feed_dict=...)
        if i % 10 == 0:
            saver.save(sess, os.path.join(model_dir, model_name), global_step=i)

以前的版本只会生成一个文件.ckpt，如今版本会生成4个文件，分别是.ckpt.meta, .ckpt.data, .ckpt.index, checkpoint。

checkpoint: 记录了全部checkpoint点保存的模型以及最新的模型
.ckpt.meta: 保存了网络的Graph图
.ckpt.data: 保存了网络的权重参数
.ckpt.index:

在定义Saver时，能够只保存部分变量：

# 使用字典
saver = tf.train.Saver({'v1': v1, 'v2': v2})
# 使用列表
saver = tf.train.Saver([v1, v2])

# 使用列表初始一个字典
saver = tf.train.Saver({v.op.name: v for v in [v1, v2]})

重载model，使用restore函数，以下：

#使用lastest_checkpoint
model_file = tf.train.latest_checkpoint(model_dir)
saver.restore(sess, model_file)

#使用save时的文件名
saver.restore(sess, os.path.join(model_dir, model_name))

为了使用的时候，再也不次定义模型，可使用以下代码将graph加载进来，而且经过字符串名访问模型中的变量、hld变量、运算结点：

sess = tf.Session()
 
    # 《《《 加载模型结构 》》》
    saver = tf.train.import_meta_graph('./ckpt/model.ckpt.meta') 
    # 只须要指定目录就能够恢复全部变量信息 
   saver.restore(sess, tf.train.latest_checkpoint('./ckpt'))  

    # 直接获取保存的变量
    print(sess.run('b:0'))

    # 获取placeholder变量
    input_x = sess.graph.get_tensor_by_name('x:0')
    input_y = sess.graph.get_tensor_by_name('y:0')
    
    # 获取须要进行计算的operator
    op = sess.graph.get_tensor_by_name('op_to_store:0')

    # 加入新的操做
    add_on_op = tf.multiply(op, 2)

    ret = sess.run(add_on_op, {input_x: 5, input_y: 5})
    print(ret)

参考：
https://zhuanlan.zhihu.com/p/32887066

6、共享变量

为何要共享变量：

若是一个函数中建立了变量，须要调用屡次，就会产生多个这样的变量，命令方式如下划线数字方式递增，如weight, weight_1, weight_2, weight_3等，因此会产生多个变量，形成没必要要的浪费。咱们实际想反复利用weight这个变量就够了，使用全局变量能够解决产生屡次的问题，但影响封装。这时只须要将weight设为共享变量，那么就会只初始化一次，反复使用的都是这个变量。

name_scope：

若是使用tf.Variable定义了相同名字的变量，tf会自动给变量加下划线区分。

tf中提供name_scope限制变量做用域，能够将变量放置到不一样的命名域中管理。

with namescope('conv1'):
    w1 = tf.Variable([1.0, 2.0], name='weights')
    b1 = tf.Variable([1.0, 2.0], name='bias')
    
with namescope('conv2'):
    w2 = tf.Variable([1.0, 2.0], name='weights')
    b2 = tf.Variable([1.0, 2.0], name='bias')

w1的name为conv1/weights:0, w2的name为conv2/weights: 0。

执行完 with 里边的语句以后，这个 conv1/ 和 conv2/ 空间仍是在内存中的。这时候若是再次执行上面的代码就会再生成其余命名空间，加了个_1以下：
w1的name为conv1_1/weights:0, w2的name为conv2_1/weights: 0

variable_scope, get_variable:

使用variable_scope和get_variable能够实现共享变量。
首先须要在一个做用域定义一个变量，在另一个同名做用域中设置reuse=True，并使用tf.get_variable()获取这个共享变量：

# 共享变量必须使用get_variable定义，不能使用tf.Variable
with tf.variable_scope('test'):
    w = tf.get_variable('weights', shape=[5, 3])

# 须要置reuse=True
with tf.variable_scope('test', reuse=True):
    w = tf.get_variable('weights')

设置reuse=True的子块中，全部使用用到的共享变量必须事先使用tf.get_variable定义好，不然会报变量不存在。

get_variable会在变量不存在时自动建立一个，此时必需要提供shape参数；在设置reuse=True时，使用已经存在的变量。

也能够在语句中设置scope为reuse，以下：

# 共享变量必须使用get_variable定义，不能使用tf.Variable
with tf.variable_scope('test'):
    w = tf.get_variable('weights', shape=[5, 3])

with tf.variable_scope('test') as scope:
    scope.reuse_variables()
    w = tf.get_variable('weights')

Others

1. Anaconda

conda create -n tensorflow_1.6 python=2.7
source activate tensorflow_1.6
pip install 
source deactivate

视频教程

http://www.javashuo.com/article/p-aeximyar-bq.html
http://mooc.study.163.com/smartSpec/detail/1001319001.htm
http://i.youku.com/pythontutorial
http://blog.csdn.net/lqf921205/article/details/78702704
http://open.163.com/special/opencourse/machinelearning.html

Reading

  1. 官方中文教程
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程