从本篇文章开始，作者正式开始研究Python深度学习、神经网络及人工智能相关知识。前一篇文章主要讲解神经网络基础概念，同时讲解Theano库的安装过程及基础用法，这篇文章主要讲解theano实现回归神经网络，主要是学习"莫烦大神" 网易云视频的在线笔记，后面随着深入会讲解具体的项目及应用。基础性文章，希望对您有所帮助，也建议大家一步步跟着学习，同时文章中存在错误或不足之处，还请海涵~
"莫烦大神" 网易云视频地址：http://study.163.com/provider/1111519/course.html
从2014年开始，作者主要写了三个Python系列文章，分别是基础知识、网络爬虫和数据分析。
- Python基础知识系列：Pythonj基础知识学习与提升
- Python网络爬虫系列：Python爬虫之Selenium+Phantomjs+CasperJS
- Python数据分析系列：知识图谱、web数据挖掘及NLP
一. 定义神经网络Layer类
如下图所示，通过该神经网络识别动物猫或狗，共包括输入层（Input Layer）、隐藏层3层（Hidden Layer）和输出层（Output Layer）。其中
每一个神经元都有一个激励函数，被激励的神经元传递的信息最有价值，它也决定最后的输出结果，经过海量数据的训练，最终神经网络将可以用于识别猫或狗。
神经网络激励函数参考：
http://deeplearning.net/software/theano/library/tensor/nnet/nnet.html
激励函数相当于一个过滤器或激励器，它把特有的信息或特征激活，常见的激活函数包括softplus、sigmoid、relu、softmax、elu、tanh等。对于隐藏层，我们可以使用relu、tanh、softplus等非线性关系；对于分类问题，我们可以使用sigmoid（值越小越接近于0，值越大越接近于1）、softmax函数，对每个类求概率，最后以最大的概率作为结果；对于回归问题，可以使用线性函数（linear function）来实验。
神经网络首先需要添加神经层，将层（Layer）定义成类，通过类来添加神经层。神经层是相互链接，并且是全连接，从第一层输入层传入到隐藏层，最后传输至输出层。假设接下来需要定义两层内容：
L1 = Layer(inputs, in_size=1, out_size=10, activation_function)
参数包括输入值，输入节点数，输出节点数和激励函数
L2 = Layer(L1.outputs, 10, 1, None)
参数中L1的输出作为输入值，L1的输出10个节点作为输入节点，输出节点1个，激励函数为None。
定义类的代码如下，包括权重和bias，其中参数为随机变量更有利于我们后面的更新，乱序更能促进神经网络的学习。
class Layer(object):
def __init__(self, inputs, in_size, out_size, activation_function=None):
#权重: 平均值为0 方差为1 行数为in_size 列数为out_size
self.W = theano.shared(np.random.normal(0,1,(in_size,out_size)))
#bias
self.b = theano.shared(np.zeros((out_size,) ) + 0.1)
#乘法加bias
self.Wx_plus_b = T.dot(inputs, self.W) + self.b #dot乘法
#激励函数
self.activation_function = activation_function
#默认为None,否则进行激活
if activation_function is None:
self.outputs = self.Wx_plus_b
else:
self.outputs = self.activation_function(self.Wx_plus_b)
二. 回归神经网络实现
接下来开始跟着莫烦大声实现了第一个神经网络代码，步骤如下：
1.制造虚拟数据
通过numpy.linspace生成300个随机点进行训练，形成y=x^2-0.5的虚拟数据。代码如下：
#coding:utf-8
import numpy as np
import theano.tensor as T
import theano
from theano import function
class Layer(object):
def __init__(self, inputs, in_size, out_size, activation_function=None):
#权重: 平均值为0 方差为1 行数为in_size 列数为out_size
self.W = theano.shared(np.random.normal(0,1,(in_size,out_size)))
#bias
self.b = theano.shared(np.zeros((out_size,) ) + 0.1)
#乘法加bias
self.Wx_plus_b = T.dot(inputs, self.W) + self.b #dot乘法
#激励函数
self.activation_function = activation_function
#默认为None,否则进行激活
if activation_function is None:
self.outputs = self.Wx_plus_b
else:
self.outputs = self.activation_function(self.Wx_plus_b)
#回归神经网络 Regression
#1.制造虚拟数据
import matplotlib.pyplot as plt
#Make up some fake data
x_data = np.linspace(-1,1,300)[:, np.newaxis] #300个点进行训练
noise = np.random.normal(0, 0.05, x_data.shape)
y_data = np.square(x_data) - 0.5 + noise #y = x^2 - 0.5
#一元二次散点图
plt.scatter(x_data, y_data)
plt.show()生产的一元二次随机散点图如下图所示：
图1 散点图结果
2.增加神经层
定义输入x和y，注意其dtype类型为64位浮点型，整个代码前后类型需要保持一致。同时定义了L1层和L2层：
L1 = Layer(x, 1, 10, T.nnet.relu)
输入为x，1维的data，神经元10个，relu非线性激励函数
L2 = Layer(L1.outputs, 10, 1, None)
输入为L1输出值， L2的in_size为L1的神经元10，假设L2输出为最终output
#coding:utf-8
import numpy as np
import theano.tensor as T
import theano
from theano import function
class Layer(object):
def __init__(self, inputs, in_size, out_size, activation_function=None):
#权重: 平均值为0 方差为1 行数为in_size 列数为out_size
self.W = theano.shared(np.random.normal(0,1,(in_size,out_size)))
#bias
self.b = theano.shared(np.zeros((out_size,) ) + 0.1)
#乘法加bias
self.Wx_plus_b = T.dot(inputs, self.W) + self.b #dot乘法
#激励函数
self.activation_function = activation_function
#默认为None,否则进行激活
if activation_function is None:
self.outputs = self.Wx_plus_b
else:
self.outputs = self.activation_function(self.Wx_plus_b)
#回归神经网络 Regression
#1.制造虚拟数据
import matplotlib.pyplot as plt
#Make up some fake data
x_data = np.linspace(-1,1,300)[:, np.newaxis] #300个点进行训练
noise = np.random.normal(0, 0.05, x_data.shape)
y_data = np.square(x_data) - 0.5 + noise #y = x^2 - 0.5
#一元二次散点图
plt.scatter(x_data, y_data)
plt.show()
#2.定义输入和神经元
#determine the inputs dytpe
x = T.dmatrix('x') #d代表64位float类型
y = T.dmatrix('y')
#add layers
L1 = Layer(x, 1, 10, T.nnet.relu)
L2 = Layer(L1.outputs, 10, 1, None)3.计算误差与梯度下降更新
定义cost变量计算误差，即预测值与真实值的差别；再定义梯度下降变量，其误差越大，降低趋势越大，通过梯度下降让预测值更接近真实值。代码中通过theano.function()函数更新神经网络的四个参数，计算公式如下啊：
L1.W, L1.W-learnging_rate*gW1：
(原始的权重-学习效率*下降幅度)并且更新为L1.W，通过该方法将L1.W、L1.b、L2.W、L2.b更新。
#coding:utf-8
import numpy as np
import theano.tensor as T
import theano
from theano import function
class Layer(object):
def __init__(self, inputs, in_size, out_size, activation_function=None):
#权重: 平均值为0 方差为1 行数为in_size 列数为out_size
self.W = theano.shared(np.random.normal(0,1,(in_size,out_size)))
#bias
self.b = theano.shared(np.zeros((out_size,) ) + 0.1)
#乘法加bias
self.Wx_plus_b = T.dot(inputs, self.W) + self.b #dot乘法
#激励函数
self.activation_function = activation_function
#默认为None,否则进行激活
if activation_function is None:
self.outputs = self.Wx_plus_b
else:
self.outputs = self.activation_function(self.Wx_plus_b)
#回归神经网络 Regression
#1.制造虚拟数据
import matplotlib.pyplot as plt
#Make up some fake data
x_data = np.linspace(-1,1,300)[:, np.newaxis] #300个点进行训练
noise = np.random.normal(0, 0.05, x_data.shape)
y_data = np.square(x_data) - 0.5 + noise #y = x^2 - 0.5
#一元二次散点图
plt.scatter(x_data, y_data)
plt.show()
#2.定义输入和神经元
#determine the inputs dytpe
x = T.dmatrix('x') #d代表64位float类型
y = T.dmatrix('y')
#add layers
L1 = Layer(x, 1, 10, T.nnet.relu)
L2 = Layer(L1.outputs, 10, 1, None)
#3.计算误差与梯度下降更新
#误差为预测值与真实值差别
cost = T.mean(T.square(L2.outputs - y)) #mean()求平均误差
#compute the gradients
#梯度下降，让预测值更接近真实值，误差越大，降低趋势越大
gW1, gb1, gW2, gb2 = T.grad(cost, [L1.W, L1.b, L2.W, L2.b]) #权重和bias
#apply gradient descent
#学习效率: 神经网络中learning_rate通常小于1的数字,0.05保证神经网络学习比较精细
learning_rate = 0.05
#更新四个神经网络的参数
train = theano.function(
inputs = [x,y],
outputs = cost,
updates = [(L1.W, L1.W-learning_rate*gW1),
(L1.b, L1.b-learning_rate*gb1),
(L2.W, L2.W-learning_rate*gW2),
(L2.b, L2.b-learning_rate*gb2)
]
)
#(L1.W, L1.W-learnging_rate*gW1)
#(原始的权重-学习的效率*下降的幅度)更新为L1.W4.预测结果
最后是预测结果，训练时会给出x和y求cost，而预测时只给出输入x，用来做预测。最后每隔50步输出err，如果err不断减小，说明神经网络在学到东西，因为预测值与真实值误差在不断减小。
#coding:utf-8
import numpy as np
import theano.tensor as T
import theano
from theano import function
class Layer(object):
def __init__(self, inputs, in_size, out_size, activation_function=None):
#权重: 平均值为0 方差为1 行数为in_size 列数为out_size
self.W = theano.shared(np.random.normal(0,1,(in_size,out_size)))
#bias
self.b = theano.shared(np.zeros((out_size,) ) + 0.1)
#乘法加bias
self.Wx_plus_b = T.dot(inputs, self.W) + self.b #dot乘法
#激励函数
self.activation_function = activation_function
#默认为None,否则进行激活
if activation_function is None:
self.outputs = self.Wx_plus_b
else:
self.outputs = self.activation_function(self.Wx_plus_b)
#回归神经网络 Regression
#1.制造虚拟数据
import matplotlib.pyplot as plt
#Make up some fake data
x_data = np.linspace(-1,1,300)[:, np.newaxis] #300个点进行训练
noise = np.random.normal(0, 0.05, x_data.shape)
y_data = np.square(x_data) - 0.5 + noise #y = x^2 - 0.5
#一元二次散点图
plt.scatter(x_data, y_data)
plt.show()
#2.定义输入和神经元
#determine the inputs dytpe
x = T.dmatrix('x') #d代表64位float类型
y = T.dmatrix('y')
#add layers
L1 = Layer(x, 1, 10, T.nnet.relu)
L2 = Layer(L1.outputs, 10, 1, None)
#3.计算误差与梯度下降更新
#误差为预测值与真实值差别
cost = T.mean(T.square(L2.outputs - y)) #mean()求平均误差
#compute the gradients
#梯度下降，让预测值更接近真实值，误差越大，降低趋势越大
gW1, gb1, gW2, gb2 = T.grad(cost, [L1.W, L1.b, L2.W, L2.b]) #权重和bias
#apply gradient descent
#学习效率: 神经网络中learning_rate通常小于1的数字,0.05保证神经网络学习比较精细
learning_rate = 0.05
#更新四个神经网络的参数
train = theano.function(
inputs = [x,y],
outputs = cost,
updates = [(L1.W, L1.W-learning_rate*gW1),
(L1.b, L1.b-learning_rate*gb1),
(L2.W, L2.W-learning_rate*gW2),
(L2.b, L2.b-learning_rate*gb2)
]
)
#(L1.W, L1.W-learnging_rate*gW1)
#(原始的权重-学习的效率*下降的幅度)更新为L1.W
#4.预测结果
#训练时会给y求cost, 而预测输入只给出x用来做预测
predict = theano.function(inputs=[x], outputs=L2.outputs)
for i in range(1000):
#training 把x_data和y_data放到函数x、y中
err = train(x_data, y_data) #误差
#每隔50步输出err, 如果err不断减小说明神经网络在学到东西, 因为预测值与真实值误差在不断减小
if i % 50 == 0:
print(err)最后输出误差结果，可以看到在不断减小，通过不断更新权重和bias，神经网络在不断学习。
2.079139917311914
0.019342171772016286
0.010080951605219858
0.007202397774306516
0.005702041299886045
0.004946926023254156
0.004565940080184372
0.0043433009094413985
0.00421325480276665
0.0041214880336559725
0.004046461715568916
0.003989685842213987
0.003934933552824453
0.003886586291155118
0.003843283475886867
0.0038068442317786316
0.0037721487639369986
0.0037432478192238835
0.003712756532212612
0.00368813308403329三. 回归神经网络可视化
最后补充神经网络不断学习的拟合图形，从最早不合理的图形到后面基本拟合，同时cost误差也在不断减小，说明神经网络的真实值和预测值在不断更新接近，神经网络正常运行。结果如下：
图2 第一次拟合结果
图3 第二次拟合结果
图4 最后一次拟合结果
完整代码及注释如下所示：
#coding:utf-8
import numpy as np
import theano.tensor as T
import theano
from theano import function
class Layer(object):
def __init__(self, inputs, in_size, out_size, activation_function=None):
#权重: 平均值为0 方差为1 行数为in_size 列数为out_size
self.W = theano.shared(np.random.normal(0,1,(in_size,out_size)))
#bias
self.b = theano.shared(np.zeros((out_size,) ) + 0.1)
#乘法加bias
self.Wx_plus_b = T.dot(inputs, self.W) + self.b #dot乘法
#激励函数
self.activation_function = activation_function
#默认为None,否则进行激活
if activation_function is None:
self.outputs = self.Wx_plus_b
else:
self.outputs = self.activation_function(self.Wx_plus_b)
#回归神经网络 Regression
#1.制造虚拟数据
import matplotlib.pyplot as plt
#Make up some fake data
x_data = np.linspace(-1,1,300)[:, np.newaxis] #300个点进行训练
noise = np.random.normal(0, 0.05, x_data.shape)
y_data = np.square(x_data) - 0.5 + noise #y = x^2 - 0.5
#一元二次散点图
plt.scatter(x_data, y_data)
plt.show()
#2.定义输入和神经元
#determine the inputs dytpe
x = T.dmatrix('x') #d代表64位float类型
y = T.dmatrix('y')
#add layers
L1 = Layer(x, 1, 10, T.nnet.relu)
L2 = Layer(L1.outputs, 10, 1, None)
#3.计算误差与梯度下降更新
#误差为预测值与真实值差别
cost = T.mean(T.square(L2.outputs - y)) #mean()求平均误差
#compute the gradients
#梯度下降，让预测值更接近真实值，误差越大，降低趋势越大
gW1, gb1, gW2, gb2 = T.grad(cost, [L1.W, L1.b, L2.W, L2.b]) #权重和bias
#apply gradient descent
#学习效率: 神经网络中learning_rate通常小于1的数字,0.05保证神经网络学习比较精细
learning_rate = 0.05
#更新四个神经网络的参数
train = theano.function(
inputs = [x,y],
outputs = cost,
updates = [(L1.W, L1.W-learning_rate*gW1),
(L1.b, L1.b-learning_rate*gb1),
(L2.W, L2.W-learning_rate*gW2),
(L2.b, L2.b-learning_rate*gb2)
]
)
#(L1.W, L1.W-learnging_rate*gW1)
#(原始的权重-学习的效率*下降的幅度)更新为L1.W
#4.预测结果
#训练时会给y求cost, 而预测输入只给出x用来做预测
predict = theano.function(inputs=[x], outputs=L2.outputs)
#可视化分析
#plot the fake data
fig = plt.figure()
ax = fig.add_subplot(1,1,1)
ax.scatter(x_data,y_data) #散点图效果
#输入红线并且连续不断更新
plt.ion()
plt.show() #参数block=True: 只显示这张图,关掉图后才运行后面程序
#每隔50步输出err并绘制拟合曲线
#cost值不断减小说明预测值与真实值误差在不断减小,拟合直线越来越接近
for i in range(1000):
#误差: training 把x_data和y_data放到函数x、y中
err = train(x_data, y_data)
pre = predict(x_data)
#to visualize the result and improvement
#查看神经网络结果和拟合提升过程
if i % 50 == 0:
#消除红线, 否则每次的红线绘制在一起
#因为第一步没有红线, 故使用try忽略第一步
try:
ax.lines.remove(lines[0])
except Exception:
pass
predicted_value = predict(x_data)
#plot the prediction
lines = ax.plot(x_data, predicted_value, 'r-', lw=5) #x和预测y lw线宽度
plt.pause(1) #暂定1秒
#输出误差
print(err)
#print(pre)基础性文章，希望对您有所帮助，推荐大家阅读莫烦大神的学习视频，也建议大家一步步跟着学习，同时文章中存在错误或不足之处，还请海涵~
(By:Eastmount 2018-05-21 下午4点 http://blog.csdn.net/eastmount/ )
5123
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
