校园网站html模板,自己创建公众号免费吗,佛山建网站的公司,wordpress博客 免费下载文章目录 1.从数据中学习1#xff09;数据驱动2#xff09;训练数据和测试数据 2.损失函数1)均方误差2)交叉熵误差3)mini-batch学习 3.数值微分1#xff09;概念2#xff09;数值微分实现 4.梯度1#xff09;实现2#xff09;梯度法3#xff09;梯度法实现4#xff09;… 文章目录 1.从数据中学习1数据驱动2训练数据和测试数据 2.损失函数1)均方误差2)交叉熵误差3)mini-batch学习 3.数值微分1概念2数值微分实现 4.梯度1实现2梯度法3梯度法实现4神经网络的梯度5实现神经网络的梯度 5.学习算法的实现1神经网络的学习步骤2两层神经网络的类实现3mini-batch的实现4小结 这里所说的“学习”是指从训练数据中自动获取最优权重参数的过程。为了使神经网络能进行学习将导入
损失函数这一指标。而学习的目的就是以该损失函数为基准找出能使它的值达到最小的权重参数。为了找出尽可能小的损失函数的值利用了
函数斜率的梯度法。 本章内容
• 机器学习中使用的数据集分为训练数据和测试数据。 • 神经网络用训练数据进行学习并用测试数据评价学习到的模型的泛化能力。 • 神经网络的学习以损失函数为指标更新权重参数以使损失函数的值减小。 • 利用某个给定的微小值的差分求导数的过程称为数值微分。 • 利用数值微分可以计算权重参数的梯度。 • 数值微分虽然费时间但是实现起来很简单。下一章中要实现的稍微复杂一些的误差反向传播法可以高速地计算梯度。
1.从数据中学习
神经网络的特征就是可以从数据中学习。所谓“从数据中学习”是指可以由数据自动决定权重参数的值。
1数据驱动
数据是机器学习的命根子。
比如识别5。一种方案是先从图像中提取特征量再用机器学习技术学习这些特征量的模式。这里所说的“特征量”是指可以从输入数据输入图像中准确地提取本质数据重要的数据的转换器。
图像的特征量通常表示为向量的形式。在计算机视觉领域常用的特征量包括SIFT、SURF 和 HOG 等。使用这些特征量将图像数据转换为向量然后对转换后的向量使用机器学习中的SVM、KNN等分类器进行学习。
机器学习的方法中由机器从收集到的数据中找出规律性。与从零开始想出算法相比这种方法可以更高效地解决问题也能减轻人的负担。但是需要注意的是将图像转换为向量时使用的特征量仍是由人设计的。
神经网络直接学习图像本身。该方法不存在人为介入。图像中包含的重要特征量都是由机器来学习的。
三种方案比较 神经网络的优点是对所有的问题都可以用同样的流程来解决。比如不管要求解的问题是识别5还是识别狗抑或是识别人脸神经网络都是通过不断地学习所提供的数据尝试发现待求解的问题的模式。也就是说与待处理的问题无关神经网络可以将数据直接作为原始数据进行“端对端”的学习。
2训练数据和测试数据
机器学习中一般将数据分为训练数据和测试数据两部分来进行学习和实验等**。首先使用训练数据进行学习寻找最优的参数然后使用测试数据评价训练得到的模型的实际能力。**另外训练数据也可以称为监督数据。
泛化能力是指处理未被观察过的数据不包含在训练数据中的数据的能力。获得泛化能力是机器学习的最终目标。
因此仅仅用一个数据集去学习和评价参数是无法进行正确评价的。这样会导致可以顺利地处理某个数据集但无法处理其他数据集的情况。顺便说一下只对某个数据集过度拟合的状态称为过拟合over fitting。避免过拟合也是机器学习的一个重要课题。
2.损失函数
神经网络的学习通过某个指标表示现在的状 k 3 k^3 k3态。然后以这个指标为基准寻找最优权重参数。神经网络的学习中所用的指标称为损失函数loss function。这个损失函数可以使用任意函数但一般用均方误差和交叉熵误差等。
损失函数是表示神经网络性能的“恶劣程度”的指标即当前的神经网络对监督数据在多大程度上不拟合在多大程度上不一致。“使性能的恶劣程度达到最小”和“使性能的优良程度达到最大”是等价的,y^2
1)均方误差
可以用作损失函数的函数有很多其中最有名的是均方误差mean squared error。均方误差如下式所示。 这里y k {_k} k是表示神经网络的输出 t k t_k tk表示监督数据k表示数据的维数。
2)交叉熵误差
除了均方误差之外交叉熵误差cross entropy error也经常被用作损失函数。交叉熵误差如下式所示。 这里log表示以e为底数的自然对数loge。 y k y_k yk是神经网络的输出 t k t_k tk是正确解标签。并且 t k t_k tk中只有正确解标签的索引为1其他均为0one-hot表示。 因此实际上只计算对应正确解标签的输出的自然对数。
3)mini-batch学习
机器学习使用训练数据进行学习。使用训练数据进行学习严格来说就是针对训练数据计算损失函数的值找出使该值尽可能小的参数。因此计算损失函数时必须将所有的训练数据作为对象。也就是说如果训练数据有100个的话我们就要把这100个损失函数的总和作为学习的指标。前面介绍的损失函数的例子中考虑的都是针对单个数据的损失函数。如果要求所有训练数据的损失函数的总和以交叉熵误差为例可以写成下面的式
这里,假设数据有N个 t n k t_{nk} tnk表示第n个数据的第k个元素的值( y n k y_{nk} ynk是神经网络的输出 t n k t_{nk} tnk是监督数据。式子虽然看起来有一些复杂其实只是把求单个数据的损失函数的式扩大到了N份数据不过最后还要除以N进行正规化。通过除以N可以求单个数据的“平均损失函数”。通过这样的平均化可以获得和训练数据的数量无关的统一指标。比如即便训练数据有1000个或10000个也可以求得单个数据的平均损失函数。
3.数值微分
所谓数值微分就是用数值方法近似求解函数的导数的过程。
1概念
计算函数f在(x h)和(x−h) 之间的差分。因为这种计算方法以 x 为中心计算它左右两边的差分所以也称为中心差分而(x h)和x之间的差分称为前向差分。
利用微小的差分求导数的过程称为数值微分。基于数学式的推导求导数的过程则用“解析性”analytic一词称为“解析性求解”或者“解析性求导”。
2数值微分实现
# coding: utf-8
import numpy as np
import matplotlib.pylab as pltdef numerical_diff(f, x):#差分h 1e-4 # 0.0001return (f(xh) - f(x-h)) / (2*h)def function_1(x):return 0.01*x**2 0.1*x def tangent_line(f, x):d numerical_diff(f, x)print(d)y f(x) - d*xreturn lambda t: d*t yx np.arange(0.0, 20.0, 0.1)
y function_1(x)
plt.xlabel(x)
plt.ylabel(f(x))
#求function_1函数在x5的表达式即为切线
tf tangent_line(function_1, 5)
y2 tf(x)plt.plot(x, y)
plt.plot(x, y2)
plt.show()4.梯度
由全部变量的偏导数汇总而成的向量称为梯度gradient。梯度指示的方向是各点处的函数值减小最多的方向
1实现
# coding: utf-8
# cf.http://d.hatena.ne.jp/white_wheels/20100327/p3
import numpy as np
import matplotlib.pylab as plt
from mpl_toolkits.mplot3d import Axes3Ddef _numerical_gradient_no_batch(f, x):h 1e-4 # 0.0001grad np.zeros_like(x)for idx in range(x.size):tmp_val x[idx]x[idx] float(tmp_val) hfxh1 f(x) # f(xh)x[idx] tmp_val - h fxh2 f(x) # f(x-h)grad[idx] (fxh1 - fxh2) / (2*h)x[idx] tmp_val # 还原值return graddef numerical_gradient(f, X):if X.ndim 1:return _numerical_gradient_no_batch(f, X)else:grad np.zeros_like(X)for idx, x in enumerate(X):grad[idx] _numerical_gradient_no_batch(f, x)return graddef function_2(x):if x.ndim 1:return np.sum(x**2)else:return np.sum(x**2, axis1)def tangent_line(f, x):d numerical_gradient(f, x)print(d)y f(x) - d*xreturn lambda t: d*t yif __name__ __main__:x0 np.arange(-2, 2.5, 0.25)x1 np.arange(-2, 2.5, 0.25)X, Y np.meshgrid(x0, x1)X X.flatten()Y Y.flatten()grad numerical_gradient(function_2, np.array([X, Y]) )plt.figure()plt.quiver(X, Y, -grad[0], -grad[1], anglesxy,color#666666)#,headwidth10,scale40,color#444444)plt.xlim([-2, 2])plt.ylim([-2, 2])plt.xlabel(x0)plt.ylabel(x1)# plt.grid()# plt.legend()plt.draw()plt.show()运行结果
结果表明梯度指向函数f(x0,x1) 的“最低处”最小值离“最低处”越远箭头越大。
实际上梯度会指向各点处的函数值降低的方向。更严格地讲梯度指示的方向是各点处的函数值减小最多的方向。
quiver方法说明
作用绘制向量场
quiver([X, Y], U, V, [C], **kw) 其中 X, Y 定义了箭头的位置, U, V 定义了箭头的方向, C 作为可选参数用来设置颜色。 下面是几个常见的参数
units 此参数指示了除箭头长度外其他尺寸的变化趋势以该单位的倍数测量。可取值为 {‘width’, ‘height’, ‘dots’, ‘inches’, ‘x’, ‘y’ ‘xy’}, 默认是 ‘width’。需要配合 scale 参数使用。
scale: float, optional。此参数是每个箭头长度单位的数据单位数通常该值越小意味着箭头越长默认为 None ,此时系统会采用自动缩放算法。箭头长度单位由 scale_units 参数指定。
scale_units: 此参数是可选参数其中包含以下值{‘width’, ‘height’, ‘dots’, ‘inches’, ‘x’, ‘y’, ‘xy’}, 一般当 scaleNone 时该选项指示长度单位默认为 None。
angles: 此参数指定了确定箭头角度的方法可以取 {‘uv’, ‘xy’} 或者 array-like, 默认是 ‘uv’ 。 设计原因是 因为图的宽和高可能不同所以 x 方向的单位长度和 y 方向的单位长度可能不同这时我们需要做出选择一是不管长度对不对角度一定要对此时 angles‘uv’二是不管角度了只要长度对就可以了此时 angles‘xy’。当该值为一个 array 的时候该数组应该是以度数为单位的数组表示了每一个箭头的方向如下所示
2梯度法
机器学习的主要任务是在学习时寻找最优参数。
同样地神经网络也必须在学习时找到最优参数权重和偏置。这里所说的最优参数是指损失函数取最小值时的参数。但是一般而言损失函数很复杂参数空间庞大我们不知道它在何处能取得最小值。而通过巧妙地使用梯度来寻找函数最小值或者尽可能小的值的方法就是梯度法。
函数的极小值、最小值以及被称为鞍点saddle point的地方梯度为0。极小值是局部最小值也就是限定在某个范围内的最小值。鞍点是从某个方向上看是极大值从另一个方向上看则是极小值的点。虽然梯度法是要寻找梯度为0的地方但是那个地方不一定就是最小值也有可能是极小值或者鞍点。此外当函数很复杂且呈扁平状时学习可能会进入一个几乎平坦的地区陷入被称为“学习高原”的无法前进的停滞期。
在梯度法中函数的取值从当前位置沿着梯度方向前进一定距离然后在新的地方重新求梯度再沿着新梯度方向前进如此反复不断地沿梯度方向前进。像这样通过不断地沿梯度方向前进逐渐减小函数值的过程就是梯度法gradient method。梯度法是解决机器学习中最优化问题的常用方法特别是在神经网络的学习中经常被使用。
η表示更新量在神经网络的学习中称为学习率。学习率决定在一次学习中应该学习多少以及在多大程度上更新参数。
上述式子是表示更新一次的式子这个步骤会反复执行。
学习率需要事先确定为某个值比如0.01或0.001。一般而言这个值过大或过小都无法抵达一个“好的位置”。在神经网络的学习中一般会一边改变学习率的值一边确认学习是否正确进行了。
3梯度法实现
# coding: utf-8
import numpy as np
import matplotlib.pylab as plt
from gradient_2d import numerical_gradient#参数f是要进行最优化的函数init_x是初始值lr是学习率learning ratestep_num 是梯度法的重复次数。
#使用这个函数可以求函数的极小值顺利的话还可以求函数的最小值。
def gradient_descent(f, init_x, lr0.01, step_num100):x init_xx_history []for i in range(step_num):x_history.append( x.copy() )#numerical_gradient(f,x) 会求函数的梯度用该梯度乘以学习率得到的值进行更新操作由step_num指定重复的次数。grad numerical_gradient(f, x)x - lr * gradreturn x, np.array(x_history)def function_2(x):return x[0]**2 x[1]**2init_x np.array([-3.0, 4.0]) lr 0.1
step_num 20
x, x_history gradient_descent(function_2, init_x, lrlr, step_numstep_num)plt.plot( [-5, 5], [0,0], --b)
plt.plot( [0,0], [-5, 5], --b)
plt.plot(x_history[:,0], x_history[:,1], o)plt.xlim(-3.5, 3.5)
plt.ylim(-4.5, 4.5)
plt.xlabel(X0)
plt.ylabel(X1)
plt.show()
实验结果表明学习率过大的话会发散成一个很大的值反过来学习率过小的话基本上没怎么更新就结束了。也就是说设定合适的学习率是一个很重要的问题。
像学习率这样的参数称为超参数。这是一种和神经网络的参数权重和偏置性质不同的参数。相对于神经网络的权重参数是通过训练数据和学习算法自动获得的学习率这样的超参数则是人工设定的。一般来说超参数需要尝试多个值以便找到一种可以使学习顺利进行的设定。
4神经网络的梯度
这里所说的梯度是指损失函数关于权重参数的梯度。比如有一个只有一个形状为2×3 的权重 W 的神经网络损失函数用L表示。此时梯度可以用 表示。用数学式表示的话如下所示。 5实现神经网络的梯度
根据梯度法更新权重参数
# coding: utf-8
# 导入sys和os模块sys模块提供了一些变量和函数os模块提供了一些与操作系统交互的功能
import sys, os
#为了导入父目录中的文件而进行的设定
sys.path.append(os.pardir) # 为了导入父目录中的文件而进行的设定
import numpy as np
from common.functions import softmax, cross_entropy_error
from common.gradient import numerical_gradient
simple Net类只有一个实例变量即形状为2×3的权重参数。它有两个方法一个是用于预测的predict(x)另一个是用于求损失函数值的loss(x,t)。这里参数x接收输入数据t接收正确解标签。class simpleNet:def __init__(self):# 用高斯分布进行初始化self.W np.random.randn(2,3)
#用于预测def predict(self, x):return np.dot(x, self.W)def loss(self, x, t):# 计算预测结果z z self.predict(x)y softmax(z)# 计算交叉熵误差作为损失函数值 loss cross_entropy_error(y, t)# 返回损失函数值return loss
x np.array([0.6, 0.9])
t np.array([0, 0, 1])net simpleNet()
f lambda w: net.loss(x, t)
dW numerical_gradient(f, net.W)
#打印梯度dW
print(dW)5.学习算法的实现
求出神经网络的梯度后接下来只需根据梯度法更新权重参数即可。
1神经网络的学习步骤
前提 神经网络存在合适的权重和偏置调整权重和偏置以便拟合训练数据的过程称为“学习”。神经网络的学习分成下面4个步骤。 步骤1mini-batch 从训练数据中随机选出一部分数据这部分数据称为mini-batch。我们的目标是减小mini-batch的损失函数的值。 步骤2计算梯度 为了减小mini-batch的损失函数的值需要求出各个权重参数的梯度。梯度表示损失函数的值减小最多的方向。 步骤3更新参数
将权重参数沿梯度方向进行微小更新。
步骤4重复 重复步骤1、步骤2、步骤3。
这个方法通过梯度下降法更新参数不过因为这里使用的数据是随机选择的mini batch数据所以又称为随机梯度下降法stochastic gradient descent。“随机”指的是“随机选择的”的意思因此随机梯度下降法是“对随机选择的数据进行的梯度下降法”。深度学习的很多框架中随机梯度下降法一般由一个名为SGD的函数来实现。SGD 来源于随机梯度下降法的英文名称的首字母。
2两层神经网络的类实现
# coding: utf-8
import sys, os
sys.path.append(os.pardir) # 为了导入父目录的文件而进行的设定
from common.functions import *
from common.gradient import numerical_gradientclass TwoLayerNet:#进行初始化。参数从头开始依次表示输入层的神经元数、隐藏层的神经元数、输出层的神经元数def __init__(self, input_size, hidden_size, output_size, weight_init_std0.01):# 初始化权重#保存神经网络的参数的字典型变量实例变量。#params[W1] 是第 1 层的权重params[b1] 是第 1 层的偏置。#params[W2] 是第 2 层的权重params[b2] 是第 2 层的偏置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)#进行识别推理。参数x是图像数据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) b1z1 sigmoid(a1)a2 np.dot(z1, W2) b2y softmax(a2)return y# x:输入数据, t:监督数据#计算损失函数的值。参数x是图像数据t是正确解标签后面3个方法的参数也一样def loss(self, x, t):y self.predict(x)return cross_entropy_error(y, t)#计算识别精度def accuracy(self, x, t):y self.predict(x)y np.argmax(y, axis1)t np.argmax(t, axis1)accuracy np.sum(y t) / float(x.shape[0])return accuracy#计算权重参数的梯度# x:输入数据, t:监督数据def numerical_gradient(self, x, t):loss_W lambda W: self.loss(x, t)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#计算权重参数的梯度。def gradient(self, x, t):W1, W2 self.params[W1], self.params[W2]b1, b2 self.params[b1], self.params[b2]#保存梯度的字典型变量numerical_gradient() 方法的返回值。#grads[W1] 是第 1 层权重的梯度grads[b1] 是第 1 层偏置的梯度。#grads[W2] 是第 2 层权重的梯度grads[b2] 是第 2 层偏置的梯度grads {}batch_num x.shape[0]# forwarda1 np.dot(x, W1) b1z1 sigmoid(a1)a2 np.dot(z1, W2) b2y softmax(a2)# backwarddy (y - t) / batch_numgrads[W2] np.dot(z1.T, dy)grads[b2] np.sum(dy, axis0)da1 np.dot(dy, W2.T)dz1 sigmoid_grad(a1) * da1grads[W1] np.dot(x.T, dz1)grads[b1] np.sum(dz1, axis0)return grads初始化方法会对权重参数进行初始化。如何设置权重参数的初始值这个问题是关系到神经网络能否成功学习的重要问题。这里权重使用符合高斯分布的随机数进行初始化偏置使用 0 进行初始化。
3mini-batch的实现
mini-batch 学习就是从训练数据中随机选择一部分数据称为 mini-batch再以这些mini-batch为对象使用梯度法更新参数的过程。
完整代码实现如下
train_neuralnet.py文件,训练并测试二层神经网络TwoLayerNet
# coding: utf-8
import sys, ossys.path.append(os.pardir) # 为了导入父目录的文件而进行的设定
import numpy as np
import matplotlib.pyplot as plt
from dataset.mnist import load_mnist
from two_layer_net import TwoLayerNet# 读入数据
(x_train, t_train), (x_test, t_test) load_mnist(normalizeTrue, one_hot_labelTrue)
network TwoLayerNet(input_size784, hidden_size50, output_size10)
iters_num 10000 # 适当设定循环的次数
# 获取训练集的大小
train_size x_train.shape[0]
# mini-batch的大小为100需要每次从60000个训练数据中随机取出100个数据图像数据和正确解标签数据。
batch_size 100
# 设定学习率为0.1。
learning_rate 0.1
train_loss_list []
train_acc_list []
test_acc_list []
# 计算每个epoch的迭代次数至少为1。
iter_per_epoch max(train_size / batch_size, 1)
# 对循环迭代次数进行计数。
for i in range(iters_num):batch_mask np.random.choice(train_size, batch_size)x_batch x_train[batch_mask]t_batch t_train[batch_mask]# 计算梯度# 使用网络计算梯度。# 对这个包含100笔数据的mini-batch求梯度使用随机梯度下降法SGD更新参数。# grad network.numerical_gradient(x_batch, t_batch)grad network.gradient(x_batch, t_batch) # 快速版# 对网络中的参数进行更新。for key in (W1, b1, W2, b2):network.params[key] - learning_rate * grad[key]# 计算当前批次的损失。loss network.loss(x_batch, t_batch)# 将损失添加到列表中。train_loss_list.append(loss)if i % iter_per_epoch 0:# 计算训练集上的准确度。train_acc network.accuracy(x_train, t_train)# 计算测试集上的准确度。test_acc network.accuracy(x_test, t_test)# 将训练准确度添加到列表中。train_acc_list.append(train_acc)#将测试准确度添加到列表中。test_acc_list.append(test_acc)# 打印训练和测试准确度。print(train acc, test acc | str(train_acc) , str(test_acc))# 绘制图形
# 定义用于绘图的标记类型。
markers {train: o, test: s}
# 创建x轴的坐标值从0到列表的
x np.arange(len(train_acc_list))
plt.subplot(2,1,1)
# 绘制训练准确度曲线
plt.plot(x, train_acc_list, labeltrain acc)
# 绘制测试准确度曲线
plt.plot(x, test_acc_list, labeltest acc, linestyle--)
plt.xlabel(epochs)
plt.ylabel(accuracy)
plt.ylim(0, 1.0)
plt.legend(loclower right)
# 绘制训练损失曲线
plt.subplot(2,1,2)
xxnp.arange(len(train_loss_list))
plt.plot(xx, train_loss_list, labeltrain loss)
plt.ylabel(loss)
plt.legend(locupper right)
# 显示图像
plt.show()mnist.py获取手写数据
# coding: utf-8
try:import urllib.request
except ImportError:raise ImportError(You should use Python 3.x)
import os.path
import gzip
import pickle
import os
import numpy as npurl_base http://yann.lecun.com/exdb/mnist/
key_file {train_img:train-images-idx3-ubyte.gz,train_label:train-labels-idx1-ubyte.gz,test_img:t10k-images-idx3-ubyte.gz,test_label:t10k-labels-idx1-ubyte.gz
}dataset_dir os.path.dirname(os.path.abspath(__file__))
save_file dataset_dir /mnist.pkltrain_num 60000
test_num 10000
img_dim (1, 28, 28)
img_size 784def _download(file_name):file_path dataset_dir / file_nameif os.path.exists(file_path):returnprint(Downloading file_name ... )urllib.request.urlretrieve(url_base file_name, file_path)print(Done)def download_mnist():for v in key_file.values():_download(v)def _load_label(file_name):file_path dataset_dir / file_nameprint(Converting file_name to NumPy Array ...)with gzip.open(file_path, rb) as f:labels np.frombuffer(f.read(), np.uint8, offset8)print(Done)return labelsdef _load_img(file_name):file_path dataset_dir / file_nameprint(Converting file_name to NumPy Array ...) with gzip.open(file_path, rb) as f:data np.frombuffer(f.read(), np.uint8, offset16)data data.reshape(-1, img_size)print(Done)return datadef _convert_numpy():dataset {}dataset[train_img] _load_img(key_file[train_img])dataset[train_label] _load_label(key_file[train_label]) dataset[test_img] _load_img(key_file[test_img])dataset[test_label] _load_label(key_file[test_label])return datasetdef init_mnist():download_mnist()dataset _convert_numpy()print(Creating pickle file ...)with open(save_file, wb) as f:pickle.dump(dataset, f, -1)print(Done!)def _change_one_hot_label(X):T np.zeros((X.size, 10))for idx, row in enumerate(T):row[X[idx]] 1return Tdef load_mnist(normalizeTrue, flattenTrue, one_hot_labelFalse):读入MNIST数据集Parameters----------normalize : 将图像的像素值正规化为0.0~1.0one_hot_label : one_hot_label为True的情况下标签作为one-hot数组返回one-hot数组是指[0,0,1,0,0,0,0,0,0,0]这样的数组flatten : 是否将图像展开为一维数组Returns-------(训练图像, 训练标签), (测试图像, 测试标签)if not os.path.exists(save_file):init_mnist()with open(save_file, rb) as f:dataset pickle.load(f)if normalize:for key in (train_img, test_img):dataset[key] dataset[key].astype(np.float32)dataset[key] / 255.0if one_hot_label:dataset[train_label] _change_one_hot_label(dataset[train_label])dataset[test_label] _change_one_hot_label(dataset[test_label])if not flatten:for key in (train_img, test_img):dataset[key] dataset[key].reshape(-1, 1, 28, 28)return (dataset[train_img], dataset[train_label]), (dataset[test_img], dataset[test_label]) if __name__ __main__:init_mnist()
gradient.py文件梯度计算
# coding: utf-8
import numpy as np计算函数f在给定输入点x处的数值梯度def numerical_gradient(f, x):定义一个函数numerical_gradient它接受两个参数函数f和输入点x #设置步长h即梯度下降法中的学习率这里取值为0.0001。h 1e-4 # 0.0001#初始化一个与输入点x形状和大小相同的零向量grad用于存储计算得到的梯度。grad np.zeros_like(x)#使用np.nditer来遍历输入点x的所有元素flags[multi_index]表示返回多个索引op_flags[readwrite]表示读写操作。it np.nditer(x, flags[multi_index], op_flags[readwrite])#while循环条件是当迭代器it未完成时继续循环。while not it.finished:idx it.multi_indextmp_val x[idx]x[idx] float(tmp_val) hfxh1 f(x) # f(xh)x[idx] tmp_val - hfxh2 f(x) # f(x-h)grad[idx] (fxh1 - fxh2) / (2*h)x[idx] tmp_val # 还原值it.iternext() return grad运行结果 随着epoch的前进学习的进行发现使用训练数据和测试数据评价的识别精度都提高了并且这两个识别精度基本上没有差异两条线基本重叠在一起。因此可以说这次的学习中没有发生过拟合的现象。随着学习的进行损失函数的值在不断减小。这是学习正常进行的信号表示神经网络的权重参数在逐渐拟合数据。也就是说神经网络的确在学习通过反复地向它浇灌输入数据神经网络正在逐渐向最优参数靠近。
epoch 是一个单位。一个epoch表示学习中所有训练数据均被使用过一次时的更新次数。比如对于10000笔训练数据用大小为100笔数据的mini-batch进行学习时重复随机梯度下降法100次所有的训练数据就都被“看过”了
一般做法是事先将所有训练数据随机打乱然后按指定的批次大小按序生成 mini-batch。这样每个mini-batch均有一个索引号比如此例可以是0, 1, 2,. . ., 99然后用索引号可以遍历所有的mini-batch。遍历一次所有数据就称为一个epoch。
4小结
为了能顺利进行神经网络的学习我们导入了损失函数这个指标。以这个损失函数为基准找出使它的值达到最小的权重参数就是神经网络学习的目标。为了找到尽可能小的损失函数值我们介绍了使用函数斜率的梯度法。
