PYTHON TENSORFLOW手记

个人记性不好，经常性工作中忘记知识点，现在打算在做项目时候，哪些知识点淡忘了，就在CSDN上MARK一下。

mark 一下tensorflow 的流程：

• tensorflow的基础运算

tensorflow口诀：1.变量（variable)  2.tensor  3.会话  4 图  5.feed(与placeholder一块使用）

1.变量(variable)：用来记录一些数据和状态，是我们的容器

2.tensor：用来表示数据，是我们的原料

3.会话：建立会话，此时会生成一张空图；在会话中添加节点和边，形成一张图，一个会话可以有多张图，通过执行这些图得到结果。如果把每个图看作一个车床，那会话就是一个车间，里面有若干个车床，用来把数据生产成结果

4.图：用来表示计算任务，也就我们要做的一些操作

5.feed和fetch：可以为任意的操作赋值或者从其中获取数据。相当于一些铲子，可以操作数据。

形象的比喻就是：把会话看成车间，图看做车床，里面用TENSOR做原料，变量做容器，FEED和FETCH将数据feed给容器，，把容器再给到车床，从而使数据得到加工而得到我们要的结果。

例子：

#引入模块
import tensorflow as tf
#创建一个变量占位符
input1=tf.placeholder(tf.float32)
#创建一个变量占位符
input2=tf.placeholder(tf.float32)
#创建一个加法操作
new_value=tf.matmul(input1,input2)
#使用这种写法，再运行完毕后，会话会自动关闭
with tf.Session() as sess:
    print(sess.run(new_value,feed_dict={input1:23.0,input2:11.0}))

--------------------------------------------------------------------------------------------------------------------------------------------------

• tensorflow生成随机数

1.tf.random_normal(shape,mean=0.0,stddev=1.0,dtype=tf.float32,seed=None,name=None)  

从正太分布输出随机值

shape：一个一维整数张量或Python数组。代表张量的形状。
mean：数据类型为dtype的张量值或Python值。是正态分布的均值。
stddev：数据类型为dtype的张量值或Python值。是正态分布的标准差
dtype： 输出的数据类型。
seed：一个Python整数。是随机种子。
name： 操作的名称(可选)

2.tf.random_uniform(shape,minval=0.0,maxval=1.0,dtype=tf.float32,seed=None,name=None) 

从均匀分布中返回随机值

返回值的范围默认是0到1的左闭右开区间，即[0，1)。minval为指定最小边界，默认为1。maxval为指定的最大边界，如果是数据浮点型则默认为1，如果数据为整形则必须指定。

3.tf.truncated_normal

截断的正态分布函数。生成的值遵循一个正态分布，但不会大于平均值2个标准差。

truncated_normal(  
    shape,#一个一维整数张量或Python数组。代表张量的形状。  
    mean=0.0,#数据类型为dtype的张量值或Python值。是正态分布的均值。  
    stddev=1.0,#数据类型为dtype的张量值或Python值。是正态分布的标准差  
    dtype=tf.float32,#输出的数据类型。  
    seed=None,#一个Python整数。是随机种子。  
    name=None#操作的名称(可选)  
)  

 4.tf.random_shuffle

沿着要洗牌的张量的第一个维度，随机打乱。

random_shuffle(  
    value,# 要被洗牌的张量  
    seed=None,  
    name=None  
)  

例

[[1, 2],       [[5, 6],  
 [3, 4],  ==>   [1, 2],  
 [5, 6]]        [3, 4]]  

 

5.tf.random_crop(value, size, seed=None, name=None)

tf.random_crop是tensorflow中的随机裁剪函数，可以用来裁剪图片

例：

import tensorflow as tf
import matplotlib.image as img
import matplotlib.pyplot as plt
sess = tf.InteractiveSession()
image = img.imread('D:/Documents/Pictures/logo3.jpg')

reshaped_image = tf.cast(image,tf.float32)
size = tf.cast(tf.shape(reshaped_image).eval(),tf.int32)
height = sess.run(size[0]//2)
width = sess.run(size[1]//2)
distorted_image = tf.random_crop(reshaped_image,[height,width,3])
print(tf.shape(reshaped_image).eval())
print(tf.shape(distorted_image).eval())

#输出
[1200,1920,3]
[600.960,3]

 

6.tf.multinomial(logits, num_samples, seed=None, name=None)

对这一函数还没理解透，等后续项目中接触到，再回来mark.

7.tf.random_gamma(shape, alpha, beta=None, dtype=tf.float32, seed=None, name=None)

类似于tf.random_normal的用法，但是andom_gamma是gamma分布取数。

8.tf.set_random_seed(seed)

设置随机种子，但是随机种子又分为两类，图级种子，和操作种子。这两个区别具体解释，见百度。

• 创建常数张量

1.tf.constant(value, dtype=None, shape=None, name='Const')

tf.constant创建一个常数张量。
tf.constant(value, dtype, shape, name, verify_shape)
value：输出类型的常量值（或列表）dtype。
dtype：结果张量的元素类型。
shape：结果张量的可选维数。
name：张量的可选名称。
verify_shape：布尔值，用于验证值的形状。

2.tf.fill(dims, value, name=None)

创建一个维度为dims，值为value的tensor对象．该操作会创建一个维度为dims的tensor对象，并将其值设置为value，该tensor对象中的值类型和value一致。当value为０时，该方法等同于tf.zeros()；当value为１时，该方法等同于tf.ones()

参数：dims: 类型为int32的tensor对象，用于表示输出的维度(1-D, n-D)，通常为一个int32数组，如：[1], [2,3]等

value: 常量值(字符串，数字等)，该参数用于设置到最终返回的tensor对象值中

name:名字

其他：

tf.zeros(shape, dtype=tf.float32, name=None)

tf.zeros_like(tensor, dtype=None, name=None)

tf.ones(shape, dtype=tf.float32, name=None)

tf.ones_like(tensor, dtype=None, name=None)

• 初始化

1、tf.constant_initializer()

也可以简写为tf.Constant()

初始化为常数，这个非常有用，通常偏置项就是用它初始化的。

由它衍生出的两个初始化方法：

a、 tf.zeros_initializer()， 也可以简写为tf.Zeros()

b、tf.ones_initializer(), 也可以简写为tf.Ones()

其他：

tf.random_normal_initializer(mean=0.0, stddev=1.0, seed=None, dtype=tf.float32)

tf.truncated_normal_initializer(mean=0.0, stddev=1.0, seed=None, dtype=tf.float32)

tf.random_uniform_initializer(minval=0, maxval=None, seed=None, dtype=tf.float32)

tf.uniform_unit_scaling_initializer(factor=1.0, seed=None, dtype=tf.float32)

tf.orthogonal_initializer(gain=1.0, dtype=tf.float32, seed=None)

• tf.variable 和 tf.get_variable 的区别

tf.varable:

tf.Variable(initial_value=None, trainable=True, collections=None, validate_shape=True, caching_device=None, name=None, variable_def=None, dtype=None, expected_shape=None, import_scope=None)

tf.get_variable:

tf.get_variable(name, shape=None, dtype=None, initializer=None, regularizer=None, trainable=True, collections=None, caching_device=None, partitioner=None, validate_shape=True, custom_getter=None)

区别：

1.使用tf.Variable时，如果检测到命名冲突，系统会自己处理。使用tf.get_variable()时，系统不会处理冲突，而会报错

 

import tensorflow as tf
w_1 = tf.Variable(3,name="w_1")
w_2 = tf.Variable(1,name="w_1")
print w_1.name
print w_2.name
#输出
#w_1:0
#w_1_1:0

import tensorflow as tf

w_1 = tf.get_variable(name="w_1",initializer=1)
w_2 = tf.get_variable(name="w_1",initializer=2)
#错误信息
#ValueError: Variable w_1 already exists, disallowed. Did
#you mean to set reuse=True in VarScope?

当同时命名为W_1时，tf.variable会进行自动处理，如处理成上图中的w_1_1。而当使用tf.get_variable时，相同命名w_1时，会报错。基于这两个函数的特性，当我们需要共享变量的时候，需要使用tf.get_variable()，此时就需要用到reuse()。在其他情况下，这两个的用法是一样的。

再看以下例子：

import tensorflow as tf

with tf.variable_scope("scope1"):
    w1 = tf.get_variable("w1", shape=[])
    w2 = tf.Variable(0.0, name="w2")
with tf.variable_scope("scope1", reuse=True):
    w1_p = tf.get_variable("w1", shape=[])
    w2_p = tf.Variable(1.0, name="w2")

print(w1 is w1_p, w2 is w2_p)
#输出
#True  False

看到这，就可以明白官网上说的参数复用的真面目了。由于tf.Variable() 每次都在创建新对象，所有reuse=True 和它并没有什么关系。对于get_variable()，来说，如果已经创建的变量对象，就把那个对象返回，如果没有创建变量对象的话，就创建一个新的。