TensorFlow以逻辑回归拟合二维数据

深度学习大概有如下4个步骤：

（1）准备数据

（2）搭建模型

（3）迭代训练

（4）使用模型

准备数据阶段一般就是把与任务相关的数据收集起来，然后通过建立网络模型，经过一定的迭代训练让网络学习收集来的数据特征，形成一个可以用的模型，之后就是通过使用模型来解决现实中的问题。

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

本例子就是让神经网络通过学习这些样本，并找到其中的规律，让神经网络能够总结出y≈2x这样的公式。

具体代码实现过程如下：

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

#定义生成loss可视化的函数
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)]

#重置图
tf.reset_default_graph()

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

#创建模型
#占位符
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 = 1

saver = tf.train.Saver()#生成saver
savedir = "D:/2.0/progect/log/"



#启动session
with tf.Session() as sess:
    sess.run(init)
    
    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})

        #显示训练中的详细信息
        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! ")
    saver.save(sess, savedir+"linermode.ckpt")#保存模型
    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, 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["batchsize"],plotdata["avgloss"],'b--')
    plt.xlabel('Minibatch number')
    plt.ylabel('loss')
    plt.title('Minibatch run vs. Training loss')

    plt.show()

    print("x=0.2, z=",sess.run(z, feed_dict={X: 0.2}))

结果输出：

 

上面的模型仅仅迭代了20次就得到了一个可以模拟y≈2x的模型，在遇到稍微复杂一点的模型时，需要迭代的次数会更多。一般会把生成的模型保存起来，再通过载入已有的模型来进行实际的使用。该实验中模型以及被保存，读者可以通过保存下来的模型进行后续的实验，比如模型载入和读取等。