使用 MNIST 数据集对 0 到 9 之间的数字进行手写数字识别神经网络的一个典型入门教程。

 

 

该技术在现实场景中是很有用的,比如可以把该技术用来扫描银行转帐单或支票,其中帐号和需要转账的金额可以被识别处理并写在明确定义的方框中。

 

 

在本教程中,我们将介绍如何使用 Julia 编程语言和名为 Flux 的机器学习库来实现这一技术。为什么使用 Flux 和 Julia?本教程为什么想使用 Flux(https://fluxml.ai/) 和 Julia(https://julialang.org/) ,而不是像 Torch、PyTorch、Keras 或 TensorFlow 2.0 这样的知名框架呢?一个很好的原因是因为 Flux 更易于学习,而且它提供更好的性能和拥有有更大的潜力,另外一个原因是,Flux 在仍然是一个小库的情况下实现了很多功能。Flux 库非常小,因为它所做的大部分工作都是由 Julia 编程语言本身提供的。例如,如果你查看 Gorgonia ML 库(https://github.com/gorgonia/gorgonia) 中的 Go 编程语言,你将看到,它明确地展示了其他机器学习库如何构建一个需要执行和区分的表达式图。在 Flux 中,这个图就是 Julia 本身。Julia 与 LISP 非常相似,因为 Julia 代码可以很容易地表示为数据结构,可以对其进行修改和计算。机器学习概论如果你是机器学习的新手,你可以跟着本教程来学习,但并不是所有的东西对你来说都是有价值的。你也可以看看我以前关于 Medium 的一些文章,它们可能会解释你一些新手的疑惑:线性代数的核心思想。(https://medium.com/@Jernfrost/the-core-idea-of-linear-algebra-7405863d8c1d)线性代数基本上是关于向量和矩阵的,这是你在机器学习中经常用到的东西。使用引用。(https://medium.com/@Jernfrost/working-with-and-emulating-references-in-julia-e02c1cae5826)它看起来有点不太好理解,但是如果你想理解像 Flux 这样的 ML 库,那么理解 Julia 中的引用是很重要的。Flux 的实现。(https://medium.com/@Jernfrost/implementation-of-a-modern-machine-learning-library-3596badf3be)如何实现 Flux-ML 库的初学者指南。机器学习简介。(https://medium.com/@Jernfrost/machine-learning-for-dummies-in-julia-6cd4d2e71a46) 机器学习概论。简单多层感知机我们要编程的人工神经网络被称为简单的多层感知机,这是神经网络(ANN)的基础,大多数教科书都会从它开始。我先展示整个程序,然后我们再更详细地讲解不同的部分。using Flux, Flux.Data.MNIST, Statistics
using Flux: onehotbatch, onecold, crossentropy, throttle
using Base.Iterators: repeated
# Load training data. 28x28 grayscale images of digits
imgs = MNIST.images()
# Reorder the layout of the data for the ANN
imagestrip(image::Matrix{<:Gray}) = Float32.(reshape(image, :))
X = hcat(imagestrip.(imgs)...)
# Target output. What digit each image represents.
labels = MNIST.labels()
Y = onehotbatch(labels, 0:9)
# Defining the model (a neural network)
m = Chain(
Dense(28*28, 32, relu),
Dense(32, 10),
softmax)

loss(x, y) = crossentropy(m(x), y)
dataset = repeated((X, Y), 200)
opt = ADAM()
evalcb = () -> @show(loss(X, Y))
# Perform training on data
Flux.train!(loss, params(m), dataset, opt, cb = throttle(evalcb, 10))
探索输入数据数据预处理通常是数据科学中最大的工作之一。通常情况下,数据的组织或格式化方式与将其输入算法所需的方式不同。我们首先将 MNIST 数据集加载为 60000 个 28x28 像素的灰度图像:imgs = MNIST.images()
现在,如果你这样处理数据,你可能不知道输出的数据是怎么样子的,但使用 Julia 研究,我们只需检查一下:julia> size(imgs)
(60000,)
输出说明了 imgs 是一个包含 60000 个元素的一维数组。但这些元素是什么?julia> eltype(imgs)
Array{Gray{FixedPointNumbers.Normed{UInt8,8}},2}
你可能看不懂,但我可以简单地告诉你这是什么:julia> eltype(imgs) <: Matrix{T} where T <: Gray
true
这告诉我们 imgs 中的每个元素都是某种值矩阵,这些值属于某种类型 T,它是 Gray 类型的子类型。什么是 Gray 类型?我们可以在 Julia 在线文档中查找:help?> Gray
 Gray is a grayscale object. You can extract its value with gray(c).
如果我们想知道这些灰度值矩阵的维数,则可以:julia> size(imgs[1])
(28, 28)
julia> size(imgs[2])
(28, 28)
这告诉我们它们的尺寸为 28x28 像素。我们可以通过简单地绘制其中的一些图来进一步验证这一点。Julia 的 Plots 库使你可以绘制函数和图像。julia> using Plots
julia> plot(imgs[2])
得出了下面的图像,显然看起来像一个数字:

 

 

但是,你可能会发现了解更多的数据看起来是更有用。我们可以很容易地一起绘制几个图像:imgplots = plot.(imgs[1:9])
plot(imgplots...)

 

 

现在我们知道了数据是什么样的了。准备输入数据然而,我们不能像这样将数据输入到我们的神经网络(ANN),因为每个神经网络输入必须是列向量,而不是矩阵。这是因为神经网络期望一个矩阵作为输入,矩阵中的每一列都是输入。ANN 所看到的三乘十矩阵对应于十个不同的输入,其中每个输入包含三个不同的值或者更具体地说是三个不同的特征,因此,我们将 28x28 灰度图像转换为 28x28=784 的长像素带。其次,我们的神经网络并不知道什么是灰度值,它是对浮点数据进行操作的,所以我们必须同时转换数据的维度和元素类型。数组中的列和行数称为其形状。很多人提到了张量,虽然它并不完全精确,但它是一个涵盖了标量、向量、矩阵、立方体或任何等级的数组(基本上是数组的所有维度)的概念。在 Julia 中,我们可以使用 reshape 函数来改变数组的形状。下面是一些你如何使用它的例子。这将创建一个包含四个元素的列向量 A:julia> A = collect(1:4)
4-element Array{Int64,1}:
1
2
3
4
通过 reshape 我们把它变成一个二乘二的矩阵 B:julia> B = reshape(A, (2, 2))
2×2 Array{Int64,2}:
1  3
2  4
矩阵可以再次转换为列向量:julia> reshape(B, 4)
4-element Array{Int64,1}:
1
2
3
4
找出一个列向量到底有多少个元素是不切实际的,你可以让 Julia 只通过写来计算合适的长度。julia> reshape(B, :)
4-element Array{Int64,1}:
1
2
3
4
有了这些信息,应该更容易看到 imagestrip 函数的实际功能了,它将 28x28 的灰度矩阵转换为 784 个 32 位浮点值的列向量。imagestrip(image::Matrix{<:Gray}) = Float32.(reshape(image, :))
该.符号用于将函数应用于数组的每个元素,因此 Float32.(xs)与 map(Float32, xs)是相同的。接下来,我们将 imagestrip 函数应用于 6 万张灰度图像中的每一张,生成 784x6000 个输入矩阵 X。X = hcat(imagestrip.(imgs)...)
这是如何运作的?可以想象为 imagestrip.(imgs)将图像转换为单个输入值的数组,例如[X?, X?, X?, ..., X?],其中 n = 60,000,每个 X?都是 784 个浮点值。使用 splat 运算符...,我们将其转换为所有这些列向量的水平连接,以产生模型输入。X = hcat(X?, X?, X?, ..., X?)
如果要验证尺寸,则可以运行 size(X)。接下来,我们加载标签。labels = MNIST.labels()
标签是我们称之为监督学习中观察的"答案"部分。在我们的任务中,标签是从 0 到 9 的数字。手绘数字的每一个图像都应归类为十个不同的数字之一,例如,如果这是一个包含不同花卉品种的花瓣长度和花瓣宽度的虹膜数据集,那么该品种的名称就是标签。X?代表我们所有的特征向量,用机器学习的术语来说,每个像素的灰度值都是一个特征。你可以将标签与我们绘制的图像进行比较。imgplots = plot.(imgs[1:9])
plot(imgplots...)
labels[1:9]
独热编码每个图像一个标签,则有 60000 个标签,然而神经网络不能直接输出标签。例如,如果你正试图对猫和狗的图像进行分类,那么一个网络不能输出字符串“dog”或“cat”,因为它是使用浮点值的。如果标签是一个不一定有用的数字,例如如果输出是一系列邮政编码,那么将 3000 的邮政编码视为 1500 的邮政编码的两倍是没有意义的,同样,当使用神经网络从图像中预测数字时,4 的大小是 2 的两倍并不重要,数字也可能是字母,因此它们的值不重要。我们在机器学习中处理这个问题的方法是使用所谓的独热编码,这意味着,如果我们有标签 A、B 和 C,并且我们想用独热编码来表示它们,那么 A 是[1、0、0],B 是[0、1、0],C 是[0、0、1]。这看起来很浪费空间,但在 Julia one hot 数组内部,它只跟踪元素的索引,并不保存所有的零。下面是一些正在使用的编码示例:julia> Flux.onehot('B', ['A', 'B', 'C'])
3-element Flux.OneHotVector:
0
1
0
julia> Flux.onehot("foo", ["foo", "bar", "baz"])
3-element Flux.OneHotVector:
1
0
0
但是,我们不会使用 onehot 函数,因为我们正在创建一批独热编码标签,我们将把 60000 张图片作为一个批次来处理。机器学习的批次指的是在我们模型(神经网络)的权值或参数更新之前必须完成的最小样本数量。Y = onehotbatch(labels, 0:9)
这将创建目标输出。在理想情况下,模型(X)==Y,但在现实中,即使经过模型的训练,也会有一些偏差。我们已经讨论完数据准备,现在让我们用人工神经网络来构造我们的模型。构造神经网络模型模型是真实世界的简化表示,就像我们可以建立简化的物理模型一样,我们也可以用数学或代码来创建物理世界的模型,现实中存在许多这样的数学模型。例如,统计模型可以使用统计数据来模拟人们一天中是如何到达商店的。一般来说,人们会以一种遵循特定概率分布的方式到达。在我们的例子中,我们试图用神经网络来模拟现实世界中的一些东西,当然,这只是对现实世界的一种近似。当我们建立一个神经网络时,我们有很多可以玩的东西。网络是由多个层连接而成的,每一层通常都有一个激活函数。建立一个神经网络的挑战是选择合适的层和激活函数,并决定每层应该有多少个节点。我们的模型非常简单,定义如下:m = Chain(
 Dense(28^2, 32, relu),
 Dense(32, 10),
 softmax)
这是一个三层的神经网络。Chain 用于将各个层连接在一起。第一层 Dense(28^2, 32, relu)有 784(28x28)个输入节点,对应于每个图像中的像素数。它使用校正线性单元(ReLU)函数作为激活函数。在经典的神经网络文献中,通常会介绍 sigmoid 和 tanh。relu 等激活函数,这些激活函数在大多数情况下都工作得很好,包括图像的分类。下一层是我们的隐藏层,它接受 32 个输入,因为前一层有 32 个输出,隐藏节点的数量没有明确的对错选择。但输出的数量根据不同任务是不一样的,因为我们希望每个数字有一个输出,这也就是“独热编码”发挥作用的地方。Softmax 函数最后一层,是 softmax 函数,它以前一层的输出的矩阵作为输入,并沿着每一列进行归一化。标准化将 60000 列中的每一列转换为概率分布。那到底是什么意思?概率是 0 到 1 之间的值,0 表示事件永远不会发生,1 是肯定会发生。与 min-max 归一化一样,softmax 将所有输入归一化为 0 到 1 之间的值,但是与 min max 不同的是它会确保所有值的和为一。这需要一些例子来说明。假设我创建了 10 个从 1 到 10 的随机值,我们可以放任意范围和任意数量的值。julia> ys = rand(1:10, 10)
10-element Array{Int64,1}:
 9
 6
10
 5
10
 2
 6
 6
 7
 9
现在让我们使用不同的归一化函数归一化这个数组,我们将使用来自 LinearAlgebra 模块的 normalize,因为它与 Julia 捆绑在一起。但首先使用 softmax:julia> softmax(ys)
10-element Array{Float64,1}:
0.12919082661651196  
0.006432032517257137  
0.3511770763952676    
0.002366212528045101  
0.3511770763952676    
0.00011780678490667763
0.006432032517257137  
0.006432032517257137  
0.017484077111717768  
0.12919082661651196
如你所见,所有值都在 0 到 1 之间。现在看一下如果我们把它们加起来会发生什么:julia> sum(softmax(ys))
0.9999999999999999
它们基本上变成了 1。现在将其与 normalize 的功能进行对比:julia> using LinearAlgebra
julia> normalize(ys)
10-element Array{Float64,1}:
0.38446094597254243
0.25630729731502827
0.4271788288583805
0.21358941442919024
0.4271788288583805
0.0854357657716761
0.25630729731502827
0.25630729731502827
0.2990251802008663
0.38446094597254243
julia> sum(normalize(ys))
2.9902518020086633
julia> norm(normalize(ys))
1.0
julia> norm(softmax(ys))
0.52959100847191
如果对用 normalize 归一化的值求和,它们只会得到一些随机值,然而如果我们把结果反馈给 norm,我们得到的结果正好是 1.0。不同之处在于,normalize 将向量中的值进行了归一化,以便它们可以表示单位向量,即长度正好为一的向量。norm 给出向量的大小。相比之下,softmax 不会将这些值视为向量,而是将其视为概率分布,每个元素表示输入图像为该数字的概率。假设我们有 A,B 和 C 的图像作为输入,如果你从 softmax 得到一个输出值是[0.1,0.7,0.2],那么输入图像有 10%的可能性是 A 的图形,有 70%的可能性是 B 的图形,最后有 20%的可能性是 C 的图形。这就是为什么我们希望 softmax 作为最后一层的原因。用神经网络不能绝对确定输入图像是什么,但是我们可以给出一个概率分布,它表示更有可能是哪个数字。定义损失函数当训练我们的神经网络(模型)给出准确的预测时,我们需要定义人工神经网络(ANN)的评估指标。为此,我们使用所谓的损失函数。损失函数有很多名字,20 年前当我被教授神经网络时,我们曾称之为误差函数,也有人称之为成本函数。然而,归根结底,这是一种表达我们的预测与现实相比有多正确的方式。loss(x, y) = crossentropy(m(x), y)
训练神经网络实际上是最小化这个函数的输出,所以这是一个优化问题。训练是一个反复调整模型中参数(权重)的过程,直到损失函数的输出变低,或者换句话说,直到我们的预测误差变低。均方误差函数(MSE)是计算预测错误程度的经典方法,这就意味着取差的平方,然而,MSE 更适合于线性回归(将一条或多条直线拟合到某些观测值)。在这种情况下,我们改用交叉熵函数。当你的最后一层是 softmax,进行分类而不是线性回归时,这是我比较推荐的选择。指定 Epoch 在机器学习术语中,Epoch 是训练算法进行一次完整的迭代,换句话说:一个 Epoch 处理一个批次并更新权重因此,如果我们使用 10 个 Epoch 来进行训练,那么模型的参数 / 权重将更新 / 调整 10 次。为了得到 200 个 Epoch,我们使用 repeat 重复我们的批处理 200 次。它实际上不会重复我们的数据 200 次,它只是用迭代器创建了这样的错觉。dataset = repeated((X, Y), 200)
在数据集中,我们得到的数组如下:dataset = [(X1, Y1), (X2, Y2), ..., (X200, Y200)]
优化器最常见和最著名的训练神经网络策略是梯度下降算法,这是由 Julia 中的 Descent 类型提供的。然而,在我们的例子中,当我们处理大量带有相当数量噪声的数据时,建议改用 ADAM 优化器,这就是所谓的随机优化。opt = ADAM()
进行训练我们终于可以进行训练了,但我们希望在训练进行的过程中得到一些反馈。我们定义了一个回调函数,在每次迭代(epoch)时,它将输出 loss 函数的值,从而显示错误。我们希望每次迭代时都能看到这个错误。evalcb = () -> @show(loss(X, Y))
观察错误发展的一个有用的地方是,你可以看到是否有振荡。人工神经网络过快地朝着最低值过渡,会导致它朝相反的方向移动,如果速度太快,则会向相反的方向超调,振荡会变得更加剧烈,直到误差变为无穷大。这是一个切换优化算法或降低学习率的提示。不管怎样,这就是你训练的方式。注意,回调是可选的:Flux.train!(loss, params(m), dataset, opt, cb = throttle(evalcb, 10))
评价模型预测精度经过训练后,我们可以测试模型在预测方面的表现。我们定义了这样一个函数:accuracy(x, y) = mean(onecold((m(x))) .== onecold(y))
然后我们用输入数据和标签作为输入参数来调用它:@show accuracy(X, Y)
至于什么是 onecold?在某种程度上,它与 onehot 实现的效果是相反的。我们的输出 m(X)都是概率分布,而我们的目标 Y 都是独热向量。它们不能直接比较,所以我们需要使用 onecold 来做一个转换。给定概率分布,它选择最可能的候选:julia> onecold([0.1, 0.7, 0.2])
2
julia> onecold([0.9, 0.05, 0.05])
1
因此,使用 onecold(m(X))我们可以得到预测的标签,这可以与实际的标签 onecold(y)进行比较。用测试数据验证模型到目前为止,我们只根据我们使用的训练数据来验证了我们的模型,然而,如果该模型不适用于新的数据,它将是完全无用的。因此,在训练网络时,我们通常将数据分为训练数据和测试数据。测试数据不是训练的一部分,只有在训练完成后才能进行测试。tX = hcat(float.(reshape.(MNIST.images(:test), :))...)
tY = onehotbatch(MNIST.labels(:test), 0:9)
@show accuracy(tX, tY)
最后我希望这能帮助你理解建立神经网络的过程。太多的教程倾向于跳过向初学者解释的内容,从而所有的新概念都会很快变得令人困惑。我希望这为初学者在进一步探索机器学习之前提供了一个起点,特别是基于 Julia 的机器学习,因为我认为 Julia 有着光明的未来。参考链接:https://medium.com/better-programming/handwriting-recognition-using-an-artificial-neural-network-78060d2a7963