1
sess.run(tf.global_variables_initializer())，初始化模型的参数
2
tf.truncated_normal与tf.random_normal生成符合正态分布的随机数
tf.truncated_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None)
tf.random_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None)
shape: 一维的张量，也是输出的张量。
mean: 正态分布的均值。
stddev: 正态分布的标准差。
dtype: 输出的类型。
seed: 一个整数，当设置之后，每次生成的随机数都一样。
name: 操作的名字。
a = tf.Variable(tf.random_normal([2,2],seed=1))
b = tf.Variable(tf.truncated_normal([2,2],seed=2))
init = tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init)
print(sess.run(a))
print(sess.run(b))
3
numpy.random.randn()与rand()用来产生随机数的函数
numpy.random.randn(d0, d1, …, dn)是从标准正态分布中返回一个或多个样本值。
numpy.random.rand(d0, d1, …, dn)的随机样本位于[0, 1)中。
4
tf.Session()和tf.Session().as_default()创建会话
tf.Session()：创建一个会话
tf.Session().as_default()：创建一个默认会话
tf.Session()创建一个会话，当上下文管理器退出时会话关闭和资源释放自动完成。
tf.Session().as_default()创建一个默认会话，当上下文管理器退出时会话没有关闭，还可以通过调用会话进行run()和eval()操作
import tensorflow as tf
a = tf.constant(1.0)
b = tf.constant(2.0)
with tf.Session() as sess:
print(a.eval())
print(b.eval(session=sess))#报错RuntimeError: Attempted to use a closed Session.
import tensorflow as tf
a = tf.constant(1.0)
b = tf.constant(2.0)
with tf.Session().as_default() as sess:
print(a.eval())
print(b.eval(session=sess))
import tensorflow as tf
a = tf.constant(1.0)
b = tf.constant(2.0)
with tf.Session().as_default() as sess:
print(a.eval())
sess.close()
print(b.eval(session=sess))#报错RuntimeError: Attempted to use a closed Session.
5
tf.placeholder()
tf.placeholder(dtype, shape=None, name=None)
dtype：数据类型。常用的是tf.float32,tf.float64等数值类型。
shape：数据形状。默认是None，就是一维值，也可以是多维，比如[2,3], [None, 3]表示列是3，行不定。
name：名称。
import tensorflow as tf
import numpy as np
input1 = tf.placeholder(tf.float32)
input2 = tf.placeholder(tf.float32)
output = tf.multiply(input1, input2)
with tf.Session() as sess:
print sess.run(output, feed_dict = {input1:[3.], input2: [4.]})
import tensorflow as tf
import numpy as np
x = tf.placeholder(tf.float32, shape=(1024, 1024))
y = tf.matmul(x, x)
with tf.Session() as sess:
# print(sess.run(y)) # ERROR: x is none now
rand_array = np.random.rand(1024, 1024)
print(sess.run(y, feed_dict={x: rand_array})) # Will succeed.
6
tf.Session()和tf.InteractiveSession()的区别
tf.InteractiveSession()是一种交互式的session方式，它让自己成为了默认的session，也就是说用户在不需要指明用哪个sessio
运行的情况下，就可以运行起来，这就是默认的好处。这样的话就是run()和eval()函数可以不指明session
import tensorflow as tf
import numpy as np
a=tf.constant([[1., 2., 3.],[4., 5., 6.]])
b=np.float32(np.random.randn(3,2))
c=tf.matmul(a,b)
init=tf.global_variables_initializer()
sess=tf.Session()
print (c.eval())
解决方法1：
sess=tf.Session()
print (c.eval(session=sess))
解决方法2：
with tf.Session() as sess:
#print (sess.run(c))
print(c.eval())
import tensorflow as tf
import numpy as np
a=tf.constant([[1., 2., 3.],[4., 5., 6.]])
b=np.float32(np.random.randn(3,2))
c=tf.matmul(a,b)
init=tf.global_variables_initializer()
sess=tf.InteractiveSession()
print (c.eval())
7
tf.matmul 矩阵a*b
# 2-D tensor `a`
a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3]) => [[1. 2. 3.]
[4. 5. 6.]]
# 2-D tensor `b`
b = tf.constant([7, 8, 9, 10, 11, 12], shape=[3, 2]) => [[7. 8.]
[9. 10.]
[11. 12.]]
c = tf.matmul(a, b) => [[58 64]
[139 154]]
# 3-D tensor `a`
a = tf.constant(np.arange(1,13), shape=[2, 2, 3]) => [[[ 1. 2. 3.]
[ 4. 5. 6.]],
[[ 7. 8. 9.]
[10. 11. 12.]]]
# 3-D tensor `b`
b = tf.constant(np.arange(13,25), shape=[2, 3, 2]) => [[[13. 14.]
[15. 16.]
[17. 18.]],
[[19. 20.]
[21. 22.]
[23. 24.]]]
c = tf.matmul(a, b) => [[[ 94 100]
[229 244]],
[[508 532]
[697 730]]]
8
t.eval()
f.Tensor.eval(feed_dict=None, session=None)：
作用：
参数：
feed_dict:一个字典，用来表示tensor被feed的值（联系placeholder一起看）
session:（可选） 用来计算（evaluate）这个tensor的session.要是没有指定的话，那么就会使用默认的session。
Tensor的值能够通过把Tensor传到Seesion.run（）这个函数里面去得到结果。相同的，也可以用t.eval()这个函数，其中的t就
是你的tensor啦，这个函数可以算是tf.get_default_session().run(t)的简便写法
9
input_data.read_data_set()下载数据集
import input_data
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
下载下来的数据集被分成两部分：60000行的训练数据集（mnist.train）和10000行的测试数据集（mnist.test）。
每一张图片包含28像素X28像素。我们可以用一个数字数组来表示这张图片：
我们把这个数组展开成一个向量，长度是 28x28 = 784
因此，在MNIST训练数据集中，mnist.train.images 是一个形状为 [60000, 784] 的张量，第一个维度数字用来索引图片，第二个
维度数字用来索引每张图片中的像素点。在此张量里的每一个元素，都表示某张图片里的某个像素的强度值，值介于0和1之间。
相对应的MNIST数据集的标签是介于0到9的数字，用来描述给定图片里表示的数字.因此， mnist.train.labels 是一个 [60000, 10]
的数字矩阵。
10
tf.Variable()定义图变量
当使用tf.get_variable定义变量时，如果出现同名的情况将会引起报错
tf.Variable.init(initial_value, trainable=True, collections=None, validate_shape=True, name=None)
参数名称 参数类型 含义
initial_value 所有可以转换为Tensor的类型 变量的初始值
trainable bool 如果为True，会把它加入到GraphKeys.TRAINABLE_VARIABLES，
才能对它使用Optimizer
collections list 指定该图变量的类型、默认为[GraphKeys.GLOBAL_VARIABLES]
validate_shape bool 如果为False，则不进行类型和维度检查
name string 变量的名称，如果没有指定则系统会自动分配一个唯一的值
只有第一个参数initial_value是必需的
In [1]: import tensorflow as tf
In [2]: v = tf.Variable(3, name='v')
In [3]: v2 = v.assign(5)
In [4]: sess = tf.InteractiveSession()
In [5]: sess.run(v.initializer)
In [6]: sess.run(v)
Out[6]: 3
In [7]: sess.run(v2)
Out[7]: 5
11
tf.get_variable()定义图变量
而对于tf.Variable来说，却可以定义“同名”变量
tf.get_variable的必需参数（即第一个参数）并是图变量的名称。
https://blog.csdn.net/gg_18826075157/article/details/78368924
12
tf.constant()
tf.constant(value,dtype=None,shape=None,name=’Const’)
创建一个常量tensor，按照给出value来赋值，可以用shape来指定其形状。value可以是一个数，也可以是一个list。
如果是一个数，那么这个常亮中所有值的按该数来赋值。
如果是list,那么len(value)一定要小于等于shape展开后的长度。赋值时，先将value中的值逐个存入。不够的部分，则全部存入
value的最后一个值。
13
tf.nn.conv2d()实现卷积的函数
tf.nn.conv2d(input, filter, strides, padding, use_cudnn_on_gpu=None, name=None)
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
具体含义是[卷积核的高度，卷积核的宽度，图像通道数，卷积核个数
注意：第三维in_channels
strides：卷积时在图像每一维的步长，这是一个一维的向量，长度4
padding：string类型的量，只能是"SAME","VALID"其中之一，这个值决定了不同的卷积方式
use_cudnn_on_gpu:bool类型，是否使用cudnn加速，默认为true
name：用以指定该操作的name
结果返回一个Tensor，这个输出是feature map，shape仍然是[batch, height, width, channels]这种形式。
https://www.cnblogs.com/qggg/p/6832342.html
14
tf.nn.max_pool实现池化操作
tf.nn.max_pool(value, ksize, strides, padding, name=None)
value：需要池化的输入，池化层在卷积层后面，所以输入是feature map，依然是[batch, height, width, channels]的shape
ksize：池化窗口的大小，取一个四维向量，一般是[1, height, width, 1]
strides：和卷积类似，窗口在每一个维度上滑动的步长，也是[1, stride,stride, 1]
padding：和卷积类似，可以取'VALID' 或者'SAME'
返回一个Tensor，类型不变，shape仍然是[batch, height, width, channels]形式
15
tf.nn.relu()
tf.nn.relu(features, name = None)
计算激活函数relu，即max(features, 0)。即将矩阵中每行的非最大值置0
16
tf.reshape()
tensor = tf.constant([1, 2, 3, 4, 5, 6, 7,8])
sess.run(tf.initialize_all_variables())
print(sess.run(tensor))
[1 2 3 4 5 6 7 8]
tensorReshape = tf.reshape(tensor,[2,4])
print(sess.run(tensorReshape))
[[1 2 3 4]
[5 6 7 8]]
tensorReshape = tf.reshape(tensor,[1,2,4])
print(sess.run(tensorReshape))
[[[1 2 3 4]
[5 6 7 8]]]
tensorReshape = tf.reshape(tensor,[-1,2,2])
print(sess.run(tensorReshape))
[[[1 2]
[3 4]]
[[5 6]
[7 8]]]
所以-1，就是缺省值，就是先以你们合适，到时总数除以你们几个的乘积，我该是几就是几。
？？？
tf.reshape(x,[-1,28,28,1])
？？？
17
tf.nn.dropout()
tf.nn.dropout(x, keep_prob, noise_shape=None, seed=None,name=None)
x：输入
keep_prob: 设置神经元被选中的概率,在初始化时keep_prob是一个占位符, keep_prob = tf.placeholder(tf.float32) 。tensorflow在
run时设置keep_prob具体的值，例如keep_prob: 0.5
name：指定该操作的名字。
tf.nn.dropout是TensorFlow里面为了防止或减轻过拟合而使用的函数，它一般用在全连接层。
Dropout就是在不同的训练过程中随机扔掉一部分神经元。也就是让某个神经元的激活值以一定的概率p，让其停止工作，这次训
练过程中不更新权值，也不参加神经网络的计算。但是它的权重得保留下来（只是暂时不更新而已），因为下次样本输入时它可
能又得工作了。
18
tf.nn.softmax()与tf.nn.softmax_cross_entropy_with_logits
tf.nn.softmax(logits, name=None)
softmax[i, j] = exp(logits[i, j]) / sum(exp(logits[i]))
当分类的个数变为2时，Softmax回归又退化为logistic回归问题。
tf.nn.softmax_cross_entropy_with_logits(logits, labels, name=None)
logits：神经网络最后一层的输出有batch大小是[batchsize，num_classes]，单样本的大小是num_classes
labels：实际的标签，大小同上
name：操作的name
流程：
第一步：是先对网络最后一层的输出做一个softmax，这一步通常是求取输出属于某一类的概率，对于单样本而言，输出就是一
个num_classes大小的向量（[Y1，Y2,Y3...]其中Y1，Y2，Y3...分别代表了是属于该类的概率）
softmax的公式是：
第二步：softmax的输出向量[Y1，Y2,Y3...]和样本的实际标签做一个交叉熵，公式如下：
其中指代实际的标签中第i个的值（用mnist数据举例，如果是3，那么标签是[0，0，0，1，0，0，0，0，0，0]，除第4个值为1，
其他全为0），就是softmax的输出向量[Y1，Y2,Y3...]中，第i个元素的值
显而易见，预测越准确，结果的值越小（前面有负号），最后求一个平均，得到loss
注意：这个函数的返回值并不是一个数，而是一个向量。
如果要求交叉熵，我们要再做一步tf.reduce_sum操作,就是对向量里面所有元素求和。
如果求loss，则要做一步tf.reduce_mean操作，对向量求均值。
19
tf.reduce_sum()
reduce_sum应该理解为压缩求和，在tensor的某一维度上求值的函数
求最大值:
tf.reduce_max(input_tensor, reduction_indices=None, keep_dims=False, name=None)
求平均值:
tf.reduce_mean(input_tensor, reduction_indices=None, keep_dims=False, name=None)
求和:
tf.reduce_sum(input_tensor, reduction_indices=None, keep_dims=False, name=None)
input_tensor:待求值的tensor。
reduction_indices:在哪一维上求解，0代表列，1代表行， keep_dims=True：行的维度求和，[0, 1]：行列求和
#'x' is [[1, 1, 1]
[1, 1, 1]]
#求和
tf.reduce_sum(x) ==> 6
#按列求和
tf.reduce_sum(x, 0) ==> [2, 2, 2]
#按行求和
tf.reduce_sum(x, 1) ==> [3, 3]
#按照行的维度求和
tf.reduce_sum(x, 1, keep_dims=True) ==> [[3], [3]]
#行列求和
tf.reduce_sum(x, [0, 1]) ==> 6
20
优化器Optimizer
tf.train.Optimizer
优化器（optimizers）类的基类。这个类定义了在训练模型的时候添加一
个操作的API。基本上不用这个类
tf.train.GradientDescentOptimizer
这个类是实现梯度下降算法的优化器。
__init__(learning_rate, use_locking=False,name=’GradientDescent’)
learning_rate: A Tensor or a floating point value. 要使用的学习率
use_locking: 要是True的话，就对于更新操作（update operations.）使用锁
name: 名字，可选，默认是”GradientDescent”.
compute_gradients(loss,var_list=None,gate_gradients=GATE_OP,aggregation_method=None,colocate_gradients_with_ops=False,grad_loss=None)
作用：对于在变量列表（var_list）中的变量计算对于损失函数的梯度,这个函数返回一个（梯度，变量）对的列表，其中梯度就
是相对应变量的梯度了。这是minimize()函数的第一个部分，
参数：
loss: 待减小的值
var_list: 默认是在GraphKey.TRAINABLE_VARIABLES.
gate_gradients: 如何控制梯度的计算。 可选 GATE_NONE, GATE_OP, or GATE_GRAPH.
aggregation_method: 指定用于组合渐变项的方法。 有效值在AggregationMethod类中定义。
colocate_gradients_with_ops: 如果为True，请尝试将渐变与相应的op进行对齐。
grad_loss: 可选参数，一个计算损失的梯度的Tensor。
apply_gradients(grads_and_vars,global_step=None,name=None)
作用：按照梯度下降的方式加到变量上。这是minimize()函数的第二个步骤。 返回一个应用的操作。
参数:
grads_and_vars: compute_gradients()函数返回的(gradient, variable)对的列表
global_step: 可选变量，在变量更新后递增1。
name: 可选，名字
get_name()
minimize(loss,global_step=None,var_list=None,gate_gradients=GATE_OP,aggregation_method=None,colocate_gradients_with_ops=False,name=None,grad_loss=None)
作用：
非常常用的一个函数 ，通过更新var_list来减小loss，这个函数就是前面compute_gradients() 和apply_gradients().的结合
tf.train.AdadeltaOptimizer
实现了 Adadelta算法的优化器，Adagrad算法改进版本
tf.train.AdadeltaOptimizer.init(learning_rate=0.001, rho=0.95, epsilon=1e-08, use_locking=False, name=’Adadelta’)
作用：
构造一个使用Adadelta算法的优化器
参数：
learning_rate: tensor或者浮点数，学习率
rho: tensor或者浮点数. 衰减率。
epsilon: 张量或浮点值。 用于更好地调节grad更新的常数epsilon。
use_locking:如果True使用lock进行更新操作。
name: 【可选】这个操作的名字，默认是”Adadelta”
tf.train.AdagradOptimizer
实现Adagrad算法的优化器。
__init__(learning_rate, initial_accumulator_value=0.1, use_locking=False, name=’Adagrad’)
参数：
learning_rate：Tensor或浮点值。 学习率。
initial_accumulator_value：浮点值。 累加器的起始值必须为正。
use_locking：如果True使用lock进行更新操作。
name：应用渐变时创建的操作的可选名称前缀。 默认为“Adagrad”。
tf.train.MomentumOptimizer
实现Momentum算法的优化器。
__init __（learning_rate，momentum，use_locking = False，name ='Momentum'，use_nesterov = False）
参数：
learning_rate：Tensor或浮点值。 学习率。
momentum：张量或浮点值。 势头。
use_locking：如果True使用lock进行更新操作。
name：应用渐变时创建的操作的可选名称前缀。 默认为“Momentum”。
class tf.train.AdamOptimizer
实现了Adam算法的优化器
__ init __（learning_rate = 0.001，beta1 = 0.9，beta2 = 0.999，epsilon = 1e-08，use_locking = False，name ='Adam'）
参数：
learning_rate：Tensor或浮点值。学习率。
beta1：浮点值或常量浮点张量。第一时刻的指数衰减率估计。
beta2：浮点值或常量浮点张量。第二时刻的指数衰减率估计。
epsilon：数值稳定性的一个小常数。
use_locking：如果True使用锁定进行更新操作。
name：应用渐变时创建的操作的可选名称。默认为“Adam”。
使用：tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
https://blog.csdn.net/xierhacker/article/details/53174558
21
tf.equal()
tf.equal(A, B)
对比这两个矩阵或者向量的相等的元素，如果是相等的那就返回True，反正返回False，返回的值的矩阵维度和A是一样的
22
tf.argmax(）
tf.argmax(vector, axis)
返回vector中的最大值的索引号
vector：如果vector是一个向量，返回一个值，如果是一个矩阵，返回一个向量
axis：0代表列，1代表行
test = np.array([[1, 2, 3], [2, 3, 4], [5, 4, 3], [8, 7, 2]])
np.argmax(test, 0)
＃输出：array([3, 3, 1]
np.argmax(test, 1)
＃输出：array([2, 2, 0, 0]
23
tf.cast()
tf.cast()x, dtype, name=None)
类型转换函数
参数:
x：输入
dtype：转换目标类型
name：名称
返回：Tensor
24
扫一扫
19万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
