感知机
简单的实现单层感知机
- 定义与门：可以设置w1,w2,theta = 0.5,0.5,0.7来实现
def And(x1, x2):
w1, w2, theta = 0.5, 0.5, 0.7
temp = w1 * x1 + w2 * x2
if temp > theta:
return 1
else:
return 0
print(And(0, 0))
print(And(0, 1))
print(And(1, 0))
print(And(1, 1))
- 定义与非门:可以设置w1,w2,theta = -0.5,-0.5,-0.7来实现
- 定义或门:可以设置w1,w2,theta = 0.5,0.5,0.25来实现
用权重和偏置实现单层感知机
令 b = -theta, 在与门，与非门，或门下，b分别为-0.7，0.7，-0.25。下面以与门为例实现：
import numpy as np
def And(x1,x2):
w1, w2 = 0.5, 0.5
x = np.array([x1, x2])
w = np.array([w1, w2])
b = -0.7
temp = b + np.sum(x*w)
if temp >= 0:
return 1
else:
return 0
print(And(0, 0))
print(And(0, 1))
print(And(1, 0))
print(And(1, 1))
单层感知机的局限性
只能表示由一条直线分割而成的空间，如与门（And)、与非门(NAND)和或门(OR)，即线性空间。而无法表示由一条曲线分割成的空间，如异或门(XOR)，即非线性空间。
多层感知机
多层感知机通过And, NAND,OR的双层叠加可以实现XOR。其中x1, x2是与或门和或门的输入，s1, s2是与门的输入。
用代码检验这种表示方式的正确性：
def XOR(x1, x2):
s1 = OR(x1, x2)
s2 = NAND(x1,x2)
y = And(s1, s2)
return y
print(XOR(0, 0))
print(XOR(0, 1))
print(XOR(1, 0))
print(XOR(1, 1))
神经网络
和多层感知机的传导过程差不多。神经网络和多层感知机的主要区别在于激活函数的具体形式不同，但所有激活函数的激活函数只能是非线性函数，以此来发挥神经网络叠加层带来的优势。
阶跃函数
感知机的激活函数一般是阶跃函数。代码实现如下：
def step_function(x):
if x > 0:
return 1
else:
return 0
print(step_function(3.0))
以上的代码只能以一个浮点数作为输入，改善为能接受一组数组的阶跃函数，并绘制图形：
import numpy as np
import matplotlib.pylab as plt
def step_function(x):
y = x > 0
return y.astype(np.int_)
x = np.arange(-5, 5, 0.1)
y = step_function(x)
plt.plot(x, y)
plt.ylim(-0.1, 1.1)#指定y的范围
plt.show()
图形如下，阶跃函数以0为界限，呈现出阶梯式变化。
sigmoid函数
神经网络的激活函数一般是sigmoid函数。可以看出sigmoid函数更为平滑。
import numpy as np
import matplotlib.pylab as plt
def sigmoid(x):
return 1/(1+np.exp(-x))
x = np.arange(-5, 5, 0.1)
y = sigmoid(x)
plt.plot(x, y)
plt.ylim(-0.1, 1.1)#指定y的范围
plt.show()
ReLU函数
ReLU函数在输入大于0时，直接输出该值；在输入小于等于0时，输出0。
import numpy as np
import matplotlib.pylab as plt
def relu(x):
return np.maximum(0,x)
x = np.arange(-5, 5, 0.1)
y = relu(x)
plt.plot(x, y)
plt.ylim(-0.1, 1.1)#指定y的范围
plt.show()
数组运算
要弄清楚神经网络的内部结构，必须掌握数组运算的基本知识。
import numpy as np
#建立一维数组
A = np.array([1, 2])
#建立二维数组
B = np.array([[1, 2], [3, 4]])
#数组维度
print(np.ndim(A), np.ndim(B))
#数组各维度的数量，返回的是元组：
print(A.shape, B.shape)#等价于
print(np.shape(A), np.shape(B))
#矩阵（二维数组）乘法
C = np.array([[5, 6], [7, 8]])
print(np.dot(B, C)) #要求B的列数与C的行数相等，最后返回的是B的行数与C的列数
print(np.dot(A, C)) #A的列数与C的行数相等
数组在神经网络上的应用主要体现在，通过数组的乘积进行神经网络的运算，考虑一个只有权重的二层神经网络，如下所示，
其中x1 = 1, x2 = 2,求输出层y1, y2, y3的数值，用以下方式可以实现：
import numpy as np
X = [[1, 2]]
W = [[1, 3, 5], [2, 4, 6]]
Y = np.dot(X, W)
print(Y)
将数组在神经网络上的应用拓展到多层神经网络和有偏置的情况，考虑一个有四层神经网络的情况，包括输入层，第1层隐藏层，第2层隐藏层，输出层。
通过代码来实现这一过程。首先将每一层的权重，偏置以字典的形式保存在init_network中，然后定义一个forward函数，计算y1，y2的输出。以第一层为例子，首先通过b1, x1, x2, w11, w12以算出a1, a2, a3, 然后使用sigmoid函数作为转换函数，算出z1, z2, z3， 作为下一层的输入，如此循环，直到y1, y2。
import numpy as np
def sigmoid(x):
return 1/(1+np.exp(-x))
def init_network():
network = {}
network['W1'] = np.array([[0.1, 0.3, 0.5], [0.2, 0.4, 0.6]])
network['b1'] = np.array([0.1, 0.2, 0.3])
network['W2'] = np.array([[0.1, 0.4], [0.2, 0.5], [0.3, 0.6]])
network['b2'] = np.array([0.1, 0.2])
network['W3'] = np.array([[0.1, 0.3], [0.2, 0.4]])
network['b3'] = np.array([0.1, 0.2])
return network
def forward(network, x):
W1, W2, W3 = network['W1'], network['W2'], network['W3']
b1, b2, b3 = network['b1'], network['b2'], network['b3']
a1 = np.dot(x, W1) + b1
z1 = sigmoid(a1)
a2 = np.dot(z1, W2) + b2
z2 = sigmoid(a2)
a3 = np.dot(z2, W3) + b3
y = a3
return y
network = init_network()
x = np.array([1.0, 0.5])
y = forward(network, x)
print(y)
输出层的激活函数设计
- 恒等函数：回归问题一般使用恒等函数，即输入和输出相等，如上面这个函数的y = a3。
- sigmoid函数：二元分类问题一般使用sigmoid函数
- softmax函数：分类问题一般使用softmax函数，softmax函数的转换函数如下所示：
假设一个双层神经网络，有三个输入数值x1， x2，x3, 三个输出y1，y2，y3,使用代码实现这个softmax函数如下：
import numpy as np
def softmax(x):
return np.exp(x)/np.sum(np.exp(x))
x = np.array([0.3, 2.9, 4.0])
print(softmax(x))
但是这种方式容易出现溢出状况，当x的数字超过四位数时一般都得不到有效的输出。为了让softmax函数更加具有通用性，我们使用以下以下这个方法对函数进行转化：
这是因为指数函数的乘除运算加上或者减少一个常数，其结果是不会改变的。通常这个C’一般取最大输入信号的相反数。因此新的softmax函数为：
def softmax(x):
return np.exp(x-max(x))/np.sum(np.exp(x-max(x)))
x = np.array([990, 1000, 1010])
print(softmax(x))
可以看出，原来的softmax函数只能得出nan,nan,nan,而改进后的softmanx则会得出准确的输出。
soft函数的特征：softhmax函数输出的值在0-1之间且总和为1，因此将他解释为概率；各元素之间的大小关系并不会改变，这是因为指数函数是增函数；而且神经网络只会把最大的神经网络的值作为输出结果。
输出神经元的个数
神经网络输出的神经元的个数往往是需要分类的数量，各神经元用不同的灰度表示，灰度最深的值对应的最终的类别。
手写数字识别的实践
神经网络包括学习和推理过程，下面是手写识别的学习过程
import sys, os
sys.path.append(os.getcwd())
import numpy as np
from dataset.mnist import load_mnist
from PIL import Image
def img_show(img):
pil_img = Image.fromarray(np.uint8(img))
pil_img.show()
#load_mnist函数以“(训练图像 ,训练标签 )，(测试图像，测试标签 )”的形式返回读入的MNIST数据。
(x_train, t_train), (x_test, t_test) = load_mnist(flatten = True, normalize = False)
img = x_train[0]
label = t_train[0]
#显示图像时，需要把它变为原来的28像素 × 28像素的形状
print(img.shape)
img = img.reshape(28, 28)
print(img.shape)
像load_mnist(normalize=True, flatten=True, one_hot_label=False)，normalize是否把数值规范化到0-1之间，flatten即是否展开为一维数组，如手写数字识别中展开为（784，），one_hot_label即是否仅以正确解编码成1。
接下来是利用测试集进行测试并评估其精度，这一个神经网络包括一个输入层，一个输出层，2个隐藏层，这几层的信号传递的多维数组的元素情况为（784，）（784，50）（50，100）*（100，10），所以最后输出的是0-9之间的10个数字，而图形的数字是这里面概率最大的一个。这段代码和书上说的不一样的地方就是with open(“sample_weight.pkl”, ‘rb’) as f:里面的sample_weight.pkl其实是指sample_weight.pkl的所在路径。
# 获取测试数据
def get_data():
(x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, flatten=True, one_hot_label=False)#进行正则化处理
return x_test, t_test
# 每个层次的偏置和权重数据
def init_network():
with open("D:\Project\深度学习\【2018 斋藤康毅】《深度学习入门：基于Python的理论与实现》高清中文版PDF+源代码\【2018 斋藤康毅】《深度学习入门：基于Python的理论与实现》高清中文版PDF+源代码\《深度学习入门：基于Python的理论与实现》源代码\ch03\sample_weight.pkl", 'rb') as f:
network = pickle.load(f)
return network
# 信号传递，进行预测
def predict(network, x):
W1, W2, W3 = network['W1'], network['W2'], network['W3']
b1, b2, b3 = network['b1'], network['b2'], network['b3']
a1 = np.dot(x, W1) + b1
z1 = sigmoid(a1)
a2 = np.dot(z1, W2) + b2
z2 = sigmoid(a2)
a3 = np.dot(z2, W3) + b3
y = softmax(a3)
return y
# 评价分类准确度
x, t = get_data()
network = init_network()
accuracy_cnt = 0
for i in range(len(x)):
y = predict(network, x[i])
p = np.argmax(y) # 获取概率最高的元素的索引
if p == t[i]:
accuracy_cnt += 1
print("Accuracy:" + str(float(accuracy_cnt) / len(x)))
上面是一个一个的处理图像，这样的处理会耗费较多的时间，因此考虑批处理。下面考虑一次性输出100张图像识别的结果，并评估识别精度。这时信号传递中多维数组的元素的变动情况为（100，784）（784，50）（50，100）*（100，10）=（100，10）最后输出的是100个0-9之间的数值。
# 前面的和上面的那个一样
x, t = get_data()
network = init_network()
accuracy_cnt = 0
batch_size = 100
for i in range(0, len(x), batch_size): #形成类似[0,100,200]的数组
y_batch = predict(network, x[i:i+batch_size]) #x[i, i+batch_size]提取x中从i到i+batch_size之间的数值
p = np.argmax(y_batch, axis=1) #沿着第一维的方向提取最大值的索引
accuracy_cnt += np.sum(p == t[i:i+batch_size]) #和实际情况进行对比，计算精度
print("Accuracy:" + str(float(accuracy_cnt) / len(x)))
神经网络的学习
前面都是给定权重，现在讨论的学习则是通过训练数据自动识别最优权重的过程，这就需要导入损失函数的概念。损失函数表示模型拟合的不好的程度，神经网络以损失函数最小为目标求最优权重参数。主要的损失函数有均方误差和交叉熵误差。
均方误差
yk是神经网络的输出，tk是监督数据，表示预测数据和实际数据的差距。
代码实现如下，其中t的这种标注方法，被称为one_hot表示，即正确解表示为 1，其他的表示为0：
def mean_squared_error(y,t):
return 0.5*np.sum((y-t)**2)
y = [0.1, 0.05, 0.6, 0.0, 0.05, 0.1, 0.0, 0.1, 0.0, 0.0]
t = [0, 0, 1, 0, 0, 0, 0, 0, 0, 0]
print(mean_squared_error(np.array(y), np.array(t)))
交叉熵误差
交叉熵误差完全由正确姐对应的概率决定。
代码实现如下，代码里添加一个delta主要是防止y为0时出现负无穷大而无法计算的情况：
def cross_entroy_error(y,t):
delta = 1e-7
return -np.sum(t*np.log(y+delta))
print(cross_entroy_error(np.array(y), np.array(t)))
mini_batch学习
在进行“学习”的时候，数据可能有成千上万个，如果对这些数据全部进行训练，那么计算机耗费的时间就比较长，所以我们往往从中间挑选一小部分用于模型的训练，这个过程就叫做mini_batch学习。以mnist数据集为例，我们需要从mnist的60000条数据中随机挑选10条作为我们的训练数据，具体如下：
上面计算误差的方法都只能计算单个数据的误差。
为什么需要损失函数
为什么不用精度作为神经网络的目标呢，这是因为精度的导数在很多时候是为0的，而且是离散的变化的，这使得微小参数的变化不会引起目标的变化。
同样地，如果使用阶跃函数来作为损失函数也是不合适的。
梯度
导数的定义方法如下，h取1e-4可以避免舍入误差，即数值太小被认为是0，而返回的形式不是(f(x+h)-f(x))/h可以避免前向微分。当f只有一个变量时，求的就是导数；当f有多个变量时，求的就是偏导数。
def numeric_diff(f, x):
h = 1e-4
return (f(x+h)-f(x-h))/(2*h)
梯度则是一个函数里全部变量的偏导数汇总，指示着最大限度地使损失函数变小的方向，但指定的不一定是全局最小值。根据所求目的的不同，一般分为梯度下降法和梯度上升法，在机器学习里，经常用的是梯度下降法。当偏导为正，方向为负方向，偏导为负，方向为正方向。
给定了参数变化的方向，需要给定参数变化的大小，即学习率。这是认为给定的，太大或者太小都不会得到最优的参数，学习率过大，很容易跳过最优解，学习率过小，到达最优解的过程会很忙。
x沿着梯度的相反方向并以一定的学习率进行变化，就可以得到全局极小值。
扫一扫
605
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
