tensorflow入门-01-逻辑回归拟合实例与模型初步理解

1.理解初步

一个标准的模型汇总有三个部分：输入、中间节点、输出

TensorFlow让一个标准的模型中的各部分联通起来学习规则并可以进行计算。

中间节点及节点间的运算关系OPS定义在图上，全通过一个会话session进行图中OPS的具体计算。

——图是静态的搭建，启动会话后数据流向图中

——数据流图技术进行数值计算

——有向图中，节点通常代表数学运算，边表示节点之间的某种联系，它负责传输多维数据(Tensors)。

——节点可以被分配到多个计算设备上，可以异步和并行地执行操作

——等到之前的入度节点们的计算状态完成后，当前节点才能执行操作。 

 

a.构建一个完整的图：三种变量

输入节点：网络入口

用于训练的模型参数（学习参数）：连接各个节点的路径

模型中的节点（operation, OP）：可以使中间节点也可以是最终的输出节点（一个OP获得0个活多个张量，执行计算，输出额外的0个或多个张量）

b.定义输入节点方法

①通过占位符定义：常用，使用tf.placeholder()函数

X = tf.placeholder("float")
Y = tf.placeholder("float")

②通过字典类型定义：一般用于输入比较多的情况（暂不列举）

③直接定义：一般很少使用

c.定义学习参数变量

①可以使用直接定义的方式，通过tf.Variable

W = tf.Variable(tf.random_normal([1]), name="weight")
b = tf.Variable(tf.zeros([1]), name="bias")
#在使用的时候直接使用W和b
z = tf.multiply(X, W)+ b

②由于学习参数在深层神经网络中过多，一般常使用字典定义

paradict = {
    'w': tf.Variable(tf.random_normal([1])),
    'b': tf.Variable(tf.zeros([1]))
}

#因此在使用的时候不再直接使用W和b
z = tf.multiply(X, paradict['w'])+ paradict['b']

d.定义运算（正向传播模型与损失函数）

前者经常出新，神经元以不同的组合方式组成网络结构

后者近几年相对固定，主要是计算“输出值”和“目标值”之间的误差，配合反向传播使用，使找到最小值（函数必须可导）

↓

完成正向结构和损失函数，就可以进行优化了

将误差沿着相反方向传递过去（如L1L2正则化、冲量调节、学习率自适应、adm随机梯度下降法等）

出新速度不如网络结构变化得快

 

2.逻辑回归实例

（1）额外补充有助理解

a.初始化所有变量与启动session

将session创建好了之后，第一件事就是初始化

注意：tf.global_variables_initializer()需要在所有的OP定义完成之后

用with语法启动session，可以在其结束后自行关闭（还有其他方法）

# 初始化变量
init = tf.global_variables_initializer()

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

b.梯度下降法与优化操作OP（待理解与加深）

梯度下降法将用另一博客来学习，并明确损失函数的意义，网址待定

在本次实例中采用的是梯度下降法

#反向优化
cost =tf.reduce_mean(tf.square(Y - z))
learning_rate = 0.01
#梯度下降
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)


 for epoch in range(training_epochs):
        for (x, y) in zip(train_X, train_Y):
            sess.run(optimizer, feed_dict={X: x, Y: y})

c.模型先是训练、随后完成测试，最后是真正地去使用模型

训练场景中，对样本进行学习，正向+反向，调整的是学习参数

测试场景中，用图的正向计算结果与真实值进行比较

使用场景中，利用图的正向计算结果，并直接使用

d.两种数据流向机制

注入机制（feed）：通过占位符向模式中传入数据（feed_dict）

取回机制（fetch）：从模式中得到结果

 

（2）实例

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

train_X = np.linspace(-1,1,100)
train_Y = 2 * train_X + np.random.randn(*train_X.shape)*0.3

plt.plot(train_X,train_Y,'ro',label='Original data')
plt.legend()
plt.show()

#存放批次值和损失值
plotdata = { "batchsize":[], "loss":[] }
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)]

# 创建模型
# 占位符
X = tf.placeholder("float")
Y = tf.placeholder("float")
# 模型参数
W = tf.Variable(tf.random_normal([1]), name="weight")
b = tf.Variable(tf.zeros([1]), name="bias")
# 前向结构
z = tf.multiply(X, W)+ b

#反向优化
cost =tf.reduce_mean(tf.square(Y - z))
learning_rate = 0.01
#梯度下降
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)

# 初始化变量
init = tf.global_variables_initializer()
# 训练参数
training_epochs = 20
display_step = 2

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

    # Fit all training data
    for epoch in range(training_epochs):
        for (x, y) in zip(train_X, train_Y):
            sess.run(optimizer, feed_dict={X: x, Y: y})

        #显示训练中的详细信息
        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))
    #print ("cost:",cost.eval({X: train_X, Y: train_Y}))