基于数值微分的反向传播
我们尝试使用基于数值微分的方式实现手写数字的识别，并且是使用mini_batch来提升计算性能，使用的优化方法是随机梯度下降法，这里需要补充一点的是：
随机指的是“随机选择数据源中的小批次”的意思，随机梯度下降法的英文名字就叫作SGD。
下面我们就来实现手写数字识别的神经网络，整体过程 相比之前的案例要复杂很多，不过不用担心，我们一步一步进行剖析，从之前学过的，易于理解的，容易实现的代码开始编写。
第一步，激活函数的定义。在前向传播上，我们主要是使用两类激活函数，ReLU和Softmax。这两个函数在之前已经详细讲解过了，在这里我们给出与其对应的Python实现代码。 激活函数ReLU的实现流程：
def _relu(in_data):
return np.maximum(0,in_data)
激活函数Softmax的实现流程：
def _softmax(x):
if x.ndim == 2:
c = np.max(x,axis=1)
x = x.T - c #溢出对策
y = np.exp(x) / np.sum(np.exp(x),axis=0)
return y.T
c = np.max(x)
exp_x = np.exp(x-c)
return exp_x / np.sum(exp_x)
第二步，损失函数以及数值微分的计算逻辑。这两个函数之前也已经详细讲解过了，在这里我们只给出相应的Python实现代码。
计算基于小批次的损失函数的损失值，其中，y代表真实值，p代表预测值。计算代码具体如下：
def cross_entropy_error(p, y):
delta = 1e-7
batch_size = p.shape[0]
return -np.sum(y * np.log(p + delta)) / batch_size
数值微分的实现逻辑如下（对于不理解nditer使用方法的读者，可以参阅之前写的“补充概念：Np.nditer”的相关内容）：
def numerical_gradient(f, x):
h = 1e-4 # 0.0001
grad = np.zeros_like(x)
it = np.nditer(x, flags=['multi_index'], op_flags=['readwrite'])
while not it.finished:
idx = it.multi_index
tmp_val = x[idx]
x[idx] = float(tmp_val) + h
fxh1 = f(x) # f(x+h)
x[idx] = tmp_val - h
fxh2 = f(x) # f(x-h)
grad[idx] = (fxh1 - fxh2) / (2*h)
x[idx] = tmp_val #还原值
it.iternext()return grad
第三步，定义神经网络。 我们先来看下初始化类的代码，首先在类TwoLayerNet中定义第一个初始化函数，函数接受4个参数：
input_size代表输入的神经元个数；hidden_size代表隐藏层神经元的个数；output_size代表输出层神经元的个数；
最后的weight_init_std则是为了防止权重太大，其默认值为0.01。
那么对于手写数字识别MNIST 来说：input_size的值就可以设置为784，原因是28*28=784；而output_size则可以设置为10，因为其是一个10分类的问题（对应于数字0～9）；对于hidden_size的设置则可以根据经验自行设置。
params是一个字典，里面存储的是权重以及偏移量的值，W1的形状是(input_size，hidden_size)，W2的形状是(hidden_size，output_size)，具体代码如下：
def __init__(self, input_size,
hidden_size, output_size, weight_init_std=0.01):#初始化权重
self.params = {}
self.params['W1'] = weight_init_std * np.random.randn(input_size, hidden_size)
self.params['b1'] = np.zeros(hidden_size)
self.params['W2'] = weight_init_std * np.random.randn(hidden_size, output_size)
self.params['b2'] = np.zeros(output_size)
接着我们来实现对应于这个TwoLayerNet类中的前向传播算法：前向传播的实现方式已在本章的前向传播中重点阐述过，其核心思想就是通过矩阵运算计算出结果，再通过激活函数丰富其“表达能力”，最后通过_softmax函数计算概率输出结果。
实现代码具体如下：
def predict(self, x):
W1, W2 = self.params['W1'], self.params['W2']
b1, b2 = self.params['b1'], self.params['b2']
a1 = np.dot(x, W1) + b1
z1 = _relu(a1)
a2 = np.dot(z1, W2) + b2
p = _softmax(a2)
return p
接着，我们再来看下如何计算损失值。下面这段代码还是比较容易理解的，对于预测值来说，其结果就是通过前向传播计算得到的，然后调用函数cross_entropy_error，得到损失函数的损失值Loss，我们的目标就是使Loss不断减少，具体代码如下：
# x:输入数据, y:监督数据
def loss(self, x, y):
p = self.predict(x)
return cross_entropy_error(p, y)
接着，我们来看下如何实现梯度下降。值得注意的一点 是，参数W是一个伪参数，另外因为名字重复问题，numerical_gradient函数与类中的numerical_gradient重名了，类中该函数调用的是我们之前实现的数值微分的函数，而非类函数自调用。
实现代码具体如下：
# x:输入数据, y:监督数据
def numerical_gradient(self, x, y):
loss_W = lambda W: self.loss(x, y)grads = {}
grads['W1'] = numerical_gradient(loss_W, self.params['W1'])
grads['b1'] = numerical_gradient(loss_W, self.params['b1'])
grads['W2'] = numerical_gradient(loss_W, self.params['W2'])
grads['b2'] = numerical_gradient(loss_W, self.params['b2'])
return grads
最后，我们来实现准确度 函数。这个实现方式比较简单，对于p来说就是预测值的矩阵，我们取每一行的最大值的索引与真实值中每一行最大值的索引，如果两者的值相同，则说明预测准确。
实现代码具体如下：
def accuracy(self, x, t):
p= self.predict(x)
p = np.argmax(y, axis=1)
y = np.argmax(t, axis=1)
accuracy = np.sum(p == y) / float(x.shape[0])
return accuracy
第四步，查看损失值。 首先，我们通过PyTorch导入MNIST数据源，这部分代码在此就不再赘述了。
接着，我们需要定义训练集和测试集。值得注意的是，通过PyTorch导入的标签并不是one-hot encoding格式，而是需要我们通过代码自行转换，转换逻辑之前已经给出，实现代码具体如下：
x_train = train_dataset.train_data.numpy().reshape(-1,28*28)
y_train_tmp = train_dataset.train_labels.reshape(train_dataset.train_labels.shape[0],1)
y_train = torch.zeros(y_train_tmp.shape[0], 10).scatter_(1, y_train_tmp, 1).numpy()
x_test = test_dataset.test_data.numpy().reshape(-1,28*28)
y_test_tmp = test_dataset.test_labels.reshape(test_dataset.test_labels.shape[0],1)
y_test = torch.zeros(y_test_tmp.shape[0], 10).scatter_(1, y_test_tmp, 1).numpy()
下面我们来初始化手写的神经网络以及一些超参数然后输出Loss。如果我们观察到Loss值在不断下降，则说明我们的代码是有效的！值得注意的一点是，下述程序中使用的np.random.choice函数是随机选择一个批次的数据的，因此可能会选择到与之前批次重复的数据！实现代码具体如下：
#超参数
iters_num = 1000 #适当设定循环的次数
train_size = x_train.shape[0]
batch_size = 100
learning_rate = 0.001
network = TwoLayerNet(input_size = 784,hidden_size=50,output_size=10)
for i in range(iters_num):
batch_mask =np.random.choice(train_size,batch_size)
x_batch = x_train[batch_mask]
y_batch = y_train[batch_mask]
grad = network.numerical_gradient(x_batch,y_batch)
for key in ('W1','b1','W2','b2'):
network.params[key] -= learning_rate*grad[key]#记录学习过程
loss = network.loss(x_batch,y_batch)
if i % 100 == 0:
print(loss)
通过Loss的观察，经过1000次的迭代，从原来的约等于13降低到约等于2。我们可以更进一步地通过调用print(network.accuracy(x_test，y_test))
来观察一下此时的手写数字识别的准确率，我随机运行了几次，准确率大概是在75%。
