深度学习笔记（一）逻辑回归拟合二维数据学习Tensorflow开发

Tensorflow用法简介  

一个标准的模型结构分为输入、中间节点、输出三大部分，如何让这三个部分连通起来学习规则并进行计算，这便是Tensorflow框架所做的事。Tensorflow将中间节点及节点之间的运算关系（OPS）定义在自己内部的一个“图”内，具体的运算全部通过一个“会话（session）”进行。在会话中，任何一个节点都可以通过会话的run函数进行计算，得到该节点的数据值。
    “图”是静态的，它只是将关系搭建在一块，不会进行任何运算；而会话session是动态的，只有启动会话才会将数据流向“图”，并按照图中的关系运算并将结果从图中流出。
      模型内部的数据流向分为正向和反向（其实也就是BP神经网络）：
      正向即从数据输入开始，依次进行各节点定义的运算，一直运算到输出。
      反向，只有在训练场景才会用到。先从最后一个输出节点开始，计算预期结果和真实输出的误差，这样会形成一个用学习参数表示误差的方程，然后对方程中的每个参数求导，得到其梯度修正值，同时反推出上一层的修正值，这样一直往前推，就传到正向的第一个节点了。

运行代码

    以下是模拟y=2x的训练及测试过程：import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

def moving_average(a, w=10):
if len(a) < w:
return a[:]
return [val if idx < w else sum(a[(idx-w): idx])/w for idx , val in enumerate(a)]

# 数据准备
train_X = np.linspace(-1,1,100)
train_Y = 1*train_X + np.random.randn(*train_X.shape)*0.3 # 加入噪声的y=2x
# 显示模拟数据点
plt.plot(train_X, train_Y, 'ro', label='Original data')
plt.legend()
# plt.show()

# 正向搭建模型
# 创建模型
X = tf.placeholder("float") # 占位符,x表示输入
Y = tf.placeholder("float") # 占位符，y表示期望输出
W = tf.Variable(tf.random_normal([1]), name="weight") # 模型参数，W被初始化成[-1,1]的随机数，Variable定义变量.
b = tf.Variable(tf.zeros([1]), name="bias") # b被初始化为0，形状也是一维的数字
z = tf.multiply(X, W)+b # multiply两个数相乘

# 方向搭建模型
# 反向优化
cost = tf.reduce_mean(tf.square(Y - z)) # 期望输出与真实输出的平方差
learning_rate = 0.01 # 学习速率，即调节参数的速率，一般小于1，值越小，表明调整的精度越高，但速度越慢。
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost) # 梯度下降，会根据学习速率调整误差

# 迭代训练模型
# Tensorflow中的任务是通过session来进行的
# 初始化所有变量
init = tf.global_variables_initializer()
# 定义参数
training_epochs = 20 # 迭代次数20次
display_step = 2
# 启动session
# Tensorflow将中间节点及节点间的运算关系（OPS）定义在自己的一个“图”上，全部通过一个“（会话）session”进行图中OPS的具体运算
with tf.Session() as sess:
sess.run(init) # 通过sess.run()来进行网络节点的运算
plotdata = {"batchsize": [], "loss": []} # 存放批次值和损失值
# 向模型输入数据
for epoch in range(training_epochs):
for (x, y) in zip(train_X, train_Y):
sess.run(optimizer, feed_dict={X: x, Y: y}) # 通过feed机制将真实数据灌到占位符对应的位置，同时每执行一次
# 都会将网络结构中的节点打印出来

# 显示训练中的详细信息
if epoch % display_step == 0:
loss = sess.run(cost, feed_dict={X: train_X, Y: train_Y})
print("Epoch:", epoch+1, "cost=", loss, "W=", sess.run(W), "b=", sess.run(b))
if not (loss == "NA"):
plotdata["batchsize"].append(epoch)
plotdata["loss"].append(loss)

print("Finished!")
print("cost=", sess.run(cost, feed_dict={X: train_X, Y: train_Y}), "W=", sess.run(W), "b=", sess.run(b))

# 训练模型可视化
plt.plot(train_X, sess.run(W) * train_X + sess.run(b), label='Fittedline')
plt.legend()
plt.show()

plotdata["avgloss"] = moving_average(plotdata["loss"])
plt.figure(1)
plt.subplot(211)
plt.plot(plotdata["batchsize"], plotdata["avgloss"], 'b--')
plt.xlabel('Minibatch number')
plt.ylabel('Loss')
plt.title('Minibatch run vs.Training loss')

plt.show()

# 使用模型
print("x=0.3, z=", sess.run(z, feed_dict={X: 2}))

运行结果

定义输入节点的方式

（1）通过占位符定义，具体见上边代码。
（2）通过字典类型定义，一般用于输入比较多的情况。# 占位符
inputdict = {
'x' = tf.placeholder("float"),
'y' = tf.placeholder("float")
}（3）直接定义，很少使用。

定义“学习参数“”的变量

（1）直接定义，具体见上边代码。
（2）通过字典定义，在深度神经网络输入比较多时使用。# 模型参数
paradict = {
'w': tf.Variable(tf.random_normal([1])),
'b' = tf.Variable(tf.zeros([1]))

}
# 前向结构
z = tf.multiply(X, paradict['w'])+paradict['b']

初始化所有变量

init = tf.global_variables_initializer()
# 启动Session
with tf.Session() as sess:
sess.run(init)

    注意使用tf.global_variables_initializer()初始化所有变量的步骤，必须在所有变量和OP定义完成后使用，这样才能保证定义的内容有效。
    with语法可以在session结束后自行关闭。

参考文献：深度学习之Tensorflow——李金洪