-
神经网络的搭建
-
基本概念
基于Tensorflow的NN：用张量表示数据，用计算图搭建神经网络，用会话执行计算图，优化线上的权重（参数），得到模型。
张量：张量就是多维数组（列表），用阶表示张量的维度。
0阶张量称作标量，表示一个单独的数；
1阶张量称作向量，表示一个一维数组；V = [1, 2, 3]
2阶张量称作矩阵，表示一个二维数组，它可以有 i 行 j 列个元素，每个元素可以用行号和列号共同索引到：
m = [[1, 2, 3], [4, 5, 6],[7, 8, 9]]
判断张量是几阶的，就是看张量右边的括号数，0个是0阶，n个是n阶，张量可以表示0阶到n阶数组（列表）
数据类型：Tensorflow的数据类型有tf.float32 / tf.int32
#实现Tensorflow的加法
import TensorFlow as tf #引入模块
a = tf.constant([1.0, 2.0]) #定义一个张量等于[1.0, 2.0]
b = tf.constant([3.0, 4.0]) #定义一个张量等于[3.0, 4.0]
result = a + b #实现a+b的加法
print a+b #打印出结果
#输出结果为Tensor（“add：0”， shape=（2， ），dtype=float32）
#意思是result的输出结果是一个名称为add：0的张量，shape=（2，）表示一维数组长度为2，dtype=float32#表示数据类型为浮点型。
-
计算图
搭建神经网络的计算过程，是承载一个或多个计算节点的一张图，只搭建神经网络，不运算。
神经网络的基本模型是神经元，神经元的基本模型就是数学中的乘加运算，搭建如下的计算图：
x1和x2表示输入，w1和w2分别是x1到y和x2到y的权重，y = x1*w1 + x2*w2, 可以用如下的代码实现上面的计算图：
import tensorflow as tf #引入模块
x = tf.consant([[1.0, 2.0]]) #定义一个二阶张量等于[[1.0, 2.0]]
w = tf.constant([[3.0], [4.0]]) #定义一个二阶张量等于[[3.0], [4.0]]
y = tf.matmul(x, w) #实现xw矩阵乘法
print y #打印出结果
#打印出的结果为tensor("matmul:0", shape(1, 1), dtype=float32)
从上面我们可以看出，print的结果显示y是一个张量，只搭建了承载计算过程的计算图，并没有运算，如果想要得到运算结果就要用到“会话Session()”,
-
会话（session）
执行计算图的节点运算。
用with结构实现，语法如下：
with tf.Session() as sess:
print sess.run(y)
上面的计算图，执行Session（）会话可得到矩阵相乘的结果。
import tensorflow as tf
x = tf.constant([[1.0, 2.0]])
w = tf.comstant([[3.0]. [4.0]])
y = tf.matmul(x, w)
print y
with tf.Session() as sess:
print sess.run(y) #执行会话并打印出执行后的结果
执行后的输出结果为：
Tensor("matmul:0", shape(1, 1), dtype=float32)
[[11.]]
-
vim编辑器配置的更改
在vim ~/.vimrc中写 入：
set ts = 4 #表示使Tab键等效为4个空格
set nu #表示使vim显示行号 nu是number的缩写-
神经网络的参数
是指神经元线上的权重w，用变量表示，一般会先随机生成这些参数。
生成参数的方法是让w等于tf.Variable, 神经网络中常用的生成 随机数/数组的函数有：
tf.random_normal() #生成正态分布随机数
tf.truncated_normal() #生成去掉过大偏离点的正态分布随机数
tf.random_uniform() #生成均匀分布随机数
tf.zeros #表示生成全0数组
tf.ones #表示生成全1数组
tf.fill #表示生成全定值数组
tf.constant #表示生产直接给定值的数组
#举例
w = tf.Variable(tf.random_normal([2, 3], stddev=2, mean=0, seed=1))表示生成正态分布随机数，形状两行三列，标准差是2，均值是0，随机种子是1
w = tf.Variable(tf.truncated_normal([2, 3], stddev=2, mean=0, seed=1))表示去掉偏离过大的正态分布，也就是如果随机出来的数据偏离平均值超过两个标准差，这个数据将重新生成。、
w = random_uniform(shape=7, minval=0, maxval=1, dtype=tf.int32, seed=1)表示从一个均匀分布[minval, maxval]中随机采样， 注意定义域是左闭右开。
除了生成随机数，还可以生成常量。tf.zeros([3, 2], int32)表示生成[[0, 0], [0, 0], [0, 0]];
tf.fill([3, 2], 6)表示生成[[6, 6], [6, 6], [6, 6]]；
tf.constant([3, 2, 1])表示生成[3, 2, 1]
注意：随机种子去掉的话每次生成的随机数将不一致。
如果没有特殊要求标准差、均值、随机种子是可以不写的。
-
神经网络的搭建
下面是神经网络的实现过程。
- 准备数据集，提取特征，作为输入喂给神经网络（Neural Network, NN）
- 搭建NN结构， 从输入到输出（先搭建计算图，再用会话执行）——NN前向传播算法—>计算输出
- 大量特征数据喂给NN， 迭代优化NN参数 ——NN反向传播算法—>优化参数训练模型
- 使用训练好的模型预测和分类。
很多实际应用中，我们会先使用现有的成熟网络结构，喂给新的数据，训练相应的模型，判断是否能对喂入的从未见过的新数据做出正确响应，再适当更改网络结构，反复迭代， 让机器自动训练参数找出最优结构和参数以固定专用模型。
-
前向传播
前向传播就是搭建模型的计算过程，让模型具有推理能力，可以针对一组输入给出相应的输出。
举一个栗子;
假如生产一批零件，体积为x1，重量为x2，体积和重量就是我们选择的特征，把它们喂入神经网络，当体积和重量这组数据走过神经网络后会得到一个输出，假如输入的特征值是：体积0.7，重量为0.5，
则有;
图中，各条路径上都有相应的权重W值，由初始的X值，根据权重就可以算出下一层的数值大小，进而得到输出Y的值，这就实现了前向传播的过程，详细的推导过程如下：
输入层：X是输入为1X2的矩阵，我们用X表示输入，是一个1行2列的矩阵，表示一次输入一组特征，这组特征包含了体积和重量两个元素。
W为待优化的参数，对于第一层的W，前面有两个节点，后面有三个节点，所以W应该是一个两行三列的矩阵， 可以表示为：
神经网络共有几层，或当前是第几层网络，都是指的计算层，输入不是计算层，所以a是第一层网络，a是一个一行三列的矩阵，表示为：
第二层：参数W应满足前面三个节点，后面一个节点，所以后面的W应是三行一列的矩阵：
把每层输入乘以线上的权重W，用矩阵乘法就可以计算出输出Y了，即
a = tf.matmul(X, W1)
Y = tf.matmul(a, W2)
若要计算的结果，则用会话session实现。
前向传播的tensorflow描述总的来说就是：
变量初始化、计算图节点运算都要用会话（with结构）实现，
with tf.Session() as sess:
sess.run()
变量初始化：在sess.run函数中用tf.global_variables_initializer()汇总所有待优化变量，
init_op = tf.global_variables_initializer()
sess.run(init_op)
计算图节点运算：在sess.run()函数中写入待运算的节点，
sess.run(y)
用tf.placeholder()占位，在sess.run函数中用feed_dict喂数据，
#喂一组数据
x = tf.placehoder(tf.float32, shape=(1, 2))
sess.run(y, feed_dict={x: [[0.5, 0.6]]})
#喂多组数据
x = tf.placehoder(tf.float32, shape=(none, 2))
sess.run(y, feed_dict={x: [[0.1, 0.2]， [0.3, 0.4]， [0.5, 0.6]]})
下面给出实现神经网络前向传播过程的完整代码,用placeholder实现输入定义（喂入一组数据）的情况：
#coding: utf-8
import tensorflow as tf
#定义输入和参数
x = tf.placeholder(tf.float32, shape=(1, 2))
w1 = tf.Variable(tf.random_normal([2, 3], stddev=1, seed=1))
w2 = tf.Variable(tf.random_normal([3, 1], stddev=1, seed=1))
#定义前向传播过程
a = tf.matmul(x, w1)
y = tf.matmul(a, w2)
#用会话计算结果
with tf.Session() as sess:
init_op = tf.global_variables_initializer()
sess.run(init_op)
print "y in tf3_3.py is :\n" , sess.run(y, feed_dict={x: [[0.7, 0.5]]})
用placeholder实现输入定义（喂入多组数据）的情况：
#coding: utf-8
import tensorflow as tf
#定义输入和参数
x = tf.placeholder(tf.float32, shape=(None, 2))
w1 = tf.Variable(tf.random_normal([2, 3], stddev=1, seed=1))
w2 = tf.Variable(tf.random_normal([3, 1], stddev=1, seed=1))
#定义前向传播过程
a = tf.matmul(x, w1)
y = tf.matmul(a, w2)
#用会话计算结果
with tf.Session() as sess:
init_op = tf.global_variables_initialzer()
sess,run(init_op)
print "y in tf3_4.py is :\n" , sess.run(y, feed_dict={x: [[0.7, 0.5], [0.2, 0.3], [0.3, 0.4], [0.4, 0.5]]}
-
反向传播
训练模型参数，在所有参数上用梯度下降，使NN模型在训练数据上的损失函数最小。
损失函数：（loss）计算得到的预测值y与已知答案y_的差距。
损失函数的计算有很多方法，均方误差MSE是比较常用的方法之一。
均方误差MSE;即前向传播计算结果与已知答案之差的平方再求平均。
用tensorflow函数表示为：
loss_mse = tf.reduce_mean(tf.square(y - y_))
反向传播的训练方法：以减小loss值为优化目标，有梯度下降,momentum优化器，Adam优化器等优化方法
三种优化方法用tensorflow的函数可以表示为：
train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)
train_step = tf.train.MomentumOptimizer(learning_rate, momentum).minimize(loss)
train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss)这三种优化方法的区别如下：
第一种使用随机梯度下降算法， 使参数沿着梯度的反方向，即总损失减小的方向移动，实现更新参数。
参数更新的公式是
其中，J(θ）为损失函数，θ为参数，α为学习率。
第二种在更新参数时，利用了超参数，参数更新公式是：
其中，α为学习率，超参数为β，θ为参数，g(θi-1)为损失函数的梯度。
第三种是利用自适应学习率的优化算法，Adam算法和随机梯度下降算法不同，随机梯度下降算法保持单一的学习率更新所有的参数，学习率在训练过程中并不会改变，而Adam算法通过计算梯度的一阶矩估计和二阶矩估计而为不同的参数设计独立的自适应学习率。
学习率：决定每次参数更新的幅度。
优化器中都需要一个叫做学习率的参数，使用时，如果学习率选择过大会出现震荡不收敛的情况，如果学习率选择过小，会出现收敛速度慢的情况，我们可以选择一个比较小的某个值填入，例如0.01，0.001
-
搭建神经网络的框架
分四步完成：准备工作，前向传播，反向传播和循环迭代。
- 导入模块，生成模拟数据集：import——>常量定义——>生成数据集
- 前向传播：定义输入，参数和输出
- 反向传播：定义损失函数，反向传播方法 ： loss = train_step =
- 生成会话，训练STEPS轮
with tf.Session() as sess:
Init_op = tf.global_variables_initializer()
sess_run(Init_op)
STEPS = 3000
for i in range(STEPS):
start =
end =
sess.run(train_step, feed_dict:)
-
举一个例子通过源代码了解神经网络的过程
随机产生32组生成出的零件的体积和重量，训练3000轮，每500轮输出一次损失函数：
#coding:utf-8
#导入模块，生成模拟数据集
import tensorflow as tf
import numpy as np
BATCH_SIZE = 8
seed = 23455
#基于seed生成随机数
rng = np.random.RandomState(seed)
#随机数返回32行2列的矩阵，表示32组体积和重量，作为输入数据集
X = rng.rand(32, 2)
#从X这个32行2列的矩阵中，取出一行判断如果和小于1，给Y赋值1，如果和小于1，给Y赋值0
#作为输入数据集的标签（正确答案）
Y = [[int(x0 + x1 < 1)] for (x0, x1) in X]
print "X:\n",X
print "Y:\n",Y
#定义神经网络的输入，参数和输出，定义前向传播过程；
X = tf.placeholder(tf.float32, shape=(None, 2))
y_ = tf.placeholder(tf.float32, shape=(None, 1))
w1 = tf.Variable(tf.random_normal([2, 3], stddev= 1, seed=1))
w2 = tf.Variable(tf.random_normal([3, 1], stddev= 1, seed=1))
a = tf.matmul(x, w1)
y = tf.matmul(a, w2)
#定义损失函数及反向传播方法
loss = tf.reduce_mean(tf.square(y-y_))
train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss)
#生成会话，训练STEPS轮
with tf.Session() as sess:
init_op = tf.global_variables_initialzer()
sess.run(init_op)
#输出目前未经训练的参数取值
print "w1:\n", sess.run(w1)
print "w2:\n", sess.run(w2)
print "\n"
#训练模型
STEPS = 3000
for i in range(STEPS):
start = (i*BATCH_SIZE) % 32
end = start + BATCH_SIZE
sess.run(train_step, feed_dict={x: X[start:end], y_: Y[start:end]})
if i % 500 == 0:
total_loss = sess.run(loss, feed_dict={x : X, y_ : Y})
print(；After %d training step(s) , loss on all data is %g" % (i, total_loss))
#输出训练后的参数取值
print "\n"
print "w1:\n", sess.run(w1)
print "w2:\n", sess.run(w2)
由MOOC曹健老师的人工智能实践整理
扫一扫
2497
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
