本篇文章主要用来记录tensorflow搭建深度学习模型过程中的使用方法，仅仅是常用的内容，不涉及深入的内容，不断扩充。

此文参考https://blog.csdn.net/u013733326/article/details/79971488

补充：张量

查资料时看到张量这个词，一直不知道是什么什么东西。查阅资料后知道张量是Tensorflow中最基本的数据结构，比如常量是0阶张量（单个元素），向量是一阶张量（一维数组），矩阵是二阶张量（二维数组），数据立体是三阶张量（三维数组）

a = 1
# 0阶
b = [1,2,3]
# 1阶
c = [[1,2],[3,4]] # 2阶
d = [[[1,2,3]]]
# 3阶

在没有进行会话时输出， 会输出以下东西，在不知道张量时就很烦！

a = tf.constant([1.0,2.0], name="a")
b = tf.constant([2.0,3.0], name="b")
result = tf.add(a,b,name="add")
print(result)
#Tensor("add:0", shape=(2,), dtype=float32)
"""
Tensor应该代表的是输出的result是张量
张量的命名形式：node:src_output
其中node为节点的名称，src_output表示当前张量来自节点的第几个输出。比如上面打印出来的“add:0"
就说明result这个张量是计算节点”add“输出的第一个结果(试了几次不太明白，mark了)
shape属性描述了一个张量的维度信息，比如上面样例中shape=(2,)说明张量result是一个长度为2的一维数组。
dtype就是张量的数据类型了，如果参与计算的类型不同的话会报错
"""

1、tensorflow创建常量

tf.constant(value, dtype=None, shape=None, name='Const', verify_shape=False)
#第一个值是必须的，可以是数值也是是列表，现在列出几种不同的输出方式，我猜第一种和第三种的区别在于自动关闭会话
y1 = tf.constant(20)
sess = tf.Session()
result = sess.run(y1)
print(result)
sess.close()
#20
y2 = tf.constant(20)
print(y2.eval())
#20
y3 = tf.constant(20)
with tf.Session() as session:
print(session.run(y3))
#20
#下面是数值是列表的情况
y = tf.constant([10,20])
with tf.Session() as session:
print(session.run(y))
#[10, 20]
#第二个参数是数值类型，如果填充tf.float32，那么其中的数值会自动转变成浮点类型
y = tf.constant([10,20], tf.float16)
with tf.Session() as session:
print(session.run(y))
#[ 10.
20.]
#第三个参数是形状，会用之前的value来填充，填充的方式多样，下面举个2行1列的栗子
y = tf.constant([10,20], tf.float16, shape=[2,1])
with tf.Session() as session:
print(session.run(y))
#[[ 10.]
# [ 20.]]
#第四个参数是名称，不知道干啥用的
#第五个参数是用来检查value的形状是否和shape相同，不同的话会报错

2、tensorflow创建变量

"""
tf.Variable(表达式, 名称)
在使用的时候需要将变量初始化sess.run(tf.global_variables_initializer())
"""
y1= tf.constant(2)
y2 = tf.constant(4)
loss = tf.Variable((y2-y1)**2,"loss")
sess = tf.Session()
sess.run(tf.global_variables_initializer())
print(sess.run(loss))
sess.close()
#4
#tf.get_variable()如果已有该对象就返回该对象，如果没有的话那就创建一个新的对象

3、tensorflow占位符

"""
tf.placeholder(dtype, shape = None, name=None)
"""
#在使用的时候尝试在一个变量中添加占位符结果报错了，以后慎用
x = tf.placeholder(tf.int64,name="x")
y = tf.placeholder(tf.int64,name = "y")
z = tf.placeholder(tf.int64)
result = z**2+y**2+x**2
sess = tf.Session()
print(sess.run(result,feed_dict={z:3,y:2,x:1}))
#14

4、对于输入数据与权重矩阵的关系的理解

当输入的数据的节点数量为m，数据个数为n，即数据的维度为m*n，那么下一层的权重矩阵的维度需要为a*m。在数据集和权重矩阵相乘时 tf.matmul(W, X) +b，权重矩阵在前面，数据矩阵在后面，得到的结果的维度为a*n，这个怎么理解呢？将每一组数据的m个特征利用m个权重组合，得到一个新的特征，m个特征变成一个特征肯定不行啊，那就用a组权重，得到a个特征，而数据的条数肯定是n不会变的，所以维度为a*n。联想到CNN的卷积层的每个kernal中的矩阵要和前面的通道数相同，后面输出的特征数是由下一层的kernal数控制的。

5、独热矩阵one_hot_matrix

#depth是标签深度
depth = tf.constant(3)
labels = tf.constant([0,1,2])
res = tf.one_hot(labels, depth)
sess = tf.Session()
print(sess.run(res))
sess.close()
"""
[[ 1.
0.
0.]
[ 0.
1.
0.]
[ 0.
0.
1.]]
"""

6、tensorflow中的随机数与权重矩阵的初始化

#设定种子
tf.set_random_seed(1)
#创建权重矩阵参数时随机初始化
W1 = tf.get_variable("W1",[25,12288],initializer=tf.contrib.layers.xavier_initializer(seed=1))
b1 = tf.get_variable("b1",[25,1],initializer=tf.zeros_initializer())

7、tensorflow中的转置和行列的调整（没有细看）

a = np.random.randn(3,2)
print(a)
b = tf.transpose(a)
with tf.Session() as sess:
print(sess.run(b))
"""
[[ 0.2344157
1.65980218]
[ 0.74204416 -0.19183555]
[-0.88762896 -0.74715829]]
[[ 0.2344157
0.74204416 -0.88762896]
[ 1.65980218 -0.19183555 -0.74715829]]
"""

8、搭建第一个深度模型

实现一个三层的TensorFlow神经网络：LINEAR->RELU->LINEAR->RELU->LINEAR->SOFTMAX
有了一点基础，那就来搭建第一个深度网络，接下来记录搭建过程中的一些流程。

1、将处理好的数据集和测试集输入到模型当中。

2、获取输入的节点数量和样本数量(n_x, m)，获取输出的节点数量(n_y, m)，每次迭代的代价都记录在cost数组当中

3、创建占位符X、Y，X的shape为(n_x, ?)，根据minibatch的数量来更改后面的？的大小。

4、初始化权重和偏差参数

5、向前传播、计算成本、反向传播

6、至此所有的准备都结束，初始化所有的变量，进入遍历次数的循环

7、因为需要minibatch，要打乱数据的顺序，然后每次取出minibatches_size数量的数据

8、因为有tensorflow的框架，所以我们只要在会话中计算每次循环的反向传播和代价值，然后将每次bacth的cost加起来 然后对batch的次数求平均

9、保存参数、计算当前的预测结果。计算当前准确度时，首先计算向前传播的Z3的最大值的位置，将其和对应的Y值的最大值的位置相比，位置相同就说明准确，否则不准确。然后取均值，取得均值就是准确率

这边还有个坑，我真的不知道这里面的参数是怎么存储的，预测的时候参数是怎么参与计算的

def model(X_train, Y_train,X_test,Y_test,
learning_rate = 0.0001, num_epochs = 1500, minibatch_size = 32,
print_cost = True, is_plot = True):
"""
实现一个三层的TensorFlow神经网络：LINEAR->RELU->LINEAR->RELU->LINEAR->SOFTMAX
参数：
X_train - 训练集，维度为（输入大小（输入节点数量） = 12288, 样本数量 = 1080）
Y_train - 训练集分类数量，维度为（输出大小(输出节点数量) = 6, 样本数量 = 1080）
X_test - 测试集，维度为（输入大小（输入节点数量） = 12288, 样本数量 = 120）
Y_test - 测试集分类数量，维度为（输出大小(输出节点数量) = 6, 样本数量 = 120）
learning_rate - 学习速率
num_epochs - 整个训练集的遍历次数
mini_batch_size - 每个小批量数据集的大小
print_cost - 是否打印成本，每100代打印一次
is_plot - 是否绘制曲线图
返回：
parameters - 学习后的参数
"""
ops.reset_default_graph()
#能够重新运行模型而不覆盖tf变量
tf.set_random_seed(1)
seed = 3
(n_x, m) = X_train.shape
#输入节点数量和样本数
n_y = Y_train.shape[0]
#获取输出节点数量
costs = []
#成本集
#创建占位符
X,Y = create_placeholders(n_x, n_y)
#初始化参数
parameters = initialize_parameters()
#向前传播
#因为在TensorFlow中最后的线性输出层的输出作为计算损失函数的输入，所以不需要A3.
Z3 = forward_propagation(X, parameters)
#计算成本
cost = compute_cost(Z3, Y)
#反向传播，使用adam优化
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)
#初始化所有变量
init = tf.global_variables_initializer()
#开始会话并计算
with tf.Session() as sess:
#初始化
sess.run(init)
#正常训练的循环
for epoch in range(num_epochs):
epoch_cost = 0
#每代的成本
num_minibatches = int(m / minibatch_size)
#minibatch的总数量
seed = seed + 1
minibatches = tf_utils.random_mini_batches(X_train,Y_train,minibatch_size,seed)
for minibatch in minibatches:
#选择一个minibatch
(minibatch_X,minibatch_Y) = minibatch
#数据已经准备好了，开始运行session
_ , minibatch_cost = sess.run([optimizer,cost],feed_dict={X:minibatch_X,Y:minibatch_Y})
#计算这个minibatch在这一代中所占的误差
epoch_cost = epoch_cost + minibatch_cost / num_minibatches
#记录并打印成本
## 记录成本
if epoch % 5 == 0:
costs.append(epoch_cost)
#是否打印：
if print_cost and epoch % 100 == 0:
print("epoch = " + str(epoch) + "
epoch_cost = " + str(epoch_cost))
#是否绘制图谱
if is_plot:
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('iterations (per tens)')
plt.title("Learning rate =" + str(learning_rate))
plt.show()
#保存学习后的参数
parameters = sess.run(parameters)
print("参数已经保存到session。")
#计算当前的预测结果
correct_prediction = tf.equal(tf.argmax(Z3),tf.argmax(Y))
#计算准确率
accuracy = tf.reduce_mean(tf.cast(correct_prediction,"float"))
print("训练集的准确率：", accuracy.eval({X: X_train, Y: Y_train}))
print("测试集的准确率:", accuracy.eval({X: X_test, Y: Y_test}))
return parameters

最后

以上就是大胆煎蛋为你收集整理的Tensorflow的浅层学习以及我的第一个深度学习模型补充：张量1、tensorflow创建常量2、tensorflow创建变量3、tensorflow占位符4、对于输入数据与权重矩阵的关系的理解5、独热矩阵one_hot_matrix6、tensorflow中的随机数与权重矩阵的初始化7、tensorflow中的转置和行列的调整（没有细看）8、搭建第一个深度模型的全部内容，希望文章能够帮你解决Tensorflow的浅层学习以及我的第一个深度学习模型补充：张量1、tensorflow创建常量2、tensorflow创建变量3、tensorflow占位符4、对于输入数据与权重矩阵的关系的理解5、独热矩阵one_hot_matrix6、tensorflow中的随机数与权重矩阵的初始化7、tensorflow中的转置和行列的调整（没有细看）8、搭建第一个深度模型所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。