Tensorflow常用函数

发表于   |   分类于

Referrence

Tensorflow常用函数说明
Tensorflow入门教程合集
图解TensorFlow
TensorFlow博客资源
Tensorflow学习资料

Reference

TensorFlow入门教程之0: BigPicture&极速入门
TensorFlow入门教程之1: 基本概念以及理解
TensorFlow入门教程之2: 安装和使用
TensorFlow入门教程之3: CNN卷积神经网络的基本定义理解
TensorFlow入门教程之4: 实现一个自创的CNN卷积神经网络
TensorFlow入门教程之5: TensorBoard面板可视化管理
TensorFlow入门教程之6: AlphaGo 的策略网络（CNN）简单的实现
TensorFlow入门教程之7: 训练的模型Model 保存 文件 并使用
TensorFlow入门教程之8: DNN深度神经网络 的原理 以及 使用
TensorFlow入门教程之9: 接着补充一章MLP多层感知器网络原理以及 使用
TensorFlow入门教程之10: RNN循环网络原理以及使用
TensorFlow入门教程之11: 使用TensorFlow实现RNN
TensorFlow入门教程之12: 最强网络RSNN深度残差网络 平均准确率96-99%
TensorFlow入门教程之13: 最强网络DLSTM 双向长短期记忆网络（阿里小AI实现）
TensorFlow入门教程之14: Tensorflow Caffe相互转换
TensorFlow入门教程之15: Tensorflow RCNN区域卷积神经网络
Tensorflow入门教程之16: 模型AutoEncoder自编码机网络
Tensorflow入门教程之17: Tensorflow人工智能分布式实现
查看TensorFlow版本：
import tensorflow as tf
tf.version
tf.path

查看Linux版本
cat /etc/issue
cat /proc/version

tensorflow自学之前的bigpicture

1、tf.contrib.learn，tf.contrib.slim，Keras 等，它们都提供了高层封装
2、计算图：有向无环图
3、相关概念
Tensor：类型化的多维数组，图的边；
Operation:执行计算的单元，图的节点；
Graph：一张有边与点的图，其表示了需要进行计算的任务；
Session:称之为会话的上下文，用于执行图。
Graph仅仅定义了所有 operation 与 tensor 流向，没有进行任何计算。而session根据 graph 的定义分配资源，计算 operation，得出结果。既然是图就会有点与边，在图计算中 operation 就是点而 tensor 就是边。Operation 可以是加减乘除等数学运算，也可以是各种各样的优化算法。每个 operation 都会有零个或多个输入，零个或多个输出。 tensor 就是其输入与输出，其可以表示一维二维多维向量或者常量。而且除了Variables指向的 tensor 外所有的 tensor 在流入下一个节点后都不再保存。
4、数据结构
rank：Rank一般是指数据的维度，其与线性代数中的rank不是一个概念
Shape：Shape指tensor每个维度数据的个数，可以用python的list/tuple表示。
data type：Data type，是指单个数据的类型。常用DT_FLOAT，也就是32位的浮点数。
5、Variables
5.1、介绍
当训练模型时，需要使用Variables保存与更新参数。Variables会保存在内存当中，所有tensor一旦拥有Variables的指向就不会在session中丢失。其必须明确的初始化而且可以通过Saver保存到磁盘上。Variables可以通过Variables初始化。
5.2初始化
实际在其初始化过程中做了很多的操作，比如初始化空间，赋初值（等价于tf.assign），并把Variable添加到graph中等操作。
5.3Variables与constant的区别
Constant一般是常量，可以被赋值给Variables，constant保存在graph中，如果graph重复载入那么constant也会重复载入，其非常浪费资源，如非必要尽量不使用其保存大量数据。
5.4命名
另外一个值得注意的地方是尽量每一个变量都明确的命名，这样易于管理命令空间，而且在导入模型的时候不会造成不同模型之间的命名冲突，这样就可以在一张graph中容纳很多个模型。
6、placeholders与feed_dict
当我们定义一张graph时，有时候并不知道需要计算的值，比如模型的输入数据，其只有在训练与预测时才会有值。这时就需要placeholder与feed_dict的帮助。

基本概念以及理解

https://my.oschina.net/yilian/blog/659618

安装和使用

http://blog.csdn.net/kkk584520/article/details/51476816

CNN卷积神经网络的基本定义理解

1
2
3
4
5
6
7
8
9
10
11
12
13
def conv2d(x, w, b):
	return tf.nn.relu(tf.nn.bias_add(tf.nn.conv2d(x, w, strides=[1, 1, 1, 1], padding='SAME'),b)) #卷积层 定义 relu(wx+b)  
x = tf.placeholder(tf.float32, [None, w*h]) 
y = tf.placeholder(tf.float32, [None, ysize])#y的数目个数 比如3个类 就是3
wc=tf.Variable(tf.random_normal([3, 3, 1, 64]) #3 3 分别为3x3大小的卷积核 1为输入数目 
#因为是第一层所以是1 输出我们配置的64 ，初步理解这个输出是卷积核的个数
#所以我们知道了 如果下一次卷积wc2=[5,5,64,256] 
#5x5 是我们配置的卷积核大小，第三位表示输入数目 我们通过上面知道 上面的输出 也就是下一层的输入 所以 就是64 #了输出我们定义成256 #这个随你喜好，关键要迭代看效果，一般都是某一个v*v的值
b1=tf.Variable(tf.random_normal([64]))	#同样可以知道b2=[256]
def max_pool_kxk(x):
	return tf.nn.max_pool(x, ksize=[1, k, k, 1],
                    strides=[1, k, k, 1], padding='SAME')# 参数的含义需要进一步考证
#池化层k*k里面取最大值

eg：
​

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
import input_data
mnist = input_data.read_data_sets("/tmp/data/", one_hot=True)
import tensorflow as tf
# Parameters
learning_rate = 0.001
training_iters = 100000
batch_size = 128
display_step = 10
# Network Parameters
n_input = 784 # MNIST data input (img shape: 28*28)
n_classes = 10 # MNIST total classes (0-9 digits)
dropout = 0.75 # Dropout, probability to keep units
# tf Graph input
x = tf.placeholder(tf.float32, [None, n_input])
y = tf.placeholder(tf.float32, [None, n_classes])
keep_prob = tf.placeholder(tf.float32) #dropout (keep probability)
# Create model
def conv2d(img, w, b):
	return tf.nn.relu(tf.nn.bias_add(tf.nn.conv2d(img, w, strides=[1, 1, 1, 1], padding='SAME'),b))
	
	#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"其中之一，这个值决定了不同的卷积方式（后面会介绍）
	#"Same"表示表示卷积核可以停留在图像边缘，valid只考虑有效的像素点
	#第五个参数：use_cudnn_on_gpu:bool类型，是否使用cudnn加速，默认为true
	#结果返回一个Tensor，这个输出，就是我们常说的feature map
	#http://blog.csdn.net/mao_xiao_feng/article/details/53444333
def max_pool(img, k):
	return tf.nn.max_pool(img, ksize=[1, k, k, 1], strides=[1, k, k, 1], padding='SAME')
	
	#tf.nn.max_pool(value, ksize, strides, padding, name=None)
	#参数是四个，和卷积很类似：
	#第一个参数value：需要池化的输入，一般池化层接在卷积层后面，所以输入通常是feature map，依然是[batch, height, width, channels]这样的shape
	#第二个参数ksize：池化窗口的大小，取一个四维向量，一般是[1, height, width, 1]，因为我们不想在batch和channels上做池化，所以这两个维度设为了1
	#第三个参数strides：和卷积类似，窗口在每一个维度上滑动的步长，一般也是[1, stride,stride, 1]
	#第四个参数padding：和卷积类似，可以取'VALID' 或者'SAME'
	#返回一个Tensor，类型不变，shape仍然是[batch, height, width, channels]这种形式
def conv_net(_X, _weights, _biases, _dropout):
	# Reshape input picture
	_X = tf.reshape(_X, shape=[-1, 28, 28, 1]) # -1表示会自动计算出来该维的值，注意最后面的1
	# Convolution Layer
	conv1 = conv2d(_X, _weights['wc1'], _biases['bc1'])
	# Max Pooling (down-sampling)
	conv1 = max_pool(conv1, k=2)
	# Apply Dropout
	conv1 = tf.nn.dropout(conv1, _dropout) # 按照一定的比例dropout某些节点，防止过拟合 参考 http://www.cnblogs.com/tornadomeet/p/3258122.html
	
	# Convolution Layer
	conv2 = conv2d(conv1, _weights['wc2'], _biases['bc2'])
	# Max Pooling (down-sampling)
	conv2 = max_pool(conv2, k=2) 
	# Apply Dropout
	conv2 = tf.nn.dropout(conv2, _dropout)
	# Fully connected layer
	dense1 = tf.reshape(conv2, [-1, _weights['wd1'].get_shape().as_list()[0]]) # Reshape conv2 output to fit dense layer input
	dense1 = tf.nn.relu(tf.add(tf.matmul(dense1, _weights['wd1']), _biases['bd1'])) # Relu activation
	dense1 = tf.nn.dropout(dense1, _dropout) # Apply Dropout
	# Output, class prediction
	out = tf.add(tf.matmul(dense1, _weights['out']), _biases['out'])
	return out
# Store layers weight & bias
weights = {
	'wc1': tf.Variable(tf.random_normal([5, 5, 1, 32])), # 5x5 conv, 1 input, 32 outputs
	'wc2': tf.Variable(tf.random_normal([5, 5, 32, 64])), # 5x5 conv, 32 inputs, 64 outputs
	'wd1': tf.Variable(tf.random_normal([7*7*64, 1024])), # fully connected, 7*7*64 inputs, 1024 outputs
	'out': tf.Variable(tf.random_normal([1024, n_classes])) # 1024 inputs, 10 outputs (class prediction)
}
biases = {
	'bc1': tf.Variable(tf.random_normal([32])),
	'bc2': tf.Variable(tf.random_normal([64])),
	'bd1': tf.Variable(tf.random_normal([1024])),
	'out': tf.Variable(tf.random_normal([n_classes]))
}
# Construct model
pred = conv_net(x, weights, biases, keep_prob)
# Define loss and optimizer
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(pred, y))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)
# Evaluate model
correct_pred = tf.equal(tf.argmax(pred,1), tf.argmax(y,1)) 
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
#tf.argmax(input, axis=None, name=None, dimension=None)
#Returns the index with the largest value across axis of a tensor.
#tf.equal(a,b) 如果a,b是数组，返回长度一致的一维数组，每一项为1或者0，表示每一项是否相等 
#http://stackoverflow.com/questions/41708572/tensorflow-questions-regarding-tf-argmax-and-tf-equal
# Initializing the variables
init = tf.initialize_all_variables()
# Launch the graph
with tf.Session() as sess:
	sess.run(init)
	step = 1
	# Keep training until reach max iterations
	while step * batch_size < training_iters:
		batch_xs, batch_ys = mnist.train.next_batch(batch_size)
		# Fit training using batch data
		sess.run(optimizer, feed_dict={x: batch_xs, y: batch_ys, keep_prob: dropout})
		if step % display_step == 0:
			# Calculate batch accuracy
			acc = sess.run(accuracy, feed_dict={x: batch_xs, y: batch_ys, keep_prob: 1.})
			# Calculate batch loss
			loss = sess.run(cost, feed_dict={x: batch_xs, y: batch_ys, keep_prob: 1.})
			print "Iter " + str(step*batch_size) + ", Minibatch Loss= " + "{:.6f}".format(loss) + ", Training Accuracy= " + "{:.5f}".format(acc)
		step += 1
	print "Optimization Finished!"
	# Calculate accuracy for 256 mnist test images
	print "Testing Accuracy:", sess.run(accuracy, feed_dict={x: mnist.test.images[:256], y: mnist.test.labels[:256], keep_prob: 1.})

常用函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
tf.concat(concat_dim, values, name='concat')
tf.concat是连接两个矩阵的操作
除去name参数用以指定该操作的name，与方法有关的一共两个参数：
第一个参数concat_dim：必须是一个数，表明在哪一维上连接
如果concat_dim是0，那么在某一个shape的第一个维度上连，对应到实际，就是叠放到列上
http://blog.csdn.net/mao_xiao_feng/article/details/53366163
tf.expand_dims(tf.constant([1,2,3]),1)  
扩维操作
tf.sparse_to_dense(sparse_indices, output_shape, sparse_values, default_value, name=None)
除去name参数用以指定该操作的name，与方法有关的一共四个参数：
第一个参数sparse_indices：稀疏矩阵中那些个别元素对应的索引值。
	有三种情况：
	sparse_indices是个数，那么它只能指定一维矩阵的某一个元素
	sparse_indices是个向量，那么它可以指定一维矩阵的多个元素
	sparse_indices是个矩阵，那么它可以指定二维矩阵的多个元素
第二个参数output_shape：输出的稀疏矩阵的shape
第三个参数sparse_values：个别元素的值。
	分为两种情况：
	sparse_values是个数：所有索引指定的位置都用这个数
	sparse_values是个向量：输出矩阵的某一行向量里某一行对应的数（所以这里向量的长度应该和输出矩阵的行数对应，不然报错）
第四个参数default_value：未指定元素的默认值，一般如果是稀疏矩阵的话就是0了
http://blog.csdn.net/mao_xiao_feng/article/details/53365889
tf.nn.softmax_cross_entropy_with_logits(logits, labels, name=None)
除去name参数用以指定该操作的name，与方法有关的一共两个参数：
第一个参数logits：就是神经网络最后一层的输出，如果有batch的话，它的大小就是[batchsize，num_classes]，单样本的话，大小就是num_classes
第二个参数labels：实际的标签，大小同上
第一步：对网络最后一层的输出做一个softmax
第二步：softmax的输出向量[Y1，Y2,Y3...]和样本的实际标签做一个交叉熵
tf.reduce_sum操作,就是对向量里面所有元素求和
tf.reduce_mean操作，对向量求均值
http://blog.csdn.net/mao_xiao_feng/article/details/53382790
tf.nn.local_response_normalization(input, depth_radius=None, bias=None, alpha=None, beta=None, name=None) = tf.nn.lrn
http://blog.csdn.net/mao_xiao_feng/article/details/53488271
除去name参数用以指定该操作的name，与方法有关的一共五个参数：
第一个参数input：这个输入就是feature map了，既然是feature map，那么它就具有[batch, height, width, channels]这样的shape
第二个参数depth_radius：这个值需要自己指定，就是上述公式中的n/2
第三个参数bias：上述公式中的k
第四个参数alpha：上述公式中的α
第五个参数beta：上述公式中的β
返回值是新的feature map，它应该具有和原feature map相同的shape

实现一个自创的CNN卷积神经网络

TensorBoard面板可视化管理

https://www.tensorflow.org/versions/r0.8/how_tos/summaries_and_tensorboard/index.html

tensorflow 网络可视化

1
2
summary_writer = tf.train.SummaryWriter('/tmp/tensorflowlogs', graph_def=sess.graph_def)
# 将来训练时候的op 过程记录到日志里面，便于后面显示graph

4D数据虚拟化

1
2
images = np.random.randint(256, size=shape).astype(np.uint8)
tf.image_summary("Visualize_image", images)#用图像方式虚拟化显示image_summary

图标变化方式展示tensorflow数据特征

1
2
3
w_hist = tf.histogram_summary("weights", W)
b_hist = tf.histogram_summary("biases", b)
y_hist = tf.histogram_summary("y", y)

以变量批次事件变化的线路图显示表示tensorflow数据

1
accuracy_summary = tf.scalar_summary("accuracy", accuracy)

汇总

1
2
3
4
merged = tf.merge_all_summaries() #汇总summary
summary_all = sess.run(merged_summary_op, feed_dict={x: batch_xs, y: batch_ys})
summary_writer.add_summary(summary_all,  i) 
#session中执行汇总summary操作op 并使用上面sumarywriter 写入更新到graph 日志中

AlphaGo 的策略网络（CNN）简单的实现

AlphaGo机制说明

训练的模型Model保存文件并使用

1
2
save_path = saver.save(sess, "/root/alexnet.tfmodel") #保存
saver.restore(sess, "/root/alexnet.tfmodel") #使用

DNN深度神经网络的原理以及使用

DNN ,就是去掉卷积层之后 使用全连接层+dropout下降+relu激活 一层一层的WX+B的 网络模式

接着补充一章MLP多层感知器网络原理以及使用

linear----线性感知器
tanh----双曲正切函数
sigmoid----双曲函数
softmax----1/(e(net) * e(wi*xi- shift))
log-softmax---- log(1/(e(net) * e(wi*xi)))
exp----指数函数
softplus----log(1+ e(wi*xi))

RNN循环网络原理以及使用

1
2
3
4
5
6
7
8
9
10
11
12
13
def rnn(cell, inputs, initial_state, dtype=None, squence_length=None,scope=None)
参数：
cell：RNNCell
inputs:A length T list of inputs,each a vector with shape [batch_size]
initial_state:An initial state for RNN shape[batch_size*cell.state_size]
dtype:required if initial_state is not provided
sequence_length:An int64 vector size[batch_size]
scope:VariableScope for the created subgraph;default to "RNN"
returns :
A pair (outputs,state)where:
	output is a length T list of outputs(one for each input)
	states is a length T list of states(one state following each input)
_X = tf.transpose(_X, [1, 0, 2]) # 对于3维的X 默认是 0 1 2 系数 ，我们把它置换成1 0 2 也就是 第一维 第二维进行交换

eg：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
import input_data
mnist = input_data.read_data_sets("/tmp/data/", one_hot=True)
import tensorflow as tf
# from tensorflow.models.rnn import rnn, rnn_cell
from tensorflow.contrib import rnn
import numpy as np
'''
To classify images using a reccurent neural network, we consider every image row as a sequence of pixels.
Because MNIST image shape is 28*28px, we will then handle 28 sequences of 28 steps for every sample.
'''
# Parameters
learning_rate = 0.001
training_iters = 100000
batch_size = 128
display_step = 10
# Network Parameters
n_input = 28 # MNIST data input (img shape: 28*28)
n_steps = 28 # timesteps
n_hidden = 128 # hidden layer num of features
n_classes = 10 # MNIST total classes (0-9 digits)
# tf Graph input
x = tf.placeholder("float", [None, n_steps, n_input])
# Tensorflow LSTM cell requires 2x n_hidden length (state & cell)
istate = tf.placeholder("float", [None, 2*n_hidden])
y = tf.placeholder("float", [None, n_classes])
# Define weights
weights = {
	'hidden': tf.Variable(tf.random_normal([n_input, n_hidden])), # Hidden layer weights
	'out': tf.Variable(tf.random_normal([n_hidden, n_classes]))
}
biases = {
	'hidden': tf.Variable(tf.random_normal([n_hidden])),
	'out': tf.Variable(tf.random_normal([n_classes]))
}
def RNN(_X, _istate, _weights, _biases):
	_X = tf.transpose(_X, [1, 0, 2])  # permute n_steps and batch_size	
	_X = tf.reshape(_X, [-1, n_input]) # (n_steps*batch_size, n_input)
	_X = tf.matmul(_X, _weights['hidden']) + _biases['hidden']
	lstm_cell = rnn_cell.BasicLSTMCell(n_hidden, forget_bias=1.0)
	_X = tf.split(0, n_steps, _X) # n_steps * (batch_size, n_hidden)
	outputs, states = rnn.rnn(lstm_cell, _X, initial_state=_istate)	
	# Get inner loop last output
	return tf.matmul(outputs[-1], _weights['out']) + _biases['out']
pred = RNN(x, istate, weights, biases)
# Define loss and optimizer
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(pred, y)) # Softmax loss
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost) # Adam Optimizer
# Evaluate model
correct_pred = tf.equal(tf.argmax(pred,1), tf.argmax(y,1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
# Initializing the variables
init = tf.initialize_all_variables()
# Launch the graph
with tf.Session() as sess:
	sess.run(init)
	step = 1
	# Keep training until reach max iterations
	while step * batch_size < training_iters:
		batch_xs, batch_ys = mnist.train.next_batch(batch_size)
		# Reshape data to get 28 seq of 28 elements
		batch_xs = batch_xs.reshape((batch_size, n_steps, n_input))
		# Fit training using batch data
		sess.run(optimizer, feed_dict={x: batch_xs, y: batch_ys,
									   istate: np.zeros((batch_size, 2*n_hidden))})
		if step % display_step == 0:
			# Calculate batch accuracy
			acc = sess.run(accuracy, feed_dict={x: batch_xs, y: batch_ys,
												istate: np.zeros((batch_size, 2*n_hidden))})
			# Calculate batch loss
			loss = sess.run(cost, feed_dict={x: batch_xs, y: batch_ys,
											 istate: np.zeros((batch_size, 2*n_hidden))})
			print "Iter " + str(step*batch_size) + ", Minibatch Loss= " + "{:.6f}".format(loss) + \
				  ", Training Accuracy= " + "{:.5f}".format(acc)
		step += 1
	print "Optimization Finished!"
	# Calculate accuracy for 256 mnist test images
	test_len = 256
	test_data = mnist.test.images[:test_len].reshape((-1, n_steps, n_input))
	test_label = mnist.test.labels[:test_len]
	print "Testing Accuracy:", sess.run(accuracy, feed_dict={x: test_data, y: test_label,
															 istate: np.zeros((test_len, 2*n_hidden))})

使用TensorFlow实现RNN

RNN实现
tensorflow.Python.ops.rnn_cell

类型判断：
isinstance
rnn_cell中的函数：
def _linear(args, output_size, bias, bias_start=0.0, scope=None):
args: list of tensor [batch_size, size]. 注意,list中的每个tensor的size 并不需要一定相同,但batch_size要保证一样.
output_size : 一个整数
bias: bool型, True表示 加bias,False表示不加
return : [batch_size, output_size]
注意: 这个函数的atgs 不能是 _ref 类型(tf_getvariable(), tf.Variables()返回的都是 _ref),
但这个 _ref类型经过任何op之后,_ref就会消失
class BasicLSTMCell(RNNCell):
def init(self, num_units, forget_bias=1.0, input_size=None,
state_is_tuple=True, activation=tanh):
“””
为什么被称为 Basic
It does not allow cell clipping, a projection layer, and does not
use peep-hole connections: it is the basic baseline.
“””
num_units: lstm单元的output_size
input_size: 这个参数没必要输入, 官方说马上也要禁用了
state_is_tuple: True的话, (c_state,h_state)作为tuple返回
activation: 激活函数
注意: 在我们创建 cell=BasicLSTMCell(…) 的时候, 只是初始化了cell的一些基本参数值. 这时,是没有variable被创建的, variable在我们 cell(input, state)时才会被创建, 下面所有的类都是这样

class GRUCell(RNNCell):
    def __init__(self, num_units, input_size=None, activation=tanh):

创建一个GRUCell

class OutputProjectionWrapper(RNNCell):
    def __init__(self, cell, output_size):

output_size: 要映射的 size
return: 返回一个 带有 OutputProjection Layer的 cell(s)

class InputProjectionWrapper(RNNCell):
  def __init__(self, cell, num_proj, input_size=None):

和上面差不多,一个输出映射,一个输入映射

class DropoutWrapper(RNNCell):
  def __init__(self, cell, input_keep_prob=1.0, output_keep_prob=1.0,
               seed=None):

dropout

class EmbeddingWrapper(RNNCell):
  def __init__(self, cell, embedding_classes, embedding_size, initializer=None):

返回一个带有 embedding 的cell

class MultiRNNCell(RNNCell):
  def __init__(self, cells, state_is_tuple=True):

用来增加 rnn 的层数
cells : list of cell
返回一个多层的cell

tensorflow1.0中的RNN

tensorflow reverse_sequence实例

class tf.contrib.rnn.BasicLSTMCell

tensorflow常用函数
转置函数 transpose

最强网络RSNN深度残差网络 平均准确率96-99%

论文：图像识别的深度残差学习 Deep Residual Learning for Image Recognition
待完善

最强网络DLSTM 双向长短期记忆网络（阿里小AI实现）

并没有给出阿里小AI的完整实现

1
2
3
4
5
6
7
8
 outputs = rnn.bidirectional_rnn(lstm_fw_cell, lstm_bw_cell, _X,
 									initial_state_fw=_istate_fw,
                                        initial_state_bw=_istate_bw,
                                        sequence_length=_seq_len)
# Linear activation
# Get inner loop last output
return tf.matmul(outputs[-1], _weights['out']) + _biases['out']

Tensorflow Caffe相互转换

开源项目： https://github.com/ethereon/caffe-tensorflow 
./convert.py /root/googleNet.prototxt --code-output-path=googleNetTensorflow.py

Tensorflow RCNN区域卷积神经网络

模型AutoEncoder自编码机网络

AutoEncoder 用于 有监督里面 可以用来 数据压缩 数据降维 过滤 降噪 
AutoEncoder用于 无监督算法 里面可以用来进行 数据的转换 数据的自学习

Tensorflow人工智能分布式实现

  1. 采用spark 的RDD 结合 map 在 map里面执行每一层 每一层 FF BP 采用 broardCast传播全局变量 也就是计算的梯度 来接着 map里面进行 更新梯度操作
  2. spark 的mllib包
  3. PipeLine管道 ，mlib机器学习的 ml管道方式
  4. 分布式数据库 分布式调度

Tensorflow实战

《TensorFlow实战》这本书的主要内容：

  1. 使用数据流式图规划计算流程
  2. 多个设备时：
    每一个节点该让什么硬件设备执行–设计了一套策略，首先需要计算代价模型。
    如何管理节点间的数据通信–子图之间的发送节点和接受节点 TCP或者RDMA
  3. tf.device(“/gpu:%d”%d) 从一块GPU到多块的代码
  4. 支持自动求导[db,dW,dx]=tf.gradients(C,[b,W,x])
  5. 反向传播时可能需要初始Tensor,会占用内存。持续改进中
  6. 用户可以选择计算图的任意子图，节点名+port的形式
  7. 计算图的控制流：if-condition while-loop
  8. 接收节点在刚好需要数据的时候才开始接收数据
  9. receive,enqueue,dequeue异步的实现
  10. 加速：数据并行，模型并行，流水线并行
  11. Python等接口是通过SWIG实现的
  12. 兼容Scikit-learn estimator接口
  13. 计算图必须构建为静态图，beam search变得困难
  14. 不同设备间通信使用基于socket的RPC
  15. Tensorflow Serving
  16. tf.variables中的参数是持久化的
  17. tf.cast(correct_prediction,tf.float32)# 类型转换
  18. accuracy.eval(feedict)
  19. xavier initialization 初始化参数
  20. tf.truncated_normal([in_units,h1_units]) #截断的正态分布
  21. tf.nn.lrn对局部神经元的活动创建竞争环境，使得其中响应比较大的值变得相对更大
  22. tf.train.start_queue_runners()#启动线程进行加速
  23. tf.random_uniform((fan_in,fan_out),minval=low,maxval=high,dtype=tf.float32)#均匀分布
  24. tf.truncated_normal([in_units,h1_units],stddev=0.1)#截断的正态分布，标准差为0.1
  25. tf.nn.in_top_k(logits,label_holder,1)#输出结果中topk的准确率
  26. withtf.namescope(‘conv1’) as scope可以将scope内生成的Variable自动命名为conv1/name
  27. tf.nn.nce_loss()Noise-contrastive Estimation
  28. ,a 中只是一个占位的作用
  29. ​
-------------本文结束 感谢您的阅读-------------
作者：GonewithGt
有问题请 留言 或者私信我的 微博。
满分是10分的话，这篇文章你给几分