前言

TensorFlow 当我第一次打开TensorFlow教程，第一个实例就是使用随机生成的数据拟合y=2x函数。虽然整个代码完整敲一遍还不太明白。但是得到了想要的结果还是很激动。
下面来仔细分析代码

拟合二维数据y=2x.py

导入包

import tensorflow as tf 
import numpy as np # 数学计算
import matplotlib.pyplot as plt # 画图用到的

录入数据

这里使用生成的100个随机数，而且添加了一点随机变化。

#生成模拟数据
train_X = np.linspace(-1, 1, 100) # linspace 均分函数 表示 在-1,1之前平均取100个点
train_Y = 2 * train_X + np.random.randn(*train_X.shape) * 0.3 # y=2x，但是加入了噪声

为了更直观 可以画出这100个点来

#显示模拟数据点
plt.plot(train_X, train_Y, 'ro', label='Original data') # 绘图 标签
plt.legend()
plt.show()

结果如图:

image.png

创建模型

模型分为两部分1.正向模型 2.反向模型
正向模型构造权重和偏执的值，得到结果。
反向模型计算得到的结果与实际结果的偏差，通过优化W和b的值返回给正向模型计算。
如此反复得到最优的W和b的值。

正向的数据模型

# 占位符
X = tf.placeholder("float")
Y = tf.placeholder("float")
# 模型参数 
W = tf.Variable(tf.random_normal([1]), name="weight") # w是矩阵 所以大写来区分。初始值为0到1的随机值
b = tf.Variable(tf.zeros([1]), name="bias") # 初始为0的一维数组

# 前向结构
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) #Gradient descent

cost 即方差,计算出Y的值和得到的z的方差。
learning_rate 表示学习效率 这个值需要适当调整 一般是小于1的小数。
optimizer 优化器 通过tf.train 使用 GradientDescentOptimizer(梯度下降优化器) 减小 cost的值。

开始训练模型

最重要的一句:

# 初始化变量 不然前面所有定义的变量都无效
init = tf.global_variables_initializer() 

定义两个参数 一个 训练总步数 一个 显示数据跳的步数

# 训练参数
training_epochs = 20
display_step = 2

训练代码如下:

# 启动session
with tf.Session() as sess: # python语法 session可以自动关闭
    sess.run(init) # 载入所有变量
    # Fit all training data
    for epoch in range(training_epochs): # 循环 20次
        for (x, y) in zip(train_X, train_Y):  # 循环取出数据集数据 python zip函数
            sess.run(optimizer, feed_dict={X: x, Y: y})  

这里指定注意的是 optimizer 是一个 placeholder(占位符) 变量 每次run都需要传入字典类型的参数。这里传入x，y的值 用于计算方差 优化迭代

显示训练过程中的变化:
loss 即 误差大小 可以观测到整个误差值的变化

plotdata = { "batchsize":[], "loss":[] } //with session 外定义字典


# 启动session 往字典内加入值
with tf.Session() as sess:
    ...... 
    ...... ,  MMMMMMMMMM
        #显示训练中的详细信息
        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)
    //绘制字典内容
    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()

图像显示:

image.png

当然顺便也绘制了拟合后的函数图像。

image.png

使用训练结果:

假设输入0.2

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

得出:

x=0.2，z= [0.40521938]

运行z函数 利用得到的w和b 输入0.2得到0.4

总结

这里主要是学习到 整个机器学习训练的过程。