TensorFlow基础教程-优快云博客

本文链接：https://blog.youkuaiyun.com/github_37973614/article/details/81100939

看完训练一个神经网络的代码后的一个总结：

start：

（1）此处的variable在代码中使用W = tf.get_variable('W'. shape = [n1, n2, ...], initializer=....)来代替。注意：tf.Variable()和tf.get_variable()都可以用来创建变量，但是前者会自动保证唯一性，而后者不能保证唯一性。

（2）若有需要init的，则init = tf.global_variables_initializer()；session.run(init)：在运行模型中的其他操作之前，必须先进行变量初始化。最简单的方法是添加一个运行所有变量初始值的操作，并在使用模型之前运行该操作。

# Create two variables.
weights = tf.Variable(tf.random_normal([784, 200], stddev=0.35),
                      name="weights")
biases = tf.Variable(tf.zeros([200]), name="biases")
...
# Add an op to initialize the variables.
init_op = tf.global_variables_initializer()
 
# Later, when launching the model
with tf.Session() as sess:
  # Run the init operation.
  sess.run(init_op)
  ...
  # Use the model
  ...

（3）在最后需要将需要运行的定义好的函数进行session.run([fun1, fun2,....], feed_dict={X1: values1, X2: values2.....})feed_dict是需要传入的参数。

（4）feed_dict的作用是给使用placeholder创建出来的tensor赋值

（5）placeholder用于创建占位，当需要时再将数据传入进去，第一个参数是数据类型，第二个参数是数据的维数

end

零、tensorflow的计算一般可分成两个阶段：

第一阶段，定义所有的计算过程，即计算流图。在这个阶段，所有的变量均无实际参数值，仅仅表示一个计算过程；
第二阶段，执行运算，创建会话（Session)，此时才会对变量进行赋值；

零点一、TensorFlow 将图形定义转换成分布式执行的操作, 以充分利用可用的计算资源(如 CPU 或 GPU。一般你不需要显式指定使用 CPU 还是 GPU, TensorFlow 能自动检测。如果检测到 GPU, TensorFlow 会尽可能地利用找到的第一个 GPU 来执行操作. 并行计算能让代价大的算法计算加速执行，TensorFlow也在实现上对复杂操作进行了有效的改进。大部分核相关的操作都是设备相关的实现，比如GPU。下面是一些重要的操作/核：

零点二、

import tensorflow as tf
 #定义‘符号’变量，也称为占位符
 a = tf.placeholder("float")
 b = tf.placeholder("float")

 y = tf.mul(a, b) #构造一个op节点

 sess = tf.Session()#建立会话
 #运行会话，输入数据，并计算节点，同时打印结果
 print sess.run(y, feed_dict={a: 3, b: 3})
 # 任务完成, 关闭会话.
 sess.close()

零点三、Session：

Session是为了控制和输出文件的执行的语句，一个实例化Session为sess_test运行sess_test.run()可以获得我们要得知的运算结果，或者是我要运算的部分。

首先我们加载tensorflow，然后建立两个matrix，输出两个matrix矩阵相乘的结果。

import tensorflow as tf

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

因为product不是直接计算的步骤，所以我们会要使用Session来激活product并得到计算结果，有两种形式来使用会话控制结果：

#method 1
sess = tf.Session()
result = sess.run(product)
print(product)
sess.close()
# output:[[12]]
#method 2
with tf.Session as sess:
    result2 = sess.run(product)
    print(result2)
#output: [[12]]

一、constant（常量）

constant是TensorFlow的常量节点，通过constant方法创建，其是计算图（Computational Graph）中的起始节点，是传入数据。

cons = tf.constant(value=[1,2],dtype=tf.float32,shape=(1,2),name='testconst', verify_shape=False)

参数说明

value：初始值，必填，必须是一个张量（1或[1,2,3]或[[1,2,3],[2,2,3]]或......）

dtype：数据类型，选填，默认为value的数据类型，传入参数为tensorflow下的枚举值（float32，float64.......）

shape：数据形状，选填，默认为value的shape，设置时不得比value小，可以比value阶数、维度更高，超过部分按value提供最后一个数字填充。d

name：常量名，选填，默认值不重复，根据创建顺序为（Const，Const_1，Const_2.......）

verify_shape:是否验证value的shape和指定shape相符，若设为True则进行验证，不相符时会抛出异常

import tensorflow as tf

sess = tf.InteractiveSession()
cons1 = tf.constant([1, 2, 3], shape=[2, 3])
print(sess.run(cons1))
# [[1 2 3]
#  [3 3 3]]

二、placeholder（占位符）

可以查看：https://blog.youkuaiyun.com/Fly2Leo/article/details/78539950

placeholder是TensorFlow的占位符节点，由placeholder方法创建，其也是一种常量，但是由用户在调用run方法是传递的，也可以将placeholder理解为一种形参。即其不像constant那样直接可以使用，需要用户传递常数值。

X = tf.placeholder(dtype=tf.float32, shape=[144, 10], name='X')

参数说明

dtype：数据类型，必填，默认为value的数据类型，传入参数为tensorflow下的枚举值（float32，float64.......）

shape：数据形状，选填，不填则随传入数据的形状自行变动，可以在多次调用中传入不同形状的数据

name：常量名，选填，默认值不重复，根据创建顺序为（Placeholder，Placeholder_1，Placeholder_2.......）

import tensorflow as tf
import numpy.random as random

#占位符shape不设时会按传入参数自行匹配
node1 = tf.placeholder(tf.float32)  # , shape=[4, 5])
node2 = tf.placeholder(tf.float32)  # , shape=[4, 5])
op = tf.multiply(node1, node2)
session = tf.Session()
const1 = tf.constant(random.rand(4, 5))
const2 = tf.constant(random.rand(4, 5))
#可以传入初始化后的常量
print(session.run(op, {node1: session.run(const1), node2: session.run(const2)}))
#也可以直接传入张量，其实同初始化后的常量一致
print(session.run(op, {node1: random.rand(2, 3), node2: random.rand(2, 3)}))

三、variable（变量）

Vatiable是tensorflow的变量节点，通过Variable（注：V大写）方法创建，并且需要传递初始值。在使用前需要通过tensorflow的初始化方法进行初始化。

W = tf.Variable(initial_value=tf.zeros([9, 5]),  # 初始值，必填，张量或可以转换为张量的Python对象。初始值必须有指定一个形状，除非`validate_shape`设置为False。
                trainable=True,  # 如果`True`，则默认值也将变量添加到图形中集合`GraphKeys.TRAINABLE_VARIABLES`。这个集合用作“Optimizer”类使用的默认变量列表
                collections=None,  # 图表集合键的列表。新的变量被添加到这些集合。默认为`[GraphKeys.GLOBAL_VARIABLES]`。
                validate_shape=True,  # 如果`False`，允许变量用初始化未知形状的值。如果“True”，默认的形状`initial_value`必须是已知的。
                caching_device=None,  # 可选设备字符串，描述变量的位置应该被缓存以供阅读。默认为变量的设备。如果不是“None”，则缓存在另一个设备上。典型的用途是缓存在使用变量的Ops所在的设备上进行重复数据删除复制`Switch`和其他条件语句。
                name='W',  # 变量的可选名称。默认为“Variable”并获取自动去重（Variable_1,Variable_2....）。
                variable_def=None, # `VariableDef`协议缓冲区。如果不是“无”，则重新创建变量对象及其内容，引用变量的节点在图中，必须已经存在。图形没有改变。`variable_def`和其他参数是互斥的。
                dtype=tf.float32, # 如果设置，initial_value将被转换为给定的类型。如果`None'，数据类型将被保存（如果`initial_value`是一个张量），或者“convert_to_tensor”来决定。
                expected_shape=None,  # 张量的Shape。如果设置，initial_value需要符合这个形状。
                import_scope=None)  # 可选的字符串。名称范围添加到`Variable.`仅在从协议缓冲区初始化时使用。

参数说明Variable函数的全部参数如上方代码展示，不过目前学习中遇到常用的的参数只有如下几个，其他的参数暂时没在代码中遇到

initial_value，dtype，name，创建代码类似下面这样：

 W = tf.Variable(tf.zeros([3, 10]), dtype=tf.float64, name='W')

以上地址：http://www.cnblogs.com/Vulpers/p/7809276.html

4、tf.get_variable(name, shape, initializer)：

name就是变量的名称，shape是变量的维度，initializer是变量初始化的方式，初始化的方式有以下几种：

tf.constant_initializer：常量初始化函数

tf.random_normal_initializer：正态分布

tf.truncated_normal_initializer：截取的正态分布

tf.random_uniform_initializer：均匀分布

tf.zeros_initializer：全部是0

tf.ones_initializer：全是1

tf.uniform_unit_scaling_initializer：满足均匀分布，但不影响输出数量级的随机值

5、


def initialize_parameters():
    """
    Initializes weight parameters to build a neural network with tensorflow. The shapes are:
                        W1 : [4, 4, 3, 8]
                        W2 : [2, 2, 8, 16]
    Returns:
    parameters -- a dictionary of tensors containing W1, W2
    """

    tf.set_random_seed(1)                              # so that your "random" numbers match ours

    ### START CODE HERE ### (approx. 2 lines of code)
    W1 = tf.get_variable("W1", [4, 4, 3, 8], initializer=tf.contrib.layers.xavier_initializer(seed=0))
    W2 = tf.get_variable("W2", [2, 2, 8, 16], initializer=tf.contrib.layers.xavier_initializer(seed=0))
    ### END CODE HERE ###

    parameters = {"W1": W1,
                  "W2": W2}

    return parameters

tf.reset_default_graph()
with tf.Session() as sess_test:
    parameters = initialize_parameters()
    init = tf.global_variables_initializer()
    sess_test.run(init)
    print("W1 = " + str(parameters["W1"].eval()[1,1,1]))
    print("W2 = " + str(parameters["W2"].eval()[1,1,1]))

上图中在initialize_parameters（）中定义了变量W1，W2，然后用init = tf.global_variables_initializer()；sess_test.run(init)来激活这样两个变量才起作用。

5、tf.nn.conv2d(input, filter, strides, padding, use_cudnn_on_gpu=None, name=None)

除去name参数用以指定该操作的name，与方法有关的一共五个参数：

input：
指需要做卷积的输入图像，它要求是一个Tensor，具有[batch, in_height, in_width, in_channels]这样的shape，具体含义是[训练时一个batch的图片数量, 图片高度, 图片宽度, 图像通道数]，注意这是一个4维的Tensor，要求类型为float32和float64其中之一
filter：
相当于CNN中的卷积核，它要求是一个Tensor，具有[filter_height, filter_width, in_channels, out_channels]这样的shape，具体含义是[卷积核的高度，卷积核的宽度，图像通道数，卷积核个数]，要求类型与参数input相同，有一个地方需要注意，第三维in_channels，就是参数input的第四维
strides：卷积时在图像每一维的步长，这是一个一维的向量，长度4
padding：
string类型的量，只能是”SAME”,”VALID”其中之一，这个值决定了不同的卷积方式（后面会介绍）
use_cudnn_on_gpu：
bool类型，是否使用cudnn加速，默认为true

return：结果返回一个Tensor，这个输出，就是我们常说的feature map

实例：

那么TensorFlow的卷积具体是怎样实现的呢，用一些例子去解释它：

1.考虑一种最简单的情况，现在有一张3×3单通道的图像（对应的shape：[1，3，3，1]），用一个1×1的卷积核（对应的shape：[1，1，1，1]）去做卷积，最后会得到一张3×3的feature map

2.增加图片的通道数，使用一张3×3五通道的图像（对应的shape：[1，3，3，5]），用一个1×1的卷积核（对应的shape：[1，1，1，1]）去做卷积，仍然是一张3×3的feature map，这就相当于每一个像素点，卷积核都与该像素点的每一个通道做点积

input = tf.Variable(tf.random_normal([1, 3, 3, 5]))
filter = tf.Variable(tf.random_normal([3, 3, 5, 1]))

op = tf.nn.conv2d(input, filter, strides=[1, 1, 1, 1], padding='VALID')

init = tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init)    
    sess.run(op)

# 一幅3x3x5的图，3x3过滤器，最终得到一个值
# output:[[[[ 10.53139973]]]]

6、tf.nn.max_pool(value, ksize, stride, padding, name)

value：

需要池化的输入，一般池化层接在卷积层后面，所以输入通常是feature map，依然是[batch, height, wight, channels]这样的shape

ksize：

池化窗口的大小，取一个四维向量，一般是[1, height, width, 1]，因为我们不想在batch和channels上做池化，所以这两个维度设为了1

strides：

和卷积类似，窗口在每一个维度上滑动的步长，一般也是[1, stride,stride, 1]

padding：

和卷积类似，可以取'VALID' 或者'SAME'

name：指定该操作的名字

return：返回一个Tensor，类型不变，shape仍然是[batch, height, width, channels]这种形式

7、tf.nn.relu(features, name=None)

8、tf.contrib.layers.flatten(P):

将p伸展为一维的，但是保留batch的size——>返回的值的shape为[batch_size, k]

9、tf.contrib.layers.fully_connected(F, num_outputs)：num_outputs为softmax的概率输出

10、tf.nn.softmax_cross_entropy_with_logits(_sentinel=None, labels=None, logits=None, dim=-1, name=None)

Computes softmax cross entropy between logits and labels

logits就是神经网络最后一层的输出，如果又batch的话，它的大小就是[batch_size, num_classes]，单样本的话，大小就是num_classes

labels:实际的标签，大小同上

_sentinel:Used to prevent positional parameters. Internal, do not use
labels:
logits:
dim:
name:

return ：返回值是一个向量

11、tf.reduce_mean(input_tensor, axis=None, keepdims=None, name=None, reduction_indices=None, keep_dims=None)

example:

x = tf.constant([[1., 1.], [2., 2.]])
tf.reduce_mean(x)  # 1.5
tf.reduce_mean(x, 0)  # [1.5, 1.5]
tf.reduce_mean(x, 1)  # [1.,  2.]

12、Optimizers

tf.train.Optimizer

tf.train.GradientDescentOptimizer

tf.train.AdadeltaOptimizer

tf.train.AdagradeOptimizer

tf.train.AdagradDAOptimizer

tf.train.MomentumOptimizer

tf.train.AdamOptimizer

tf.train.Ftrloptimizer

tf.train.ProximalGradientDescentOptimizer

tf.train.ProximalAdagradOptimizer

tf.train.RMSPropOptimizer

详情参考手册

13、tf.argmax(input, dimension, name=None)

dimension=0按照列找，dimension=1按照行找，tf.argmax()返回最大数值的下标。通常和tf.equal()一起使用，计算模型准确度。

import tensorflow as tf
import numpy as np
 
A = [[1,3,4,5,6]]
B = [[1,3,4], [2,4,1]]
 
with tf.Session() as sess:
    print(sess.run(tf.argmax(A, 1)))
    print(sess.run(tf.argmax(B, 1)))

# Output:[4];  [2, 1]

tf.equal(A, B)是对比这两个矩阵或者向量的相等的元素，如果是相等的那就返回True，反正返回False，返回的值的矩阵维度和A是一样的

import tensorflow as tf
import numpy as np
 
A = [[1,3,4,5,6]]
B = [[1,3,4,3,2]]
 
with tf.Session() as sess:
    print(sess.run(tf.equal(A, B)))

#output:[[True True True False False]]

14、tf.cast()：用于改变某个张量的数据类型

开始的时候定义A没有给出类型，采用默认类型，整形。利用tf.cast函数就改为float类型

import tensorflow as tf;
import numpy as np;
 
A = tf.convert_to_tensor(np.array([[1,1,2,4], [3,4,8,5]]))
 
with tf.Session() as sess:
	print A.dtype
	b = tf.cast(A, tf.float32)
	print b.dtype

# Output:<dtype: 'int64'><dtype: 'float32'>

15、tf.reduce_mean(input_tensor, axis=None, keep_dims=False, name=None, reduction_indices=None)

作用：沿着tensor的某一维度，计算元素的平均值。由于输出tensor的维度比原tensor的低，这类操作也叫降维。

input_tensor:需要降维的tensor。

axis：axis=none, 求全部元素的平均值；axis=0, 按列降维，求每列平均值；axis=1，按行降维，求每行平均值。

keep_dims：若值为True，可多行输出平均值。

name：自定义操作的名称。

reduction_indices：axis的旧名，已停用。

降维后的tensor

import tensorflow as tf

x = tf.constant([[1, 2, 3], [4, 5, 6]])

with tf.Session() as sess:
    x = sess.run(x)
    mean1 = sess.run(tf.reduce_mean(x))
    mean2 = sess.run(tf.reduce_mean(x, 0))
    mean3 = sess.run(tf.reduce_mean(x, 1))
    
    print(x)
    print(mean1)
    print(mean2)
    print(mean3)

#Output:[[ 1.  2.  3.]
 [ 4.  5.  6.]]

3.5

[ 2.5  3.5  4.5]

[ 2.  5.]

16、eval(feed_dict=None, session=None)函数

feed_dict是需要传入的参数，同run()的feed_dict

使用eval()方法的前提是，当前运行时已经创建了默认的session，例如创建交互式session，sess = tf.InteractiveSession()，否则会出现如下错误，找不到缺省sesson。

对于张量来说，使用 eval() 方法可以查看张量的具体数值，该方法返回一个numpy数组

使用eval函数：t.eval()等价于tf.get_default_session().run(t)

tn = tf.random_normal([1, 10], mean=-1, stddev=4)
t = tf.ones(10)
tmp=tn + t
print(tmp.eval())


Output:array([[-9.58623028,  0.70157331,  7.56238651,  0.12382185,  1.78133655,
        -2.60228705,  2.09345794,  0.78153497,  4.40496349,  0.13798881]], dtype=float32)

可以使用sess.run()在同一步获取多个tensor中的值，使用Tensor.eval()时只能在同一步当中获取一个tensor值，并且每次使用 eval 和 run时，都会执行整个计算图。

17、tf.contrib.layers.flatten(inputs, outputs_collections=None,scope=None)

inputs:A tensor of size [batch_size, ...].

outputs_collection: Collection to add the outputs.

scope:Optional scope for name_scope

return:A flattened tensor with shape [batch_size, k]

Raises:

vauleerror: If inputs rank is unknown or less than 2.

18、tf.boolean_mask()

# 2-D example
  tensor = [[1, 2], [3, 4], [5, 6]]
  mask = np.array([True, False, True])
  boolean_mask(tensor, mask)  # [[1, 2], [5, 6]]
  ```

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

从正太分布里输出随机数。

20、

from keras import backend as K

K.argmax(x, axis=-1, keepdims=None)或者K.max(x,axis=-1, keepdims=None), axis=-1表示倒数第一个维度，而且如果keepdims=False，那么将不会保存去最大值或最大index的那个维度：

如：K.argmax(x, axis=-1, keepdims=Flase) # x.shape=(19, 19, 5, 80),那么result.shape=(19, 19, 5)，但是如果是True的话，则为shape=(19, 19, 5, 1)

21、from keras import backend as K

K.concatenate(x, axis=- 1):在对应维度上的一个加法，比如shape=(2, 3)与shape=(2, 3)，axis=0:得到shape=(4, 3),axis=1得到shape=(2, 6)

K.gather(reference, indices):reference is a tensor, and indices is an integer tensor of indices

>>> a=np.array([[1,2,3],[4,5,6]])
  >>> b=np.array([[11,21,31],[7,8,9]])
  # 合并行
  >>> np.concatenate((a,b,c),axis=0)  # 默认情况下，axis=0可以不写
  array([[ 1,  2,  3],
   [ 4,  5,  6],
   [11, 21, 31],
   [ 7,  8,  9]])
  # 合并列
  >>> np.concatenate((a,b),axis=1) 
   array([[ 1,  2,  3, 11, 21, 31],
   [ 4,  5,  6,  7,  8,  9]])