深度学习-TensorFlow入门学习笔记1

一．以逻辑回归拟合二维数据为例

• 深度学习的4个基本步骤：
  • 准备数据
  • 搭建模型
  • 迭代训练
  • 使用模型

接下来，根据上述4个步骤，完成逻辑回归拟合二维数据。

• 实例描述：
  • 假设有一组数据集，其$x$和$y$的对应关系为$y\approx 2x$，即让神经网络能够总结出$y\approx 2x$这样的公式。
• 代码实现：

# -*- coding: utf-8 -*-

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

#训练模型可视化
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)]


#生成[-1,1]之间的100个数作为x
train_X = np.linspace(-1, 1, 100) 

#将x乘以2，再加上一个[-1,1]区间的随机数*0.3,即以$y=2x$做主体，加入噪声，变成$y\approx2x$
train_Y = 2 * train_X + np.random.randn(*train_X.shape) * 0.3 
#np.random.randn(100)

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


# 创建模型
# 占位符
X = tf.placeholder("float")
Y = tf.placeholder("float")

# 模型参数
#W初始化成[-1,1]的随机数，形状是一维的数字
W = tf.Variable(tf.random_normal([1]), name="weight")
#b初始化成0，形状也是一维的数字
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
 #Gradient descent
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)

#训练模型
# 初始化变量
init = tf.global_variables_initializer()
# 训练参数
training_epochs = 20 #迭代次数
display_step = 2 #每2次进行一次结果输出

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

    # 向模型输入数据
    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}))


    #训练模型可视化
    #图形显示
    plt.plot(train_X, train_Y, 'ro', label='Original data')
    plt.plot(train_X, sess.run(W) * train_X + sess.run(b), label='Fitted line')
    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次，通过 sess.run来进行网络节点的运算，通过feed机制将真实数据灌到占位符对应的位置（feed_dict={X： x，Y： y}），同时，每执行一次都会将网络结构中的节点打印出来。
    

  • 训练模型可视化：

  • 下图所示斜线，是模型中的参数W和b为常量所组成的关于x与y的直线方程。可以看到是一条几乎$y=2x$的直线（W=2.115327接近于 2，b=-0.08504687接近于0）。
    

  • 可视化训练Loss：

  • 从下图可以看到刚开始损失值一直在下降，直到5次左右趋近平稳。
    

  • 结果：
    

• 模型里的内容及意义
• 搭建模型

  • 模型的方向：正向和反向

  • 正向：

    • 了解模型及公式
    • 建立模型，生成一个值，观察与真实值的差距

  • 反向：

    • 引入算法调参，不断比较正向生成的预测值与真实值的差距
• 总结：
• TensorFlow开发的基本步骤：
  • 定义TensorFlow输入节点
  • 定义“学习参数”变量
  • 定义“运算”
  • 优化函数，优化目标
  • 初始化所有变量
  • 迭代更新参数到最优解
  • 测试模型
  • 使用模型
• 定义输入节点的方法：

#1 - 通过占位符定义，一般使用较多
X = tf.placeholder("float")
Y = tf.placeholder("float")

#2 - 通过字典类型定义，和第一种比较像，只不过是堆叠到了一起，一般输入较多时候使用
inputdict = {'x' : tf.placeholder("float"),
		     'y' : tf.placeholder("float")}

#3 - 直接定义，使用较少
		     

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

#1 - 直接定义，例如上面代码的模型参数定义
W = tf.Variable(tf.random_normal([1]),name = "wegiht")
b = tf.Variable(tf.zeros([1]),name="bias")
# 前向结构
z = tf.multiply(X, W)+ b

#2 -字典定义，基于第一种上修改
paradict = {'w' : tf.Variable(tf.random_normal([1])),
			'b' : tf.Variable(tf.zeros([1]))}
#前向结构
z = tf.multiply(X,paradict['w'] + paradict['b'])

• 定义“运算”
  • 定义正向模型
  • 定义损失函数（可导）
• 优化函数，优化目标（根据情况选择优化方法）
• 初始化所有变量

#session创建好后，第一件事情就是初始化
init = tf.global_variables_initializer()
#启动session
with tf.Session()as sess:
	sess.run(init)

• 迭代更新参数到最优解

#最常用的是使用with语法，session结束自行关闭
with tf.Session() as sess:

#训练环节在run里放优化操作的OP，在外层加上循环次数
for epoch in range(training_epochs):
	for(x,y) in zip(train_X,train_Y):
		sess.run(optimizer, feed_dict={X:x,Y:y})

#真正使用过程中会引入一个叫做 MINIBATCH概念进行迭代训练，即每次取一定 量的数据同时放到网络里进行训练

• 测试模型（错误率）
• 使用模型

学习《深度学习之TensorFlow：入门、原理与进阶实战》