Tensorflow搭建简易神经网络——快速入门

最新推荐文章于 2022-05-06 18:21:06 发布

ZHY@

最新推荐文章于 2022-05-06 18:21:06 发布

阅读量455

点赞数

分类专栏： tensorflow入门文章标签： tensorflow 神经网络

本文链接：https://blog.csdn.net/weixin_43793458/article/details/90668712

版权

tensorflow入门专栏收录该内容

3 篇文章 0 订阅

订阅专栏

Windows10+Tensorflow1.10+Python3.6.2
这是一篇学习笔记，如果文中有任何错误欢迎@我更正。
另，
吴恩达系列视频：https://mooc.study.163.com/university/deeplearning_ai#/c
　　　　　　　　https://study.163.com/course/introduction/1004570029.htm
莫烦python：https://space.bilibili.com/243821484?spm_id_from=333.788.b_765f7570696e666f.1
推荐书籍：《Tensorflow实战Google深度学习框架（第二版）》.郑宇泽梁博文顾思宇著。

神经网络的基本原理建议去B站看《莫烦python-tensorflow搭建神经网络》，原理言简意赅，对于快速上手的小白非常友好。

一、搭建神经网络的基本流程

定义神经层
生成训练数据
定义节点(placeholder)准备接收数据
添加神经层：隐藏层(hidden layer)和预测层(prediction layer)
定义损失函数(loss) 表达式
选择优化器(optimizer)使 loss 达到最小
初始化所有变量
tf.Session——让程序“跑”起来
进行迭代运算，输出结果

二、各部分代码及解释

1、定义神经层

def add_layer(inputs, in_size, out_size, activation_function=None):
    # add one more layer and return the output of this layer
    weights = tf.Variable(tf.random_normal([in_size, out_size]))
    biases = tf.Variable(tf.zeros([1, out_size]) + 0.1)
    wx_plus_b = tf.matmul(inputs, weights) + biases
    if activation_function is None:
        outputs = wx_plus_b
    else:
        outputs = activation_function(wx_plus_b)
    return outputs

函数名	功能
tf.Variable()	变量声明，初始化变量
tf.random_normal()	正态分布随机数，格式为[in_size, out_size]
tf.zeros()	产生全0数组，格式为[1, out_size]
tf.matmul()	矩阵乘法

2、生成训练数据

# Make up some real data
x_data = np.linspace(-1, 1, 300)[:, np.newaxis]
noise = np.random.normal(0, 0.05, x_data.shape)
y_data = np.square(x_data) - 0.5 + noise

参数名	属性
x_data	输入数据，[-1,1]范围内300个点，维度是[300,None],也就是300行
noise	噪点，让数据更接近真实值
y_data	输出数据

函数名	功能
np.linspace()	[-1,1]范围内300个点
np.newaxis()	None
np.random.normal()	noise数据的均值、标准差、输出尺寸
np.square()	平方运算

3、定义节点(placeholder)准备接收数据

# define placholder for inputs to network
xs = tf.placeholder(tf.float32, [None, 1])
ys = tf.placeholder(tf.float32, [None, 1])

placeholder机制用于提供输入数据，相当于定义一个位置，这个位置中的数据在程序运行时再指定。与feed_dict联合使用。

4、添加神经层：隐藏层(hidden layer)和预测层(prediction layer)

# add hidden layer
layer1 = add_layer(xs, 1, 10, n_layer=1, activation_function=tf.nn.relu)
# add hidden layer
prediction = add_layer(layer1, 10, 1, n_layer=2, activation_function=None)

这个神经网络包括：输入层、隐藏层、输出层(prediction)
activation_function=tf.nn.relu # 选择激励函数为relu

查看常用激励函数点这里
输入数据只有一个属性，在输入层就定义一个节点；隐藏层先设为10个节点；输出数据只有一个属性，就定义为1个节点
隐藏层节点数设置方法：
①fangfaGorman指出隐层结点数s与模式数N的关系是：s＝log2N；
②Kolmogorov定理表明，隐层结点数s＝2n＋1（n为输入层结点数）；
③s＝sqrt（0.43mn＋0.12nn＋2.54m＋0.77n＋0.35）＋0.51 （m是输入层的个数，n是输出层的个数）。

5、定义损失函数(loss) 表达式

# the error between prediciton and real data    
loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys - prediction),
                    reduction_indices=[1]))

函数名	功能
tf.reduce_mean()	求均值
tf.reduce_sum()	求和
tf.square()	求平方

reduction_indices表示函数的处理维度，参数取默认值None，将把input_tensor降到0维，也就是一个数。

6、选择优化器(optimizer)使 loss 达到最小

train_step = tf.train.GradientDescentOptimizer(0.1).minimize(loss)

GradientDescentOptimizer()使用随机梯度下降算法，使参数沿着梯度的反方向，即总损失减小的方向移动，实现更新参数。其中，?(?)为损失函数，?为参数，?为学习率。

Tensorflow提供的关于优化器的介绍请查看官方API
0.1是指学习率，学习率决定了每次参数更新的幅度，如果幅度过大可能导致参数在极优值的两侧来回移动；相反，当学习率过小时虽然能保证收敛性，但是这会大大降低优化速度。tensorflow提供了一种更加灵活的学习效率设置方法——指数衰减法。tf.train.exponential_decay函数实现了指数衰减学习效率。函数解释点这里。

7、初始化所有变量

init = tf.global_variables_initializer()

Very important step，不进行初始化无法完成后续操作。

8、tf.Session——让程序“跑”起来

sess = tf.Session()
sess.run(init)

sess.run(init) 首先让初始化的程序运行起来，将所有变量初始化

9、进行迭代运算，输出结果

for i in range(1000):
   # training train_step 和 loss 都是由 placeholder 定义的运算，所以这里要用 feed 传入参数
   sess.run(train_step, feed_dict={xs: x_data, ys: y_data})
   if i % 50 == 0:
       # to see the step improvement
       print(sess.run(loss, feed_dict={xs: x_data, ys: y_data}))

feed_dict为了方便使用batch，这里使用的是所有的data。 详细解释

三、源程序及结果

import tensorflow as tf
import numpy as np


# 定义神经层
def add_layer(inputs, in_size, out_size, activation_function=None):
    # add one more layer and return the output of this layer
    weights = tf.Variable(tf.random_normal([in_size, out_size]))
    biases = tf.Variable(tf.zeros([1, out_size]) + 0.1)
    wx_plus_b = tf.matmul(inputs, weights) + biases
    if activation_function is None:
        outputs = wx_plus_b
    else:
        outputs = activation_function(wx_plus_b)
    return outputs


# 生成数据
# Make up some real data
x_data = np.linspace(-1, 1, 300)[:, np.newaxis]
noise = np.random.normal(0, 0.05, x_data.shape)
y_data = np.square(x_data) - 0.5 + noise

# 定义节点准备接收数据
# define placeholder for inputs to network
xs = tf.placeholder(tf.float32, [None, 1])
ys = tf.placeholder(tf.float32, [None, 1])

# 添加神经层：隐藏层和预测层
# add hidden layer 输入值是 xs，在隐藏层有 10 个神经元
l1 = add_layer(xs, 1, 10, activation_function=tf.nn.relu)
# add output layer 输入值是隐藏层 l1，在预测层输出 1 个结果
prediction = add_layer(l1, 10, 1, activation_function=None)

# 定义 loss 表达式
# the error between prediciton and real data
loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys - prediction),
                                    reduction_indices=[1]))

# 选择 optimizer 使 loss 达到最小
# 这一行定义了用什么方式去减少 loss，学习率是 0.1
train_step = tf.train.GradientDescentOptimizer(0.1).minimize(loss)

# important step 对所有变量进行初始化
init = tf.global_variables_initializer()

# 上面定义的都没有运算，直到 sess.run 才会开始运算
sess = tf.Session()
sess.run(init)

# 迭代 1000 次学习，并输出结果
for i in range(1000):
    # training train_step 和 loss 都是由 placeholder 定义的运算，所以这里要用 feed 传入参数
    sess.run(train_step, feed_dict={xs: x_data, ys: y_data})
    if i % 50 == 0:
        # to see the step improvement
        print(sess.run(loss, feed_dict={xs: x_data, ys: y_data}))
 sess.close()

在这里插入图片描述
建议用：

with tf.Session() as sess:
    sess.run(init)
    # 迭代 1000 次学习，sess.run optimizer
    for i in range(1000):
        # training train_step 和 loss 都是由 placeholder 定义的运算，所以这里要用 feed 传入参数
        sess.run(train_step, feed_dict={xs: x_data, ys: y_data})
        if i % 50 == 0:
            # to see the step improvement
            print(sess.run(loss, feed_dict={xs: x_data, ys: y_data}))

代替：

# 上面定义的都没有运算，直到 sess.run 才会开始运算
sess = tf.Session()
sess.run(init)

# 迭代 1000 次学习，并输出结果
for i in range(1000):
    # training train_step 和 loss 都是由 placeholder 定义的运算，所以这里要用 feed 传入参数
    sess.run(train_step, feed_dict={xs: x_data, ys: y_data})
    if i % 50 == 0:
        # to see the step improvement
        print(sess.run(loss, feed_dict={xs: x_data, ys: y_data}))
sess.close()

通过Python上下文管理器的机制，在退出的时候会自动释放所有资源。这样既解决了因为异常退出时资源释放的问题，同时也解决了忘记调用Session.close函数而产生的资源泄露。

参考文档：
[1].https://blog.csdn.net/m0_37324740/article/details/77803694
[2].https://www.jianshu.com/p/e112012a4b2d
[3].https://blog.csdn.net/wuguangbin1230/article/details/77658229
[4]. https://blog.csdn.net/qq_34562093/article/details/80611611
[5].https://blog.csdn.net/u013421629/article/details/78329191/
[6].https://www.cnblogs.com/polly333/p/8118740.html

感谢网友分享资料！如果文章出现侵权、知识错误、代码错误，请及时联系我，欢迎大家批评指正！

ZHY@

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
Tensorflow搭建简易神经网络——快速入门

Windows10+Tensorflow1.10+Python3.6.2这是一篇学习笔记，如果文中有任何错误欢迎@我更正。另，吴恩达系列视频：https://mooc.study.163.com/university/deeplearning_ai#/c　　　　　　　　https://study.163.com/course/introduction/1004570029.htm莫烦py...
复制链接

扫一扫