【深度学习】用tensorflow搭建自己的神经网络

【深度学习】用tensorflow搭建自己的神经网络

1.创建一个神经网络层

2.运用神经网络层搭建完整神经网络

3.显示训练过程

4.tensorboard展示神经网络图

  之前已经讲过了神经网络的基本知识：【机器学习】神经网络介绍  和 【深度学习】卷积神经网络入门

  本节用tensorflow来搭建一个神经网络，实现y=x*x+1的拟合。

1.创建一个神经网络层

   在之前的学习中，了解到一个完整的神经网络，包括输入层、卷积层、池化层、全连接层等部分。在tensorflow中，也已经有了专门的卷积层函数，例如：tf.nn.conv2d（卷积）、tf.nn.max_pool（池化）等。

   那如果想学习自己搭建一个神经网络层，需要包含哪些部分呢？

   如下图所示，一个神经网络层需要有数据输入、数据输出、激活函数。

            

 创建一个神经网络层

#创建一个神经网络层
def add_layer(input,in_size,out_size,activation_function=None):
    """
    :param input: 数据输入
    :param in_size: 输入大小（前一层神经元个数）
    :param out_size: 输出大小（本层神经元个数）
    :param activation_function: 激活函数（默认没有）
    :return:
    """
    Weight=tf.Variable(tf.random_normal([in_size,out_size]) )
    biases=tf.Variable(tf.zeros([1,out_size]) +0.1 )
    W_mul_x_plus_b=tf.matmul(input,Weight) + biases
    #根据是否有激活函数
    if activation_function == None:
        output=W_mul_x_plus_b
    else:
        output=activation_function(W_mul_x_plus_b)
    return output

分析：

    参数如下，

        input:输入个数

        in_size: 当前层的输入的个数

        out_size:当前层的输出的个数（即当前层神经元的个数）

        activation_function：激活函数（输入层无激活函数，仅起到传递信号的作用，卷积层、池化层等含有激活函数。）

    内部运算如下：

        权值初始化(Weight)：大小为 in_size * out_size；

         偏置初始化(biases)：大小为out_size（即本层神经元的个数）

        卷积和运算：W_mul_x_plus_b=tf.matmul(input,Weight) + biases

        输出为(output)：activation_function(W_mul_x_plus_b)，若无激活函数则为 output=W_mul_x_plus_b。

2.运用神经网络层搭建完整神经网络

一个完整的神经网络，需要有输入层（输入数据）、隐藏层（功能层）、输出层（输出结果）、损失函数、参数求取（梯度下降法）等。

#准备训练所需的数据

x_data=np.linspace(-1,1,300)[:,np.newaxis]   # 创建输入数据  np.newaxis分别是在列(第二维)上增加维度，原先是（300，）变为（300，1）
noise=np.random.normal(0,0.05,x_data.shape)  #噪声
y_data=np.square(x_data)+1+noise    # 创建输入数据对应的输出

#定义数据格式（占位符，便于下边训练）

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

#定义一个隐藏层，含有10个神经元

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

#定义一个输出层，含有1个神经元

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

#定义训练过程并进行训练

#求解神经网络参数
#1.定义损失函数
loss=tf.reduce_mean(tf.reduce_sum(tf.square(ys-prediction) ,reduction_indices=[1] ))
#2.定义训练过程
train_step=tf.train.GradientDescentOptimizer(0.1).minimize(loss) #梯度下降法使误差最小，学习率为0.1

init=tf.global_variables_initializer() #变量初始化
sess=tf.Session()
sess.run(init) #执行初始化
#3.进行训练
for i in range(1000):
    sess.run(train_step,feed_dict={xs:x_data,ys:y_data}) #训练
    if i%100==0:
        print(sess.run(loss,feed_dict={xs:x_data,ys:y_data} )  ) #输出当前loss

#关闭sess
sess.close()

---------------------------------------------  完整程序如下：---------------------------------------------------

#encoding:utf-8
#add_layer_1.py 练习增加网络层

#创建神经网络并训练
#功能：拟合 y=x*x+1

import tensorflow as tf
import numpy as np

#创建一个神经网络层
def add_layer(input,in_size,out_size,activation_function=None):
    """
    :param input: 数据输入
    :param in_size: 输入大小
    :param out_size: 输出大小
    :param activation_function: 激活函数（默认没有）
    :return:output：数据输出
    """
    Weight=tf.Variable(tf.random_normal([in_size,out_size]) )
    biases=tf.Variable(tf.zeros([1,out_size]) +0.1 )
    W_mul_x_plus_b=tf.matmul(input,Weight) + biases
    #根据是否有激活函数
    if activation_function == None:
        output=W_mul_x_plus_b
    else:
        output=activation_function(W_mul_x_plus_b)
    return output

#创建一个具有输入层，隐藏层，输出层的三层神经网络，神经元个数分别为1，10，1
x_data=np.linspace(-1,1,300)[:,np.newaxis]   # 创建输入数据  np.newaxis分别是在列(第二维)上增加维度，原先是（300，）变为（300，1）
noise=np.random.normal(0,0.05,x_data.shape)
y_data=np.square(x_data)+1+noise    # 创建输入数据对应的输出

# print(x_data.shape)
# x=np.linspace(-1,1,300)
# print(x.shape)

#定义输入数据
xs=tf.placeholder(tf.float32,[None,1])
ys=tf.placeholder(tf.float32,[None,1])

#定义一个隐藏层
hidden_layer1=add_layer(xs,1,10,activation_function=tf.nn.relu)
#定义一个输出层
prediction=add_layer(hidden_layer1,10,1,activation_function=None)

#求解神经网络参数
#1.定义损失函数
loss=tf.reduce_mean(tf.reduce_sum(tf.square(ys-prediction) ,reduction_indices=[1] ))
#2.定义训练过程
train_step=tf.train.GradientDescentOptimizer(0.1).minimize(loss)

init=tf.global_variables_initializer()
sess=tf.Session()
sess.run(init)
#3.进行训练
for i in range(1000):
    sess.run(train_step,feed_dict={xs:x_data,ys:y_data})
    if i%100==0:
        print(sess.run(loss,feed_dict={xs:x_data,ys:y_data} )  )

#关闭sess
sess.close()

运行结果：

                       

    发现随着训练次数的增加，loss越来越小。

3.显示训练过程

    matplotlib在Python中应用最多的2D图像的绘图工具包，使用matplotlib能够非常简单的可视化数据。

    在matplotlib中使用最多的模块就是pyplot，下边用pyplot简单的展示以下训练过程。

    1.首先，需要导入pyplot包

import matplotlib.pyplot as plt

    2.然后，绘制图像

# 绘制求解的曲线
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
ax.scatter(x_data, y_data)
plt.ion()  #Turn interactive mode on 开启互动模式
plt.show() #Display a figure


#3.进行训练
for i in range(1000):
    sess.run(train_step,feed_dict={xs:x_data,ys:y_data})
    if i%100==0:
        try:
            ax.lines.remove(lines[0])
        except Exception:
            pass

        print(sess.run(loss,feed_dict={xs:x_data,ys:y_data} )  )
        # 计算预测值
        prediction_value = sess.run(prediction, feed_dict={xs: x_data})
        #print(prediction.shape)
        # 绘制预测值
        lines = ax.plot(x_data, prediction_value, 'r-', lw=5)
        plt.pause(0.1)
# 关闭Session
plt.pause(1000)

过程展示：

    通过此方法可视化训练过程，可看到曲线渐渐拟合。

最终结果:

                

完整程序如下：

#encoding:utf-8
#add_layer_1.py 练习增加网络层

#创建神经网络并训练
#功能：拟合 y=x*x+1

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

#创建一个神经网络层
def add_layer(input,in_size,out_size,activation_function=None):
    """
    :param input: 数据输入
    :param in_size: 输入大小
    :param out_size: 输出大小
    :param activation_function: 激活函数（默认没有）
    :return:output：数据输出
    """
    Weight=tf.Variable(tf.random_normal([in_size,out_size]) )
    biases=tf.Variable(tf.zeros([1,out_size]) +0.1 )
    W_mul_x_plus_b=tf.matmul(input,Weight) + biases
    #根据是否有激活函数
    if activation_function == None:
        output=W_mul_x_plus_b
    else:
        output=activation_function(W_mul_x_plus_b)
    return output

#创建一个具有输入层，隐藏层，输出层的三层神经网络，神经元个数分别为1，10，1
x_data=np.linspace(-1,1,300)[:,np.newaxis]   # 创建输入数据  np.newaxis分别是在列(第二维)上增加维度，原先是（300，）变为（300，1）
noise=np.random.normal(0,0.05,x_data.shape)
y_data=np.square(x_data)+1+noise    # 创建输入数据对应的输出

# print(x_data.shape)
# x=np.linspace(-1,1,300)
# print(x.shape)

#定义输入数据
xs=tf.placeholder(tf.float32,[None,1])
ys=tf.placeholder(tf.float32,[None,1])

#定义一个隐藏层
hidden_layer1=add_layer(xs,1,10,activation_function=tf.nn.relu)
#定义一个输出层
prediction=add_layer(hidden_layer1,10,1,activation_function=None)

#求解神经网络参数
#1.定义损失函数
loss=tf.reduce_mean(tf.reduce_sum(tf.square(ys-prediction) ,reduction_indices=[1] ))
#2.定义训练过程
train_step=tf.train.GradientDescentOptimizer(0.1).minimize(loss)

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


# 绘制求解的曲线
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
ax.scatter(x_data, y_data)
plt.ion()  #Turn interactive mode on 开启互动模式
plt.show() #Display a figure


#3.进行训练
for i in range(1000):
    sess.run(train_step,feed_dict={xs:x_data,ys:y_data})
    if i%100==0:
        try:
            ax.lines.remove(lines[0])  #擦除之前的轨迹
        except Exception:
           pass

        print(sess.run(loss,feed_dict={xs:x_data,ys:y_data} )  )
        # 计算预测值
        prediction_value = sess.run(prediction, feed_dict={xs: x_data})
        #print(prediction.shape)
        # 绘制预测值
        lines = ax.plot(x_data, prediction_value, 'r-', lw=5)
        plt.pause(0.1)
# 关闭Session
plt.pause(1000)

#关闭sess
sess.close()

4.tensorboard展示神经网络图

神经网络结构的可视化：【tensorflow】Tensorboard的安装及使用，内附详细过程。              

      

    训练过程的可视化：

可视化的完整程序如下：

#encoding:utf-8
#add_layer1_view.py 练习网络层可视化

#创建神经网络并训练 #功能：拟合 y=x*x+noise+1
#功能：将add_layer1的图标可视化

import tensorflow as tf
import numpy as np

#创建一个神经网络层
def add_layer(input,in_size,out_size,activation_function=None):
    layer_name='layer_name'
    """
    :param input: 数据输入
    :param in_size: 输入大小
    :param out_size: 输出大小
    :param activation_function: 激活函数（默认没有）
    :return:
    """
    with tf.name_scope('layer') :
        with tf.name_scope('Weight'):
            Weight=tf.Variable(tf.random_normal([in_size,out_size]) )
            # Draw histogram: name, variable
            tf.summary.histogram(layer_name + '/weights', Weight)
        with tf.name_scope('biases'):
            biases=tf.Variable(tf.zeros([1,out_size]) +0.1 )
            tf.summary.histogram(layer_name + '/biases', biases)
        with tf.name_scope('W_mul_x_plus_b'):
            W_mul_x_plus_b=tf.matmul(input,Weight) + biases
    #根据是否有激活函数
    if activation_function == None:
        output=W_mul_x_plus_b
    else:
        output=activation_function(W_mul_x_plus_b)

        # at histogram
    tf.summary.histogram(layer_name + '/output', output)
    return output

#创建一个具有输入层，隐藏层，输出层的三层神经网络，神经元个数分别为1，10，1
x_data=np.linspace(-1,1,300)[:,np.newaxis]   # 创建输入数据  np.newaxis分别是在列(第二维)上增加维度，原先是（300，）变为（300，1）
noise=np.random.normal(0, 0.05,x_data.shape)
y_data=np.square(x_data)+1+noise    # 创建输入数据对应的输出


#定义输入数据
with tf.name_scope('input'):
    xs=tf.placeholder(tf.float32,[None,1],name='x_input')
    ys=tf.placeholder(tf.float32,[None,1],name='y_input')

#定义一个隐藏层
with tf.name_scope('hidden_layer'):
    hidden_layer1=add_layer(xs,1,10,activation_function=tf.nn.relu)
#定义一个输出层
with tf.name_scope('output_layer'):
    prediction=add_layer(hidden_layer1,10,1,activation_function=None)


#求解神经网络参数
#1.定义损失函数
with tf.name_scope('loss'):
    loss=tf.reduce_mean(tf.reduce_sum(tf.square(ys-prediction) ,reduction_indices=[1] ))
    # 2.使用tf.scalar_summary来收集想要显示的变量,命名为loss
    tf.summary.scalar('loss', loss)
#2.定义训练过程
with tf.name_scope('train'):
    train_step=tf.train.GradientDescentOptimizer(0.1).minimize(loss)


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

# 3.定义一个summury op, 用来汇总由scalar_summary记录的所有变量
merged_summary_op = tf.summary.merge_all()
# 4.生成一个summary writer对象，需要指定写入路径,例如我这边就是/tmp/logdir
summary_writer = tf.summary.FileWriter('logs_add_layer1/',sess.graph)

#将网络结构图写到文件中
#writer=tf.summary.FileWriter('logs_add_layer1/',sess.graph)
sess.run(init)
#3.进行训练
for i in range(1000):
    sess.run(train_step,feed_dict={xs:x_data,ys:y_data})

    if i%100==0:
        #print(sess.run(loss,feed_dict={xs:x_data,ys:y_data} )  )
        # 5.使用sess.run来得到merged_summary_op的返回值
        summary_str = sess.run(merged_summary_op,feed_dict={xs:x_data,ys:y_data})
    # 6.使用summary writer将运行中的loss值写入
    summary_writer.add_summary(summary_str, i)


#关闭sess
sess.close()

   -------------------------------------------         END      -------------------------------------

参考：https://www.jianshu.com/p/e112012a4b2d（一文学会用 Tensorflow 搭建神经网络）

          https://blog.csdn.net/mao19931004/article/details/51915016（Matplotlib简单入门学习）

                http://www.cnblogs.com/TaylorBoy/p/6802540.html（Tensorboard 可视化之训练过程）