手写：逻辑回归拟合二维数据（tensorflow）

tensorflow开发的基本步骤

1、定义tensorflow输入节点【3种方法】

2、定义学习参数的变量【2种方法】

3、定义运算

4、选择优化函数，优化目标

5、初始化所有变量

6、迭代更新参数到最优解

7、测试模型

8、使用模型

下面就挑前几个比较重要的说一下

1、定义tensorflow输入节点【3种】

1.1使用占位符定义：比较常用，使用 tf.placeholder 函数

占位符的意思就是先定义，之后再解释，就相当于先定义了变量但是没有初始化，定义方法如下：

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

1.2使用字典类型定义：用于输入比较多的情况下

将占位符与字典类型相结合，实现方法如下：

inputdict = {
                 'x':tf.placeholder("float"),
                 'y':tf.placeholder("float")
             }

1.3直接定义：一般很少用

就是将输入的数据直接当做模型的输入变量

2、定义学习参数的变量【2种】

2.1直接定义：使用tf.Variable函数可以对参数直接定义

W = tf.Variable(tf.random_normal([1]),name = "weight")  
b = tf.Variable(tf.zeros([1]),name = "bias")

2.2字典定义：在深层神经网络中，经常使用字典定义

就是将直接定义的方法加到字典类型中，实现方法如下：

paradict = {
                 'w':tf.Variable(tf.random_normal([1]),name = "weight"),
                 'b':tf.Variable(tf.zeros([1]),name = "bias")
             }
#在前向计算的时候，使用方法
z = tf.multiply(X,paradict["w"]) + paradict["b"]

5、初始化所有变量

必须是要在所有的变量还有节点(OP)定义完成之后再进行全局的变量初始化，不然，在初始化所有变量之后定义的变量和OP都不能使用session中的run函数进行数组计算了。

实例描述：

假设有一组数据集，其x和y的对应关系为y≈2x

需要让神经网络学习这些样本，并找到其中的规律。

实现深度学习的步骤

#1、准备数据
#2、搭建模型
#3、迭代训练
#4、使用模型

下面的代码中实现了，训练模型的保存及重载、以及保存检查点


#深度学习
#1、准备数据
#2、搭建模型
#3、迭代训练
#4、使用模型

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

#定义生成loss可视化的函数
plotdata = {"batchrize":[],"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)]




#1、准备数据
train_X = np.linspace(-1,1,100) 
train_Y = 2 * train_X + np.random.rand(*train_X.shape)*0.3


#重置图
tf.reset_default_graph()


#2、搭建模型
    # X  Y是占位符,也就是说先定义了，之后再解释，用placeholder函数进行定义
X = tf.placeholder("float")   #代表输入x的值
Y = tf.placeholder("float")   #代表对应的真实值 y
    #模型参数--变量
W = tf.Variable(tf.random_normal([1]),name = "weight")    #tf.Variable 表示定义变量
b = tf.Variable(tf.zeros([1]),name = "bias")
    #前向结构
    #tf.multiply表示相乘的意思，也就是单个神经元的前向计算 权重x输入+偏移
    #z就是前向的计算输出
z = tf.multiply(X,W) + b    

    #反向优化
    #2.1、定义一个损失函数，此处使用的 生成值 与 真实值 之间的 平方差
cost = tf.reduce_mean(tf.square(Y-z))
    #2.2、定义一个学习速率，代表调整参数的速度
learning_rate = 0.01
    #2.3、使用梯度下降法进行 loss 函数的优化；  GradientDescentOptimizer就是一个已经封装好的 梯度下降的算法
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)




#3、迭代训练
#3.1  训练模型
    #初始化所有变量，必须在所有的变量和节点(OP)定义完成之后，再进行初始化
    #否则，在初始化之后定义的变量和OP都无法使用session中的run来计算值
init = tf.global_variables_initializer()
    #定义参数：迭代次数以及显示步长
training_epochs = 30
display_step = 2

#生成saver
saver = tf.train.Saver()
savedir = "D:\work_work\spyder_working_space/"

    #建立并启动session，  with语法可以在session结束后自行关闭，也是常用的session启动方法
with tf.Session() as sess:
    sess.run(init)

    
    #向模型输入数据，在单搭建模型的时候  使用X Y 两个占位符来表示的 模型中的 输入  以及   输出真实值
    #因此需要将第一步中的数据  与  模型中的占位符链接起来
    #使用feed机制将真实数据灌到占位符对应的位置
    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["batchrize"].append(epoch)
                plotdata["loss"].append(loss)
            
            #保存训练好的 模型变量，此操作只保存 定义的变量
            #也就是  tf.Variable  定义了的变量
            saver.save(sess,savedir+"linermodel.cpkt",global_step=epoch)
    
    print("Fineshed!")
    
    print("cost=",sess.run(cost,feed_dict={X:train_X,Y:train_Y}),"W=",sess.run(W),"b=",sess.run(b))
    #在显示cost的时候可以使用下面的这种表示方法
    #print("cost:",cost.eval({X:train_X,Y:train_Y}))

#3.2 模型可视化
    #为了更加直观的表达，将生成的模型以及训练的状态值显示出来
    #图形显示
    plt.plot(train_X,train_Y,'ro',label='Original data')
    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["batchrize"],plotdata["avgloss"],'b--')
    plt.xlabel("Minibatch number")
    plt.ylabel("Loss")
    plt.title("Minibatch run vs. Training loss")
    
    plt.show()
        
    
#4、使用模型,启动的时候  也需要启动session
    print("x=0.2，z=",sess.run(z,feed_dict={X:0.2}))


    
#重启一个session，载入检查点
load_epoch = 18
with tf.Session() as sess2:
    sess2.run(tf.global_variables_initializer())
    #载入之后就会覆盖掉所有的参数
    #因此，如果要载入模型的时候，不需要进行初始化了，因为就算是初始化也会被重载的覆盖掉
    saver.restore(sess2,savedir+"linermodel.cpkt-",str(load_epoch))
    print("x=0.2,z=",sess2.run(z,feed_dict={X:0.2}))

输出结果如下：

Epoch: 1 cost= 0.055053063 W= [1.6758726] b= [0.24198401]
Epoch: 3 cost= 0.011287085 W= [1.9341978] b= [0.1905865]
Epoch: 5 cost= 0.0077018575 W= [2.0061853] b= [0.16376488]
Epoch: 7 cost= 0.007581351 W= [2.0248852] b= [0.15660226]
Epoch: 9 cost= 0.0076055895 W= [2.0297222] b= [0.1547464]
Epoch: 11 cost= 0.007615575 W= [2.0309737] b= [0.15426627]
Epoch: 13 cost= 0.0076183914 W= [2.0312958] b= [0.15414251]
Epoch: 15 cost= 0.0076191537 W= [2.031381] b= [0.15410994]
Epoch: 17 cost= 0.007619343 W= [2.031402] b= [0.15410173]
Epoch: 19 cost= 0.0076193972 W= [2.031408] b= [0.15409955]
Epoch: 21 cost= 0.0076194014 W= [2.0314085] b= [0.15409915]
Epoch: 23 cost= 0.0076194014 W= [2.0314085] b= [0.15409914]
Epoch: 25 cost= 0.0076194014 W= [2.0314085] b= [0.15409914]
Epoch: 27 cost= 0.0076194014 W= [2.0314085] b= [0.15409914]
Epoch: 29 cost= 0.0076194014 W= [2.0314085] b= [0.15409914]
Fineshed!
cost= 0.0076194014 W= [2.0314085] b= [0.15409914]

x=0.2，z= [0.5603808]
INFO:tensorflow:Restoring parameters from D:\work_work\spyder_working_space/linermodel.cpkt
x=0.2,z= [0.5603808]