tesorflow - create neural network+结果可视化+加速神经网络训练+Optimizer+TensorFlow

以下仅为了自己方便查看，绝大部分参考来源：莫烦Python，建议去看原博客 

 

定义 add_layer()函数

在 Tensorflow 里定义一个添加层的函数可以很容易的添加神经层,为之后的添加省下不少时间.

神经层里常见的参数通常有weights、biases和激励函数。

然后定义添加神经层的函数def add_layer(),它有四个参数：输入值、输入的大小、输出的大小和激励函数，我们设定默认的激励函数是None。

def add_layer(inputs, in_size, out_size, activation_function=None):

接下来，我们开始定义weights和biases。

因为在生成初始参数时，随机变量(normal distribution)会比全部为0要好很多，所以我们这里的weights为一个in_size行, out_size列的随机变量矩阵。在机器学习中，biases的推荐值不为0，所以我们这里是在0向量的基础上又加了0.1。

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()是矩阵的乘法。

Wx_plus_b = tf.matmul(inputs, Weights) + biases

当activation_function——激励函数为None时，输出就是当前的预测值——Wx_plus_b，不为None时，就把Wx_plus_b传到activation_function()函数中得到输出。

if activation_function is None:
    outputs = Wx_plus_b
else:
    outputs = activation_function(Wx_plus_b)

最后，返回输出

return outputs

整体代码

def add_layer(inputs, in_size, out_size, activation_function=None):
    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 == None:
        outputs = Wx_plus_b
    else:
        outputs = activation_function(Wx_plus_b)

    return outputs

 

二、建造神经网络

导入数据

 构建所需的数据。 这里的x_data和y_data并不是严格的一元二次函数的关系，因为我们多加了一个noise,这样看起来会更像真实情况。

  • np.linspace(-1,1,300, dtype=np.float32) # 开始端-1，结束端1，且分割成300个数据，生成线段（在指定的间隔内返回均匀间隔的数字）
  • np.random.normal(loc=0, scale=1, size) 给出均值为loc，标准差为scale的高斯随机数（场）.
  • np.random.randn(size)  所谓标准正态分布（μ=0,σ=1）
  • np.square() 求平方
  • np.arange(begin, end, step) 返回一个有终点和起点的固定步长的排列（一个参数时，参数值为终点，起点默认0，步长默认1）
  • np.newaxis 作用就是在这一位置增加一个一维，这一位置指的是np.newaxis所在的位置（参考下面的链接）

参考链接：

从np.random.normal()到正态分布的拟合

np.newaxis    关于np.newaxis的一点理解

x_data = np.linspace(-1,1,300, dtype=np.float32)[:, np.newaxis] # [:, np.newaxis]将(300,0)的数组，变成(300, 1)
noise = np.random.normal(0, 0.05, x_data.shape).astype(np.float32) 
y_data = np.square(x_data) - 0.5 + noise

利用占位符定义我们所需的神经网络的输入。 tf.placeholder()就是代表占位符，这里的None代表无论输入有多少都可以，因为输入只有一个特征，所以这里是1。

xs = tf.placeholder(tf.float32, [None, 1])
ys = tf.placeholder(tf.float32, [None, 1])

接下来，我们就可以开始定义神经层了。 通常神经层都包括输入层、隐藏层和输出层。这里的输入层只有一个属性， 所以我们就只有一个输入；隐藏层我们可以自己假设，这里我们假设隐藏层有10个神经元； 输出层和输入层的结构是一样的，所以我们的输出层也是只有一层。 所以，我们构建的是——输入层1个、隐藏层10个、输出层1个的神经网络。

搭建网络

下面，我们开始定义隐藏层,利用之前的add_layer()函数，这里使用 Tensorflow 自带的激励函数tf.nn.relu。

l1 = add_layer(xs, 1, 10, activation_function=tf.nn.relu)

接着，定义输出层。此时的输入就是隐藏层的输出——l1，输入有10层（隐藏层的输出层），输出有1层。

prediction = add_layer(l1, 10, 1, activation_function=None)

计算预测值prediction和真实值的误差，对二者差的平方求和再取平均。

  • reduction_indices=[1]  在tf.reduce_sum等函数中，有一个reduction_indices参数，表示函数的处理维度。
  • 当为1时代表按行求和，当为0时代表按列求和；当没有reduction_indices这个参数，此时该参数取默认值None，将把input_tensor降到0维，也就是一个数
loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys - prediction),
                     reduction_indices=[1]))

接下来，是很关键的一步，如何让机器学习提升它的准确率。tf.train.GradientDescentOptimizer()中的值通常都小于1，这里取的是0.1，代表以0.1的效率来最小化误差loss。

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

使用变量时，都要对它进行初始化，这是必不可少的。

# init = tf.initialize_all_variables() # tf 马上就要废弃这种写法
init = tf.global_variables_initializer()  # 替换成这样就好

定义Session，并用 Session 来执行 init 初始化步骤。 （注意：在tensorflow中，只有session.run()才会执行我们定义的运算。）

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

训练

下面，让机器开始学习。

比如这里，我们让机器学习1000次。机器学习的内容是train_step, 用 Session 来 run 每一次 training 的数据，逐步提升神经网络的预测准确性。 (注意：当运算要用到placeholder时，就需要feed_dict这个字典来指定输入。)

for i in range(1000):
    # training
    sess.run(train_step, feed_dict={xs: x_data, ys: y_data})

每50步我们输出一下机器学习的误差。

if i % 50 == 0:
    # to see the step improvement
　　print(sess.run(loss, feed_dict={xs: x_data, ys: y_data}))

全部代码

import numpy as np
import tensorflow as tf

def add_layer(inputs, in_size, out_size, activation_function=None):
    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 == None:
        outputs = Wx_plus_b
    else:
        outputs = activation_function(Wx_plus_b)

    return outputs


# 构建所需的数据。 这里的x_data和y_data并不是严格的一元二次函数的关系，因为我们多加了一个noise,这样看起来会更像真实情况。
x_data = np.linspace(-1,1,300,dtype=np.float32)[:,np.newaxis] #维度
noise = np.random.normal(0, 0.05,x_data.shape).astype(np.float32)
y_data = np.square(x_data) - 0.5 + noise


# 利用占位符定义我们所需的神经网络的输入。 tf.placeholder()就是代表占位符，这里的None代表无论输入有多少都可以，因为输入只有一个特征，所以这里是1
xs = tf.placeholder(tf.float32, [None, 1])
ys = tf.placeholder(tf.float32, [None, 1])

'''
接下来，我们就可以开始定义神经层了。 通常神经层都包括输入层、隐藏层和输出层。这里的输入层只有一个属性， 所以我们就只有一个输入；隐藏层我们可以自己假设，这里我们假设隐藏层有10个神经元； 输出层和输入层的结构是一样的，所以我们的输出层也是只有一层。 所以，我们构建的是——输入层1个、隐藏层10个、输出层1个的神经网络。
'''
# 开始定义隐藏层,利用之前的add_layer()函数，这里使用 Tensorflow 自带的激励函数tf.nn.relu
layer1 = add_layer(xs, 1, 10, activation_function=tf.nn.relu)
# 定义输出层。此时的输入就是隐藏层的输出——l1，输入有10层（隐藏层的输出层），输出有1层
prediction = add_layer(layer1, 10, 1, activation_function=None)

# 计算预测值prediction和真实值的误差，对二者差的平方求和再取平均
loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys - prediction), reduction_indices=[1]))

# 接下来，是很关键的一步，如何让机器学习提升它的准确率。tf.train.GradientDescentOptimizer()中的值通常都小于1，这里取的是0.1，代表以0.1的效率来最小化误差loss
optimizer = tf.train.GradientDescentOptimizer(0.1)
train_step = optimizer.minimize(loss)

# 使用变量时，都要对它进行初始化，这是必不可少的
init = tf.global_variables_initializer()

# 定义Session，并用 Session 来执行 init 初始化步骤。 （注意：在tensorflow中，只有session.run()才会执行我们定义的运算。）
sess = tf.Session()
sess.run(init)

# 让机器学习1000次。机器学习的内容是train_step, 用 Session 来 run 每一次 training 的数据，逐步提升神经网络的预测准确性。 (注意：当运算要用到placeholder时，就需要feed_dict这个字典来指定输入。)
for i in range(1000):
    sess.run(train_step, feed_dict={xs:x_data, ys:y_data})
    # 每50步我们输出一下机器学习的误差。
    if i % 50 ==0:
        print(sess.run(loss, feed_dict={xs:x_data, ys:y_data}))

三、结果可视化

matplotlib 可视化

构建图形，用散点图描述真实数据之间的关系。 （注意：plt.ion()用于连续显示。）

  • plt.figure() 定义一个图像窗口
  • plt.plot(x, y) plt.plot画(x ,y)曲线
  • plt.show() 显示图像.
  • fig.add_subplot(1,1,1) 将画布分割成1行1列，图像画在从左到右从上到下的第1块 fig.add_subplot(111) 参考链接：matplotlib.pyplot中add_subplot方法参数111的含义
  • ax.scatter() 绘制散点图  参考链接：Python中scatter函数参数详解
  • plt.ion() 使matplotlib的显示模式转换为交互（interactive）模式，可以展示动态图或多个窗口
import matplotlib.pylab as plt
# plot the real data
fig = plt.figure() #plt.figure()
ax = fig.add_subplot(1,1,1) #将画布分割成1行1列，图像画在从左到右从上到下的第1块 fig.add_subplot(111)
ax.scatter(x_data, y_data) # 绘制散点图
plt.ion() #使matplotlib的显示模式转换为交互（interactive）模式，可以展示动态图或多个窗口
plt.show() #显示图像.

tesorflow - create neural network+结果可视化+加速神经网络训练+Optimizer+TensorFlow

接下来，我们来显示预测数据。

每隔50次训练刷新一次图形，用红色、宽度为5的线来显示我们的预测数据和输入之间的关系，并暂停0.1s。 

  • plt.plot(x,y,format_string,**kwargs)  x轴数据，y轴数据，format_string控制曲线的格式字串 
  • format_string 由颜色字符，风格字符，和标记字符   参考链接 
for i in range(1000):
    sess.run(train_step, feed_dict={xs:x_data, ys:y_data})
    # 每50步我们输出一下机器学习的误差。
    if i % 50 ==0:
        # print(sess.run(loss, feed_dict={xs:x_data, ys:y_data}))
        try:
            ax.lines.remove(lines[0]) #每一次循环都先将上一次生成的图像删除
        except:
            pass
        prediction_value = sess.run(prediction, feed_dict={xs:x_data})
        # plot the prediction'
        lines = ax.plot(x_data, prediction_value, 'r-', lw=5) # 'r-'代表红色实线 lw代表宽度
        plt.pause(0.1) #暂停0.1s

tesorflow - create neural network+结果可视化+加速神经网络训练+Optimizer+TensorFlow

完整代码：

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

def add_layer(inputs, in_size, out_size, activation_function=None):
    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 == None:
        outputs = Wx_plus_b
    else:
        outputs = activation_function(Wx_plus_b)

    return outputs


# 构建所需的数据。 这里的x_data和y_data并不是严格的一元二次函数的关系，因为我们多加了一个noise,这样看起来会更像真实情况。
x_data = np.linspace(-1,1,300,dtype=np.float32)[:,np.newaxis] #维度
noise = np.random.normal(0, 0.05,x_data.shape).astype(np.float32)
y_data = np.square(x_data) - 0.5 + noise


# 利用占位符定义我们所需的神经网络的输入。 tf.placeholder()就是代表占位符，这里的None代表无论输入有多少都可以，因为输入只有一个特征，所以这里是1
xs = tf.placeholder(tf.float32, [None, 1])
ys = tf.placeholder(tf.float32, [None, 1])

'''
接下来，我们就可以开始定义神经层了。 通常神经层都包括输入层、隐藏层和输出层。这里的输入层只有一个属性， 所以我们就只有一个输入；隐藏层我们可以自己假设，这里我们假设隐藏层有10个神经元； 输出层和输入层的结构是一样的，所以我们的输出层也是只有一层。 所以，我们构建的是——输入层1个、隐藏层10个、输出层1个的神经网络。
'''
# 开始定义隐藏层,利用之前的add_layer()函数，这里使用 Tensorflow 自带的激励函数tf.nn.relu
layer1 = add_layer(xs, 1, 10, activation_function=tf.nn.relu)
# 定义输出层。此时的输入就是隐藏层的输出——l1，输入有10层（隐藏层的输出层），输出有1层
prediction = add_layer(layer1, 10, 1, activation_function=None)

# 计算预测值prediction和真实值的误差，对二者差的平方求和再取平均
loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys - prediction), reduction_indices=[1]))

# 接下来，是很关键的一步，如何让机器学习提升它的准确率。tf.train.GradientDescentOptimizer()中的值通常都小于1，这里取的是0.1，代表以0.1的效率来最小化误差loss
optimizer = tf.train.GradientDescentOptimizer(0.1)
train_step = optimizer.minimize(loss)

# 使用变量时，都要对它进行初始化，这是必不可少的
init = tf.global_variables_initializer()

# 定义Session，并用 Session 来执行 init 初始化步骤。 （注意：在tensorflow中，只有session.run()才会执行我们定义的运算。）
sess = tf.Session()
sess.run(init)

fig = plt.figure() #plt.figure()
ax = fig.add_subplot(1,1,1) #将画布分割成1行1列，图像画在从左到右从上到下的第1块 fig.add_subplot(111)
ax.scatter(x_data, y_data) # 绘制散点图
plt.ion() #使matplotlib的显示模式转换为交互（interactive）模式，可以展示动态图或多个窗口
plt.show() #显示图像.

# 让机器学习1000次。机器学习的内容是train_step, 用 Session 来 run 每一次 training 的数据，逐步提升神经网络的预测准确性。 (注意：当运算要用到placeholder时，就需要feed_dict这个字典来指定输入。)
for i in range(1000):
    sess.run(train_step, feed_dict={xs:x_data, ys:y_data})
    # 每50步我们输出一下机器学习的误差。
    if i % 50 ==0:
        # print(sess.run(loss, feed_dict={xs:x_data, ys:y_data}))
        try:
            ax.lines.remove(lines[0]) #每一次循环都先将上一次生成的图像删除
        except:
            pass
        prediction_value = sess.run(prediction, feed_dict={xs:x_data})
        # plot the prediction'
        lines = ax.plot(x_data, prediction_value, 'r-', lw=5) # 'r-'代表红色实线 lw代表宽度
        plt.pause(0.1) #暂停0.1s
View Code

相关文章：

  • 2021-08-29
  • 2021-10-23
  • 2021-05-18
  • 2021-09-13
  • 2022-01-10
  • 2021-05-18
  • 2021-07-06
  • 2021-10-09
猜你喜欢
  • 2021-11-29
  • 2021-06-18
  • 2021-11-30
  • 2021-09-17
  • 2021-08-11
相关资源
相似解决方案
热门标签
Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode