Python AI:如何构建神经网络并进行预测?

2021年11月9日15:20:18 发表评论 1,058 次浏览

如果你刚刚开始涉足人工智能 (AI) 世界,那么 Python 是一种非常适合学习的语言,因为大多数工具都是使用它构建的。深度学习是一种使用数据进行预测的技术,它在很大程度上依赖于神经网络。今天,你将学习如何从头开始构建神经网络,以及Python实现神经网络的完整过程。

如何构建神经网络并进行预测?在生产环境中,你将使用TensorFlowPyTorch等深度学习框架,而不是构建自己的神经网络。也就是说,了解神经网络的工作原理是有帮助的,因为你可以使用它来更好地构建深度学习模型。

在本教程中,你将学习:

  • 什么是人工智能
  • 机器学习深度学习如何在人工智能中发挥作用
  • 神经网络内部如何运作
  • Python如何构建神经网络?
  • Python构建神经网络示例
  • 如何使用 Python 从头开始构建神经网络

让我们开始吧!

人工智能概述

从根本上讲,使用人工智能的目标是让计算机像人类一样思考。这似乎是新事物,但该领域诞生于 1950 年代。

想象一下,你需要编写一个使用 AI解决数独问题的 Python 程序。实现这一点的一种方法是编写条件语句并检查约束以查看是否可以在每个位置放置一个数字。好吧,这个 Python 脚本已经是 AI 的应用程序了,因为你编写了一台计算机来解决问题!

机器学习 (ML)深度学习 (DL)也是解决问题的方法。这些技术与 Python 脚本之间的区别在于 ML 和 DL 使用训练数据而不是硬编码规则,但它们都可以用于使用 AI 解决问题。在接下来的部分中,你将详细了解这两种技术的区别。

机器学习

机器学习是一种训练系统解决问题而不是明确编程规则的技术。回到上一节中的数独示例,要使用机器学习解决问题,你需要从已解决的数独游戏中收集数据并训练统计模型统计模型是一种数学形式化的近似现象行为的方法。

一个常见的机器学习任务是监督学习,其中你有一个包含输入和已知输出的数据集。任务是使用此数据集来训练一个模型,该模型根据输入预测正确的输出。下图展示了使用监督学习训练模型的工作流程:

Python AI:如何构建神经网络并进行预测?
训练机器学习模型的工作流

训练数据与机器学习算法的结合创建了模型。然后,使用此模型,你可以对新数据进行预测。

注意: scikit-learn是一个流行的 Python 机器学习库,它提供了许多有监督和无监督的学习算法。要了解更多信息,请查看使用 scikit-learn 的 train_test_split() 拆分你的数据集。

监督学习任务的目标是对新的、看不见的数据进行预测。为此,你假设这些看不见的数据遵循与训练数据集分布相似的概率分布。如果将来此分布发生变化,则你需要使用新的训练数据集再次训练你的模型。

如何构建神经网络并进行预测:特征工程

当你使用不同类型的数据作为输入时,预测问题变得更加困难。数独问题相对简单,因为你直接处理数字。如果你想训练一个模型来预测句子中的情绪怎么办?或者,如果你有一个图像,并且你想知道它是否描绘了一只猫,该怎么办?

输入数据的另一个名称是特征特征工程是从原始数据中提取特征的过程。在处理不同类型的数据时,你需要找出表示这些数据的方法,以便从中提取有意义的信息。

特征工程技术的一个例子是词形还原,你可以在其中删除句子中单词的屈折变化。例如,动词“watch”的屈折形式,如“watches”、“watching”和“watched”,将被简化为它们的引理或基本形式:“watch”。

如果你使用数组来存储语料库的每个单词,那么通过应用词形还原,你最终会得到一个不太稀疏的矩阵。这可以提高某些机器学习算法的性能。下图展示了使用词袋模型进行词形还原和表示的过程:

Python AI:如何构建神经网络并进行预测?
使用词袋模型创建特征

首先,每个词的屈折形式都归结为它的引理。然后,计算该词的出现次数。结果是一个包含文本中每个单词出现次数的数组。

深度学习

深度学习是一种让神经网络自行确定哪些特征重要的技术,而不是应用特征工程技术。这意味着,通过深度学习,你可以绕过特征工程过程。

不必处理特征工程是好的,因为随着数据集变得越来越复杂,这个过程变得越来越困难。例如,你将如何提取数据来预测一个人的情绪,给她一张脸的照片?使用神经网络,你无需担心,因为网络可以自行学习特征。在接下来的部分中,你将深入研究神经网络,以更好地了解它们的工作原理。

神经网络:主要概念

神经网络是一个通过以下步骤学习如何进行预测的系统:

  1. 获取输入数据
  2. 做出预测
  3. 将预测与所需输出进行比较
  4. 调整其内部状态以正确预测下一次

向量线性回归是神经网络的一些构建块。数据存储为向量,使用 Python 可以将这些向量存储在数组中。每一层都会转换来自前一层的数据。你可以将每一层视为特征工程步骤,因为每一层都提取了先前数据的一些表示。

神经网络层的一个很酷的事情是相同的计算可以从任何类型的数据中提取信息。这意味着你使用的是图像数据还是文本数据并不重要。两种情况下,提取有意义信息和训练深度学习模型的过程是相同的。

在下图中,你可以看到具有两层的网络架构示例:

Python AI:如何构建神经网络并进行预测?
一个两层的神经网络

每一层都通过应用一些数学运算来转换来自前一层的数据。

Python如何构建神经网络?训练神经网络的过程

训练神经网络类似于反复试验的过程。想象一下,你是第一次玩飞镖。在你的第一次投掷中,你尝试击中飞镖板的中心点。通常,第一次拍摄只是为了了解手的高度和速度如何影响结果。如果你看到飞镖高于中心点,那么你调整你的手把它扔得低一点,依此类推。

以下是尝试击中飞镖板中心的步骤:

Python AI:如何构建神经网络并进行预测?
击中飞镖板中心的步骤

请注意,你通过观察飞镖落下的位置来不断评估错误(第 2 步)。你继续前进,直到你最终击中飞镖板的中心。

对于神经网络,该过程非常相似:你从一些随机权重偏置向量开始,进行预测,将其与所需的输出进行比较,然后调整向量以在下次更准确地预测。该过程一直持续到预测和正确目标之间的差异最小。

知道何时停止训练以及设置什么样的准确率目标是训练神经网络的一个重要方面,主要是因为过拟合和欠拟合的情况。

向量和权重

使用神经网络包括使用向量进行操作。你将向量表示为多维数组。向量在深度学习中很有用,主要是因为一种特殊的操作:点积。两个向量的点积告诉你它们在方向上的相似程度,并按两个向量的大小进行缩放。

神经网络中的主要向量是权重和偏置向量。松散地说,你希望神经网络做的是检查输入是否与它已经看到的其他输入相似。如果新输入与之前看到的输入相似,那么输出也将相似。这就是你获得预测结果的方式。

线性回归模型

当你需要估计一个因变量与两个或多个自变量之间的关系时使用回归。线性回归是一种将变量之间的关系近似为线性的方法。该方法可以追溯到十九世纪,是最流行的回归方法。

注意:线性关系是其中有一个自变量和因变量之间的直接关系。

通过将变量之间的关系建模为线性关系,你可以将因变量表示为自变量的加权和。因此,每个自变量将乘以一个名为 的向量weight。除了权重和自变量之外,你还添加了另一个向量:偏差。当所有其他自变量都为零时,它会设置结果。

作为如何构建线性回归模型的真实示例,假设你想要训练一个模型,以根据面积和房屋的年龄来预测房屋的价格。你决定使用线性回归对这种关系进行建模。以下代码块显示了如何用伪代码为所述问题编写线性回归模型:

price = (weights_area * area) + (weights_age * age) + bias

在上面的例子中,有两个权重:weights_areaweights_age。训练过程包括调整权重和偏差,以便模型可以预测正确的价格值。为此,你需要计算预测误差并相应地更新权重。

这些是神经网络机制如何工作的基础知识。现在是时候看看如何使用 Python 应用这些概念了。

Python AI:开始构建你的第一个神经网络

构建神经网络的第一步是从输入数据生成输出。你将通过创建变量的加权总和来做到这一点。你需要做的第一件事是用 Python 和NumPy表示输入。

如何构建神经网络并进行预测?用 NumPy 包装神经网络的输入

你将使用 NumPy 将网络的输入向量表示为数组。但是在使用 NumPy 之前,最好先在纯 Python 中使用向量来更好地理解发生了什么。

在第一个示例中,你有一个输入向量和其他两个权重向量。目标是找到哪个权重与输入更相似,同时考虑方向和大小。如果你绘制矢量,这就是矢量的外观:

Python AI:如何构建神经网络并进行预测?
笛卡尔坐标平面中的三个向量

weights_2更类似于输入向量,因为它指向相同的方向并且幅度也相似。那么如何使用 Python 找出哪些向量相似呢?

首先,你定义三个向量,一个用于输入,另外两个用于权重。然后计算input_vectorweights_1的相似程度。为此,你将应用点积。由于所有向量都是二维向量,因此以下是执行此操作的步骤:

  1. 将 的第一个索引乘以 的第input_vector一个索引weights_1
  2. 将 的第二个索引乘以 的第二input_vector个索引weights_2
  3. 将两个乘法的结果相加。

Python构建神经网络示例:你可以使用 IPython 控制台或Jupyter Notebook进行操作。每次开始一个新的 Python 项目时都创建一个新的虚拟环境是一个很好的做法,所以你应该先这样做。venv附带 Python 3.3 及更高版本,它对于创建虚拟环境非常方便:

$ python -m venv ~/.my-env
$ source ~/.my-env/bin/activate

使用上述命令,你首先创建虚拟环境,然后激活它。现在是使用pip. 由于你还需要 NumPy 和Matplotlib,因此最好也安装它们:

(my-env) $ python -m pip install ipython numpy matplotlib
(my-env) $ ipython

现在你已准备好开始编码。这是计算的点积代码input_vectorweights_1:>>>

In [1]: input_vector = [1.72, 1.23]
In [2]: weights_1 = [1.26, 0]
In [3]: weights_2 = [2.17, 0.32]

In [4]: # Computing the dot product of input_vector and weights_1
In [5]: first_indexes_mult = input_vector[0] * weights_1[0]
In [6]: second_indexes_mult = input_vector[1] * weights_1[1]
In [7]: dot_product_1 = first_indexes_mult + second_indexes_mult

In [8]: print(f"The dot product is: {dot_product_1}")
Out[8]: The dot product is: 2.1672

点积的结果是2.1672。现在你知道如何计算点积,是时候使用np.dot()NumPy 了。以下是如何dot_product_1使用计算np.dot():>>>

In [9]: import numpy as np

In [10]: dot_product_1 = np.dot(input_vector, weights_1)

In [11]: print(f"The dot product is: {dot_product_1}")
Out[11]: The dot product is: 2.1672

np.dot()做你之前做的同样的事情,但现在你只需要指定两个数组作为参数。现在,让我们计算的点积input_vectorweights_2:>>>

In [10]: dot_product_2 = np.dot(input_vector, weights_2)

In [11]: print(f"The dot product is: {dot_product_2}")
Out[11]: The dot product is: 4.1259

这一次,结果是4.1259。作为对点积的另一种思考方式,你可以将向量坐标之间的相似性视为一个开关。如果乘法结果是0,那么你会说坐标相似。如果结果不是0,那么你会说它们相似的。

这样,你可以将点积视为向量之间相似性的松散度量。每次乘法结果为0,最终的点积都会有一个较低的结果。再回到本例的载体,因为的点积input_vectorweights_24.1259,和4.1259大于2.1672,则意味着input_vector更类似于weights_2。你将在神经网络中使用相同的机制。

注意:如果需要复制粘贴,点击每个代码块右上角的提示(>>>)。

在本教程中,你将训练一个模型来做出只有两种可能结果的预测。输出结果可以是01。这是一个分类问题,是监督学习问题的一个子集,其中你有一个包含输入和已知目标的数据集。这些是数据集的输入和输出:

输入向量目标
[1.66, 1.56]1
[2, 1.5]0

目标是要预测的变量。在此示例中,你正在处理由数字组成的数据集。这在实际生产场景中并不常见。通常,当需要深度学习模型时,数据会以文件形式呈现,例如图像或文本。

做出你的第一个预测

Python如何构建神经网络?由于这是你的第一个神经网络,你将保持简单明了并构建一个只有两层的网络。到目前为止,你已经看到在神经网络中使用的仅有的两个运算是点积和求和。两者都是线性运算

如果你添加更多层但继续仅使用线性操作,那么添加更多层将没有效果,因为每一层总是与前一层的输入有一定的相关性。这意味着,对于具有多个层的网络,总会有一个层数较少的网络预测相同的结果。

你想要的是找到一种操作,使中间层有时与输入相关,有时不相关。

你可以通过使用非线性函数来实现此行为。这些非线性函数称为激活函数。激活函数有很多种。所述RELU(整流线性单位),例如,是一个函数,其将所有负数到零。这意味着网络可以“关闭”负值的权重,从而增加非线性。

Python实现神经网络:你正在构建的网络将使用sigmoid 激活函数。你将在最后一层使用它,layer_2. 数据集中仅有的两个可能的输出是01,并且 sigmoid 函数将输出限制在0和之间的范围内1。这是表示 sigmoid 函数的公式:

Python AI:如何构建神经网络并进行预测?
Sigmoid函数公式

e是叫做数学常数欧拉数,并且可以使用np.exp(x)来计算Ë

概率函数为你提供事件可能结果的发生概率。数据集仅有的两个可能的输出是01,而伯努利分布也是具有两种可能结果的分布。如果你的问题遵循伯努利分布,则 sigmoid 函数是一个不错的选择,这就是你在神经网络的最后一层使用它的原因

由于功能限制输出到一个范围的01,你会用它来预测概率。如果输出大于0.5,则你会说预测为1。如果它低于0.5,那么你会说预测是0。这是你正在构建的网络内部的计算流程:

Python AI:如何构建神经网络并进行预测?
神经网络内部的计算流程

黄色六边形代表函数,蓝色矩形代表中间结果。现在是时候将所有这些知识转化为代码了。你还需要用 NumPy 数组包装向量。这是应用上图中显示的函数的代码:>>>

In [12]: # Wrapping the vectors in NumPy arrays
In [13]: input_vector = np.array([1.66, 1.56])
In [14]: weights_1 = np.array([1.45, -0.66])
In [15]: bias = np.array([0.0])

In [16]: def sigmoid(x):
   ...:     return 1 / (1 + np.exp(-x))

In [17]: def make_prediction(input_vector, weights, bias):
   ...:      layer_1 = np.dot(input_vector, weights) + bias
   ...:      layer_2 = sigmoid(layer_1)
   ...:      return layer_2

In [18]: prediction = make_prediction(input_vector, weights_1, bias)

In [19]: print(f"The prediction result is: {prediction}")
Out[19]: The prediction result is: [0.7985731]

原始预测结果为0.79,高于0.5,因此输出为1。网络做出了正确的预测。现在尝试使用另一个输入向量np.array([2, 1.5])。此输入的正确结果是0。你只需要更改input_vector变量,因为所有其他参数都保持不变:>>>

In [20]: # Changing the value of input_vector
In [21]: input_vector = np.array([2, 1.5])

In [22]: prediction = make_prediction(input_vector, weights_1, bias)

In [23]: print(f"The prediction result is: {prediction}")
Out[23]: The prediction result is: [0.87101915]

这一次,网络做出了错误的预测。结果应该小于,0.5因为此输入的目标是0,但原始结果是0.87。它做出了错误的猜测,但这个错误有多严重?下一步是找到一种评估方法。

训练你的第一个神经网络

如何构建神经网络并进行预测?在训练神经网络的过程中,你首先评估误差,然后相应地调整权重。要调整权重,你将使用梯度下降反向传播算法。应用梯度下降来寻找方向和更新参数的速率。

在对网络进行任何更改之前,你需要计算误差。这就是你将在下一节中执行的操作。

计算预测误差

要了解误差的大小,你需要选择一种测量方法。用于测量误差的函数称为成本函数,或损失函数。在本教程中,你将使用均方误差 (MSE)作为成本函数。你分两步计算 MSE:

  1. 计算预测和目标之间的差异。
  2. 将结果乘以自身。

网络可能会因输出高于或低于正确值的值而出错。由于 MSE 是预测与正确结果之间的平方差,因此使用此指标你将始终得到正值。

这是计算上次预测误差的完整表达式:>>>

In [24]: target = 0

In [25]: mse = np.square(prediction - target)

In [26]: print(f"Prediction: {prediction}; Error: {mse}")
Out[26]: Prediction: [0.87101915]; Error: [0.7586743596667225]

在上面的例子中,错误是0.75。将差值乘以自身的一个含义是更大的误差会产生更大的影响,而更小的误差会随着它们的减少而变得越来越小。

了解如何减少错误

目标是更改权重和偏差变量,以便减少错误。要了解这是如何工作的,你将仅更改权重变量并暂时保持偏差不变。你也可以去掉 sigmoid 函数,只使用layer_1. 剩下的就是弄清楚如何修改权重以减少错误。

你通过执行 来计算 MSE error = np.square(prediction - target)。如果你把它(prediction - target)当作一个单一的变量x,那么你有error = np.square(x),它是一个二次函数。如果绘制它,该函数的外观如下所示:

Python AI:如何构建神经网络并进行预测?
二次函数图

误差由 y 轴给出。如果你正确A并希望将误差减少到 0,那么你需要x降低该值。另一方面,如果你有把握B并希望减少错误,那么你需要提高x价值。要知道应该朝哪个方向减少误差,你将使用导数。导数准确地解释了模式将如何变化

导数的另一个词是梯度梯度下降是用于寻找方向和更新网络参数的速率的算法的名称。

注意:要了解有关梯度下降背后的数学的更多信息,请查看使用 Python 和 NumPy 的随机梯度下降算法。

Python构建神经网络示例:在本教程中,你不会专注于导数背后的理论,因此你只需将导数规则应用于你将遇到的每个函数。该电源规则规定,导数xⁿNX ⁽  ⁻¹⁾。所以 的导数np.square(x)2 * x, 的导数x1

请记住,错误表达式是error = np.square(prediction - target). 当你将其(prediction - target)视为单个变量时x,误差的导数为2 * x。通过取这个函数的导数,你想知道你应该向哪个方向改变x以使结果error为零,从而减少误差。

当涉及到你的神经网络时,导数会告诉你更新权重变量应该采取的方向。如果它是一个正数,那么你预测的太高了,你需要降低权重。如果是负数,那么你预测的太低了,你需要增加权重。

现在是时候编写代码来弄清楚如何更新weights_1之前的错误预测。如果均方误差为0.75,那么你应该增加还是减少权重?由于导数为2 * x,你只需将预测与目标之间的差异乘以2:>>>

In [27]: derivative = 2 * (prediction - target)

In [28]: print(f"The derivative is {derivative}")
Out[28]: The derivative is: [1.7420383]

结果是1.74,一个正数,所以你需要减少权重。你可以通过减去权重向量的导数结果来实现。现在你可以相应地更新weights_1并再次预测以查看它如何影响预测结果:>>>

In [29]: # Updating the weights
In [30]: weights_1 = weights_1 - derivative

In [31]: prediction = make_prediction(input_vector, weights_1, bias)

In [32]: error = (prediction - target) ** 2

In [33]: print(f"Prediction: {prediction}; Error: {error}")
Out[33]: Prediction: [0.01496248]; Error: [0.00022388]

错误下降到几乎0!很漂亮吧?在这个例子中,微分结果很小,但有些情况下微分结果太高。以二次函数的图像为例。高增量并不理想,因为你可以从一个点A一直到另一个点B,永远不会接近零。为了解决这个问题,你可以使用衍生结果的一小部分来更新权重。

要定义用于更新权重的分数,你可以使用alpha参数,也称为学习率。如果你降低学习率,那么增量会更小。如果增加它,则步骤更高。你怎么知道最好的学习率值是多少?通过猜测和试验。

注:传统的默认学习速率值是0.10.010.001

如果你采用新的权重并使用第一个输入向量进行预测,那么你将看到现在它对该向量进行了错误的预测。如果你的神经网络对训练集中的每个实例都做出了正确的预测,那么你可能有一个过拟合的模型,其中模型只记住如何对示例进行分类,而不是学习注意数据中的特征。

有一些技术可以避免这种情况,包括对随机梯度下降进行正则化。在本教程中,你将使用在线随机梯度下降。

现在你知道如何计算误差以及如何相应地调整权重,是时候回去继续构建你的神经网络了。

应用链式法则

Python如何构建神经网络?在你的神经网络中,你需要更新权重偏置向量。你用来测量误差的函数取决于两个自变量,权重和偏差。由于权重和偏差是自变量,你可以更改和调整它们以获得你想要的结果。

你正在构建的网络有两层,并且由于每一层都有自己的功能,因此你正在处理一个功能组合。这意味着错误函数仍然是np.square(x),但现在x是另一个函数的结果。

重申这个问题,现在你想知道如何改变weights_1bias减少错误。你已经看到你可以为此使用导数,但现在你拥有一个使用其他函数生成结果的函数,而不是内部只有和的函数。

由于现在你有了这个函数组合,要获取有关参数的误差的导数,你需要使用微积分中的链式法则。使用链式法则,你可以获取每个函数的偏导数,评估它们,然后将所有偏导数相乘以获得所需的导数。

现在你可以开始更新权重。你想知道如何更改权重以减少错误。这意味着你需要计算误差对权重的导数。由于误差是通过组合不同的函数来计算的,因此你需要取这些函数的偏导数。

下面是如何应用链式法则来找到误差相对于权重的导数的直观表示:

Python AI:如何构建神经网络并进行预测?
显示神经网络内部偏导数的图表

粗体红色箭头显示你想要的导数,derror_dweights。你将从红色六边形开始,采用逆向路径进行预测并计算每个函数的偏导数

在上图中,每个函数由黄色六边形表示,偏导数由左侧的灰色箭头表示。应用链式法则, 的值derror_dweights将如下:

derror_dweights = (
    derror_dprediction * dprediction_dlayer1 * dlayer1_dweights
)

要计算导数,你可以将遵循从误差六边形(红色)到找到权重的六边形(最左边的绿色)的路径的所有偏导数相乘。

你可以说的导数y = f(x)是导数f相对于x。使用此命名法,对于derror_dprediction,你想知道计算相对于预测值的误差的函数的导数。

这个反向路径称为反向传递。在每次向后传递中,你计算​​每个函数的偏导数,用它们的值替换变量,最后将所有值相乘。

这个“取偏导数、求值和乘法”部分就是你如何应用链式法则。这种更新神经网络参数的算法称为反向传播

如何构建神经网络并进行预测?使用反向传播调整参数

在本节中,你将逐步完成反向传播过程,从如何更新偏差开始。你想取误差函数关于偏差的导数,derror_dbias。然后你将继续向后走,取偏导数,直到找到bias变量。

由于你是从末尾开始向后移动,因此你首先需要针对预测取误差的偏导数。就是derror_dprediction下图中的:

Python AI:如何构建神经网络并进行预测?
显示用于计算偏置梯度的偏导数的图表

产生误差的函数是一个平方函数,这个函数的导数是2 * x,正如你之前看到的。你应用了一阶偏导数 ( derror_dprediction) 并且仍然没有得到偏差,因此你需要再退一步并获取关于前一层的预测导数,dprediction_dlayer1

预测是 sigmoid 函数的结果。你可以通过乘以sigmoid(x)和来获得 sigmoid 函数的导数1 - sigmoid(x)。这个导数公式非常方便,因为你可以使用已经计算出的 sigmoid 结果来计算它的导数。然后你取这个偏导数并继续倒退。

现在你将取layer_1关于偏差的导数。就是这样——你终于做到了!该bias变量是一个自变量,所以应用幂律后的结果是1。很酷,既然你已经完成了这个反向传递,你可以把所有东西放在一起并计算derror_dbias:>>>

In [36]: def sigmoid_deriv(x):
   ...:     return sigmoid(x) * (1-sigmoid(x))

In [37]: derror_dprediction = 2 * (prediction - target)
In [38]: layer_1 = np.dot(input_vector, weights_1) + bias
In [39]: dprediction_dlayer1 = sigmoid_deriv(layer_1)
In [40]: dlayer1_dbias = 1

In [41]: derror_dbias = (
   ...:     derror_dprediction * dprediction_dlayer1 * dlayer1_dbias
   ...: )

要更新权重,你遵循相同的过程,向后取偏导数,直到到达权重变量。由于你已经计算了一些偏导数,你只需要计算dlayer1_dweights。点积的导数是第一个向量乘以第二个向量的导数,再加上第二个向量乘以第一个向量的导数。

Python实现神经网络:创建神经网络类

现在你知道如何编写表达式来更新权重和偏差。是时候为神经网络创建一个了。类是面向对象编程 (OOP)的主要构建块。将NeuralNetwork类生成的权重和偏置随机变量的初始值。

实例化NeuralNetwork对象时,需要传递learning_rate参数。你将用于predict()进行预测。你在本节中学到的方法_compute_derivatives()_update_parameters()计算。这是最后一NeuralNetwork堂课:

class NeuralNetwork:
    def __init__(self, learning_rate):
        self.weights = np.array([np.random.randn(), np.random.randn()])
        self.bias = np.random.randn()
        self.learning_rate = learning_rate

    def _sigmoid(self, x):
        return 1 / (1 + np.exp(-x))

    def _sigmoid_deriv(self, x):
        return self._sigmoid(x) * (1 - self._sigmoid(x))

    def predict(self, input_vector):
        layer_1 = np.dot(input_vector, self.weights) + self.bias
        layer_2 = self._sigmoid(layer_1)
        prediction = layer_2
        return prediction

    def _compute_gradients(self, input_vector, target):
        layer_1 = np.dot(input_vector, self.weights) + self.bias
        layer_2 = self._sigmoid(layer_1)
        prediction = layer_2

        derror_dprediction = 2 * (prediction - target)
        dprediction_dlayer1 = self._sigmoid_deriv(layer_1)
        dlayer1_dbias = 1
        dlayer1_dweights = (0 * self.weights) + (1 * input_vector)

        derror_dbias = (
            derror_dprediction * dprediction_dlayer1 * dlayer1_dbias
        )
        derror_dweights = (
            derror_dprediction * dprediction_dlayer1 * dlayer1_dweights
        )

        return derror_dbias, derror_dweights

    def _update_parameters(self, derror_dbias, derror_dweights):
        self.bias = self.bias - (derror_dbias * self.learning_rate)
        self.weights = self.weights - (
            derror_dweights * self.learning_rate
        )

你有它:这是你的第一个神经网络的代码。恭喜!这段代码只是把你目前看到的所有部分放在一起。如果要进行预测,请首先创建 的实例NeuralNetwork(),然后调用.predict():>>>

In [42]: learning_rate = 0.1

In [43]: neural_network = NeuralNetwork(learning_rate)

In [44]: neural_network.predict(input_vector)
Out[44]: array([0.79412963])

上面的代码做了一个预测,但现在你需要学习如何训练网络。目标是使网络在训练数据集上泛化。这意味着你希望它适应与训练数据集具有相同概率分布的新的、看不见的数据。这就是你将在下一部分中执行的操作。

用更多数据训练网络

你已经为一个数据实例调整了权重和偏差,但目标是使网络泛化整个数据集。随机梯度下降是一种技术,在该技术中,模型在每次迭代时根据随机选择的训练数据进行预测、计算误差并更新参数。

现在是创建类的train()方法的时候了NeuralNetwork。你将每 100 次迭代保存所有数据点的误差,因为你想要绘制一个图表,显示该指标如何随着迭代次数的增加而变化。这是train()你的神经网络的最终方法,Python实现神经网络示例:

class NeuralNetwork:
    # ...

    def train(self, input_vectors, targets, iterations):
        cumulative_errors = []
        for current_iteration in range(iterations):
            # Pick a data instance at random
            random_data_index = np.random.randint(len(input_vectors))

            input_vector = input_vectors[random_data_index]
            target = targets[random_data_index]

            # Compute the gradients and update the weights
            derror_dbias, derror_dweights = self._compute_gradients(
                input_vector, target
            )

            self._update_parameters(derror_dbias, derror_dweights)

            # Measure the cumulative error for all the instances
            if current_iteration % 100 == 0:
                cumulative_error = 0
                # Loop through all the instances to measure the error
                for data_instance_index in range(len(input_vectors)):
                    data_point = input_vectors[data_instance_index]
                    target = targets[data_instance_index]

                    prediction = self.predict(data_point)
                    error = np.square(prediction - target)

                    cumulative_error = cumulative_error + error
                cumulative_errors.append(cumulative_error)

        return cumulative_errors

如何构建神经网络并进行预测?上面的代码块中发生了很多事情,所以这里逐行分解:

  • 第 8 行从数据集中随机选取一个实例。
  • 第 14 到 16 行计算偏导数并返回偏差和权重的导数。他们使用_compute_gradients()你之前定义的 。
  • 第 18 行使用_update_parameters()你在前一个代码块中定义的更新偏差和权重。
  • 第 21 行检查当前迭代索引是否是 的倍数100。你这样做是为了观察错误在每次100迭代中的变化情况。
  • 第 24 行开始遍历所有数据实例的循环。
  • 第 28 行计算prediction结果。
  • 第 29 行计算error每个实例的 。
  • 第 31 行是你使用cumulative_error变量累积误差总和的地方。你这样做是因为你想为所有数据实例绘制一个带有错误的点。然后,在第 32 行,将 附加errorcumulative_errors存储错误的数组。你将使用此数组绘制图形。

简而言之,你从数据集中选择一个随机实例,计算梯度,并更新权重和偏差。你还可以每 100 次迭代计算一次累积误差,并将这些结果保存在一个数组中。你将绘制此数组以可视化训练过程中误差的变化情况。

注意:如果你在 Jupyter Notebook 中运行代码,那么你需要在添加train()NeuralNetwork类后重新启动内核。

Python如何构建神经网络?为了让事情不那么复杂,你将使用一个只有 8 个实例的数据集,即input_vectors数组。现在你可以调用train()并使用 Matplotlib 绘制每次迭代的累积误差:>>>

In [45]: # Paste the NeuralNetwork class code here
   ...: # (and don't forget to add the train method to the class)

In [46]: import matplotlib.pyplot as plt

In [47]: input_vectors = np.array(
   ...:     [
   ...:         [3, 1.5],
   ...:         [2, 1],
   ...:         [4, 1.5],
   ...:         [3, 4],
   ...:         [3.5, 0.5],
   ...:         [2, 0.5],
   ...:         [5.5, 1],
   ...:         [1, 1],
   ...:     ]
   ...: )

In [48]: targets = np.array([0, 1, 0, 1, 0, 1, 1, 0])

In [49]: learning_rate = 0.1

In [50]: neural_network = NeuralNetwork(learning_rate)

In [51]: training_error = neural_network.train(input_vectors, targets, 10000)

In [52]: plt.plot(training_error)
In [53]: plt.xlabel("Iterations")
In [54]: plt.ylabel("Error for all training instances")
In [54]: plt.savefig("cumulative_error.png")

NeuralNetwork再次实例化该类并train()使用input_vectorstarget值进行调用。你指定它应该运行10000时间。这是显示神经网络实例的错误的图表:

Python AI:如何构建神经网络并进行预测?
显示累积训练误差的图表

总体误差正在减少,这就是你想要的。该图像在你运行 IPython 的同一目录中生成。在最大的减少之后,误差会从一个交互到另一个交互快速上升和下降。那是因为数据集是随机的,而且非常小,所以神经网络很难提取任何特征。

但使用此指标评估性能并不是一个好主意,因为你正在使用网络已经看到的数据实例对其进行评估。这可能会导致过度拟合,当模型非常适合训练数据集而无法推广到新数据时。

Python构建神经网络示例:向神经网络添加更多层

出于学习目的,本教程中的数据集很小。通常,深度学习模型需要大量数据,因为数据集更为复杂且有很多细微差别。

由于这些数据集具有更复杂的信息,因此仅使用一两层是不够的。这就是深度学习模型被称为“深度”的原因。它们通常有很多层。

通过添加更多层和使用激活函数,你可以提高网络的表达能力并可以进行非常高级的预测。这些类型的预测的一个例子是人脸识别,例如当你用手机拍下你的脸时,如果手机识别出你的图像,它就会解锁。

Python实现神经网络结论

恭喜!今天,你使用 NumPy 从头构建了一个神经网络。有了这些知识,你就可以更深入地探索 Python 中的人工智能世界了。

如何构建神经网络并进行预测?在本教程中,你学习了:

  • 什么是深度学习以及它与机器学习的区别
  • 如何用 NumPy表示向量
  • 什么是激活函数以及为什么在神经网络中使用它们
  • 什么是反向传播算法以及它是如何工作的
  • 如何训练神经网络并进行预测

Python如何构建神经网络?训练神经网络的过程主要包括对向量应用运算。今天,你从头开始仅使用 NumPy 作为依赖项。在生产环境中不建议这样做,因为整个过程可能效率低下且容易出错。这就是为什么像深刻的学习框架的原因之一Keras,PyTorch和TensorFlow是如此受欢迎。

木子山

发表评论

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: