ML–神经网络
主要涉及的知识点有：
- 神经网络的前世今生
- 神经网络的原理和非线性矫正
- 神经网络的模型参数调节
- 使用神经网络训练手写数字识别模型
一.神经网络的前世今生
其实神经网络并不是什么新鲜事物了，早在1943年，美国神经解剖家沃伦.麦克洛奇(Warren McCulloch)和数学家沃尔特.皮茨(Walter Pitts)就提出了第一个脑神经元的抽象模型，被称为M-P模型(McCulloch-Pitts neuron,MCP)
1.神经网络的起源
神经元是大脑中相互连接的神经细胞，它可以处理和传递化学和电信号。有意思的是，神经元具有两种常规工作状态：兴畚和抑制，这和计算机中的"1"和"0"原理几乎完全一样。所以将神经元描述为一个具备二进制输出的逻辑门：当传入的神经冲动使细胞膜电位升高超过阈值时，细胞进入兴畚状态，产生神经冲动并由轴突输出；反之当传入的冲动使细胞膜电位下降低于阈值时，细胞进入抑制状态，便没有神经冲动输出
2.神经网络之父–杰弗瑞.欣顿
杰弗瑞.欣顿等人提出了反向传播算法(Back propagation,BP)，解决了两层神经网络所需要的复杂计算问题，重新带动业界的热潮
二.神经网络的原理及使用
1.神经网络中的非线性矫正
从数学的角度来说，如果每一个隐藏层只是进行加权求和，得到的结果和普通的线性模型不会有什么不同。所以为了让模型能够比普通线性模型更强大一些，我们还需要进行一点处理
这种处理方法是：在生成隐藏层之后，我们要对结果进行非线性矫正(rectifying nonlinearity)，简称为relu(rectified linear unit)或者是进行双曲正切处理(tangens hyperbolicus)，简称为tanh。我们用图像来进行直观展示
# 导入numpy
import numpy as np
# 导入画图工具
import matplotlib.pyplot as plt
# 生成一个等差数列
line=np.linspace(-5,5,200)
# 画出非线性矫正的图形表示
plt.plot(line,np.tanh(line),label='tanh')
plt.plot(line,np.maximum(line,0),label='relu')
# 设置图注位置
plt.legend(loc='best')
plt.xlabel('x')
plt.ylabel('relu(x) and tanh(x)')
plt.show()
[结果分析] tanh函数把特征x的值压缩进-1到1的区间内，-1代表的是x中较小的数值，而1代表x中较大的数值。relu函数则索性把小于0的x值全部去掉，用0来代替。这两种非线性处理的方法，都是为了将样本特征进行简化，从而使神经网络可以对复杂的非线性数据集进行学习
2.神经网络的参数设置
# 导入MLP神经网络
from sklearn.neural_network import MLPClassifier
# 导入红酒数据集
from sklearn.datasets import load_wine
# 导入数据集拆分工具
from sklearn.model_selection import train_test_split
wine=load_wine()
X=wine.data[:,:2]
y=wine.target
# 拆分数据集
X_train,X_test,y_train,y_test=train_test_split(X,y,random_state=0)
# 定义分类器
mlp=MLPClassifier(solver='lbfgs')
mlp.fit(X_train,y_train)
MLPClassifier(activation='relu', alpha=0.0001, batch_size='auto', beta_1=0.9,
beta_2=0.999, early_stopping=False, epsilon=1e-08,
hidden_layer_sizes=(100,), learning_rate='constant',
learning_rate_init=0.001, max_iter=200, momentum=0.9,
n_iter_no_change=10, nesterovs_momentum=True, power_t=0.5,
random_state=None, shuffle=True, solver='lbfgs', tol=0.0001,
validation_fraction=0.1, verbose=False, warm_start=False)
下面我们重点看一下各个参数的含义：
alpha值和线性模型的alpha值是一样的，是一个L2惩罚项，用来控制正则化的程度，默认的数值是0.0001
hidden_layer,sizes参数，默认情况下，hidden_layer_sizes的值是[100,]，这意味着模型中只有一个隐藏层，而隐藏层中的节点数是100.如果我们给hidden_layer_sizes定义为[10,10]，那就意味着模型中有两个隐藏层，每层有10个节点
# 导入画图工具
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
# 使用不同色块表示不同分类
cmap_light=ListedColormap(['#FFAAAA','#AAFFAA','#AAAAFF'])
cmap_bold=ListedColormap(['#FF0000','#00FF00','#0000FF'])
x_min,x_max=X_train[:,0].min()-1,X_train[:,0].max()+1
y_min,y_max=X_train[:,1].min()-1,X_train[:,1].max()+1
xx,yy=np.meshgrid(np.arange(x_min,x_max,.02),np.arange(y_min,y_max,.02))
Z=mlp.predict(np.c_[xx.ravel(),yy.ravel()])
Z=Z.reshape(xx.shape)
plt.figure()
plt.pcolormesh(xx,yy,Z,cmap=cmap_light)
# 将数据特征用散点图表示出来
plt.scatter(X[:,0],X[:,1],c=y,edgecolor='k',s=60)
plt.xlim(xx.min(),xx.max())
plt.ylim(yy.min(),yy.max())
plt.title('MLPClassifier:solver=lbfgs')
plt.show()
下面我们试试吧隐藏层的节点数变少，如减少至10个，看会发生什么
# 设定隐藏层中的节点数为10
mlp_10=MLPClassifier(solver='lbfgs',hidden_layer_sizes=[10])
mlp_10.fit(X_train,y_train)
Z10=mlp_10.predict(np.c_[xx.ravel(),yy.ravel()])
Z10=Z10.reshape(xx.shape)
plt.figure()
plt.pcolormesh(xx,yy,Z10,cmap=cmap_light)
# 使用散点图画出X
plt.scatter(X[:,0],X[:,1],c=y,edgecolor='k',s=60)
plt.xlim(xx.min(),xx.max())
plt.ylim(yy.min(),yy.max())
plt.title("MLPClassifier:nodes=10")
plt.show()
[结果分析] 在每一个隐藏层当中，节点数就代表了决定边界中最大的直线数，这个数值越大，则决定边界看起来越平滑。当然，除了增加单个隐藏层中的节点数之外，还有两种方法可以让边界看起来更细腻：一个是增加隐藏层的数量；另一个是把activation参数改为tanh
现在我们试着给MLP分类器增加隐藏层数量，如增加到2层
# 设置神经网络有两个节点数为10的隐藏层
mlp_2L=MLPClassifier(solver='lbfgs',hidden_layer_sizes=[10,10])
mlp_2L.fit(X_train,y_train)
Z2L=mlp_2L.predict(np.c_[xx.ravel(),yy.ravel()])
Z2L=Z2L.reshape(xx.shape)
plt.figure()
plt.pcolormesh(xx,yy,Z2L,cmap=cmap_light)
# 使用散点图画出X
plt.scatter(X[:,0],X[:,1],c=y,edgecolor='k',s=60)
plt.xlim(xx.min(),xx.max())
plt.ylim(yy.min(),yy.max())
plt.title("MLPClassifier:layers=2")
plt.show()
下面使用activation=tanh实验一下
# 设置激活函数为tanh
mlp_tanh=MLPClassifier(solver='lbfgs',hidden_layer_sizes=[10,10],activation='tanh')
mlp_tanh.fit(X_train,y_train)
Z2=mlp_tanh.predict(np.c_[xx.ravel(),yy.ravel()])
Z2=Z2.reshape(xx.shape)
plt.figure()
plt.pcolormesh(xx,yy,Z2,cmap=cmap_light)
# 使用散点图画出X
plt.scatter(X[:,0],X[:,1],c=y,edgecolor='k',s=60)
plt.xlim(xx.min(),xx.max())
plt.ylim(yy.min(),yy.max())
plt.title("MLPClassifier:layers=2 with tanh")
plt.show()
调节alpha值来进行模型复杂度控制
# 修改模型的alpha参数
mlp_alpha=MLPClassifier(solver='lbfgs',hidden_layer_sizes=[10,10],activation='tanh',alpha=1)
mlp_alpha.fit(X_train,y_train)
Z3=mlp_alpha.predict(np.c_[xx.ravel(),yy.ravel()])
Z3=Z3.reshape(xx.shape)
plt.figure()
plt.pcolormesh(xx,yy,Z3,cmap=cmap_light)
# 使用散点图画出X
plt.scatter(X[:,0],X[:,1],c=y,edgecolor='k',s=60)
plt.xlim(xx.min(),xx.max())
plt.ylim(yy.min(),yy.max())
plt.title("MLPClassifier:alpha=1")
plt.show()
到目前为止，我么有四种方法可以调节模型的复杂程度了，第1种是跳转神经网络每一个隐藏层上的节点数，第2种是调节神经网络隐藏层的层数，第3种是调节activation的方式，第4种是通过调整alpha值来改变模型正则化的程度
[注意] 由于神经网络算法中，样本特征的权重是在模型开始学习之前，就已经随机生成了。而随机生成的权重会导致模型的形态也完全不一样。所以如果我们不指定random_state的话，即便模型所有的参数都是相同的，生成的决定边界也不一样。所以如果重新运行我们之前的代码，，也会得到不同的结果。不过不用担心，只要模型的复杂度不变，其预测结果的准确率不会受什么影响
三.神经网络实例–手写识别
在神经网络的学习中，使用MNIST数据集训练图像识别，就如同程序员刚入门时要写"hello world"一样，是非常基础的必修课
1.使用MNIST数据集
MNIST数据集是一个专门用来训练各种图形处理系统的庞大数据集，它包含70000个手写数字图像，其中60000个是训练数据，另外10000个是测试数据。而在机器学习领域，该数据集也被广泛用于模型的训练和测试。MNIST数据集实际上是从NIST原始数据集中提取的，其训练集和测试集有一半是来自NIST数据集的训练集，而另一半是来自NIST的测试集
接下来我们就用scikit-learn的fetch_mldata来获取MNIST数据集，输入代码如下：
# 导入数据集获取工具
from sklearn.datasets import fetch_mldata
# 加载MNIST手写数字数据集
mnist=fetch_mldata('MNIST original')
mnist
E:\Anaconda\envs\mytensorflow\lib\site-packages\sklearn\utils\deprecation.py:77: DeprecationWarning: Function fetch_mldata is deprecated; fetch_mldata was deprecated in version 0.20 and will be removed in version 0.22
warnings.warn(msg, category=DeprecationWarning)
E:\Anaconda\envs\mytensorflow\lib\site-packages\sklearn\utils\deprecation.py:77: DeprecationWarning: Function mldata_filename is deprecated; mldata_filename was deprecated in version 0.20 and will be removed in version 0.22
warnings.warn(msg, category=DeprecationWarning)
---------------------------------------------------------------------------
TimeoutError Traceback (most recent call last)
<ipython-input-25-c42d12ebe31a> in <module>()
3
4 # 加载MNIST手写数字数据集
----> 5 mnist=fetch_mldata('MNIST original')
6 mnist
E:\Anaconda\envs\mytensorflow\lib\site-packages\sklearn\utils\deprecation.py in wrapped(*args, **kwargs)
76 def wrapped(*args, **kwargs):
77 warnings.warn(msg, category=DeprecationWarning)
---> 78 return fun(*args, **kwargs)
79
80 wrapped.__doc__ = self._update_doc(wrapped.__doc__)
E:\Anaconda\envs\mytensorflow\lib\site-packages\sklearn\datasets\mldata.py in fetch_mldata(dataname, target_name, data_name, transpose_data, data_home)
131 urlname = MLDATA_BASE_URL % quote(dataname)
132 try:
--> 133 mldata_url = urlopen(urlname)
134 except HTTPError as e:
135 if e.code == 404:
E:\Anaconda\envs\mytensorflow\lib\urllib\request.py in urlopen(url, data, timeout, cafile, capath, cadefault, context)
221 else:
222 opener = _opener
--> 223 return opener.open(url, data, timeout)
224
225 def install_opener(opener):
E:\Anaconda\envs\mytensorflow\lib\urllib\request.py in open(self, fullurl, data, timeout)
524 req = meth(req)
525
--> 526 response = self._open(req, data)
527
528 # post-process response
E:\Anaconda\envs\mytensorflow\lib\urllib\request.py in _open(self, req, data)
542 protocol = req.type
543 result = self._call_chain(self.handle_open, protocol, protocol +
--> 544 '_open', req)
545 if result:
546 return result
E:\Anaconda\envs\mytensorflow\lib\urllib\request.py in _call_chain(self, chain, kind, meth_name, *args)
502 for handler in handlers:
503 func = getattr(handler, meth_name)
--> 504 result = func(*args)
505 if result is not None:
506 return result
E:\Anaconda\envs\mytensorflow\lib\urllib\request.py in http_open(self, req)
1344
1345 def http_open(self, req):
-> 1346 return self.do_open(http.client.HTTPConnection, req)
1347
1348 http_request = AbstractHTTPHandler.do_request_
E:\Anaconda\envs\mytensorflow\lib\urllib\request.py in do_open(self, http_class, req, **http_conn_args)
1319 except OSError as err: # timeout error
1320 raise URLError(err)
-> 1321 r = h.getresponse()
1322 except:
1323 h.close()
E:\Anaconda\envs\mytensorflow\lib\http\client.py in getresponse(self)
1329 try:
1330 try:
-> 1331 response.begin()
1332 except ConnectionError:
1333 self.close()
E:\Anaconda\envs\mytensorflow\lib\http\client.py in begin(self)
295 # read until we get a non-100 response
296 while True:
--> 297 version, status, reason = self._read_status()
298 if status != CONTINUE:
299 break
E:\Anaconda\envs\mytensorflow\lib\http\client.py in _read_status(self)
256
257 def _read_status(self):
--> 258 line = str(self.fp.readline(_MAXLINE + 1), "iso-8859-1")
259 if len(line) > _MAXLINE:
260 raise LineTooLong("status line")
E:\Anaconda\envs\mytensorflow\lib\socket.py in readinto(self, b)
584 while True:
585 try:
--> 586 return self._sock.recv_into(b)
587 except timeout:
588 self._timeout_occurred = True
TimeoutError: [WinError 10060] 由于连接方在一段时间后没有正确答复或连接的主机没有反应，连接尝试失败。
使用fetch_mldata加载MNIST数据集时，可以出现下列错误，可以参考：参考文档
重新运行代码如下：
# 导入数据集获取工具
from sklearn.datasets import fetch_mldata
# 加载MNIST手写数字数据集
mnist=fetch_mldata('MNIST original')
mnist
{'COL_NAMES': ['label', 'data'],
'DESCR': 'mldata.org dataset: mnist-original',
'data': array([[0, 0, 0, ..., 0, 0, 0],
[0, 0, 0, ..., 0, 0, 0],
[0, 0, 0, ..., 0, 0, 0],
...,
[0, 0, 0, ..., 0, 0, 0],
[0, 0, 0, ..., 0, 0, 0],
[0, 0, 0, ..., 0, 0, 0]], dtype=uint8),
'target': array([ 0., 0., 0., ..., 9., 9., 9.])}
print("样本数量：{},样本特征数：{}".format(mnist.data.shape[0],mnist.data.shape[1]))
样本数量：70000,样本特征数：784
[结果分析] 数据集中有70000个样本，每个样本有784个特征。这是因为，数据集中存储的样本是28x28像素的手写数字图片的像素信息，因此特征数为28x28=784个
在开始训练MLP神经网络之前，我们还需要将数据进行一些预处理，由于样本特征是从0–255的灰度值，为了让特征的数值更利于建模，我们把特征向量的值全部除以255，这样全部数值就会在0和1之间，再用我们熟悉的train_test_split函数将数据集分为训练集和测试集
# 建立训练数据集和测试数据集
X=mnist.data/255.
y=mnist.target
X_train,X_test,y_train,y_test=train_test_split(X,y,train_size=5000,test_size=1000,random_state=62)
为了控制神经网络的训练时长，我们只选5000个样本作为训练数据集，选取1000个数据作为测试数据集。同时为了每次选取的数据保持一致，我们指定random_state为62
2.训练MLP神经网络
# 设置神经网络有两个100个节点的隐藏层
mlp_hw=MLPClassifier(solver='lbfgs',hidden_layer_sizes=[100,100],activation='relu',alpha=1e-5,random_state=62)
# 使用数据训练神经网络模型
mlp_hw.fit(X_train,y_train)
print('测试数据集得分：{:.2f}%'.format(mlp_hw.score(X_test,y_test)*100))
测试数据集得分：93.60%
3.使用模型进行数字识别
注意 因为图像是28x28像素，所以放大后看起来会不够清晰
# 导入图像处理工具
from PIL import Image
# 打开图像
image=Image.open('8.png').convert('F')
# 调整图像的大小
image=image.resize((28,28))
arr=[]
# 将图像中的像素作为预测数据点的特征
for i in range(28):
for j in range(28):
pixel=1.0-float(image.getpixel((j,i)))/255.
arr.append(pixel)
# 由于只有一个样本,所以需要进行reshape操作
arr1=np.array(arr).reshape(1,-1)
# 进行图像识别
print("图片中的数字是：{:.0f}".format(mlp_hw.predict(arr1)[0]))
图片中的数字是：8
Image.convert功能将图片转化为32位浮点灰色图像，也就是说它的每个像素用32个bit来表示，0代表黑，255代表白。而后将每个像素的数值都进行除以255的处理，以保持和数据集一致
扫一扫
662
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
