目录

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

在生产环境中，您将使用TensorFlow或PyTorch等深度学习框架，而不是构建自己的神经网络。也就是说，了解神经网络的工作原理是有帮助的，因为您可以使用它来更好地构建深度学习模型。

在本教程中，您将学习：

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

让我们开始吧！

人工智能概述

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

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

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

训练机器学习模型的工作流

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

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

神经网络：主要概念

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

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

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

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

在下图中，您可以看到具有两层的网络架构示例：

一个两层的神经网络

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

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

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

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

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

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

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

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

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

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

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

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

您可以使用 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_vector和weights_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_vector和weights_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_vector和weights_2是4.1259，和4.1259大于2.1672，则意味着input_vector更类似于weights_2。您将在神经网络中使用相同的机制。

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

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

做出你的第一个预测

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

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

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

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

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

Sigmoid函数公式

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

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

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

神经网络内部的计算流程

黄色六边形代表函数，蓝色矩形代表中间结果。现在是时候将所有这些知识转化为代码了。您还需要用 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]

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)，它是一个二次函数。如果绘制它，该函数的外观如下所示：

二次函数图

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

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

在本教程中，您不会专注于导数背后的理论，因此您只需将导数规则应用于您将遇到的每个函数。该电源规则规定，导数xⁿ是NX ⁽ ⁿ ⁻¹⁾。所以 的导数np.square(x)是2 * x， 的导数x是1。

请记住，错误表达式是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参数，也称为学习率。如果你降低学习率，那么增量会更小。如果增加它，则步骤更高。你怎么知道最好的学习率值是多少？通过猜测和试验。

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

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

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

应用链式法则

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

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

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

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

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

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

显示神经网络内部偏导数的图表

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

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

derror_dweights = (
    derror_dprediction * dprediction_dlayer1 * dlayer1_dweights
)

显示用于计算偏置梯度的偏导数的图表

产生误差的函数是一个平方函数，这个函数的导数是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。点积的导数是第一个向量乘以第二个向量的导数，再加上第二个向量乘以第一个向量的导数。

创建神经网络类

现在您知道如何编写表达式来更新权重和偏差。是时候为神经网络创建一个类了。类是面向对象编程 (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])

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()您在上一个代码块中定义的更新偏差和权重。

• Line 21 checks if the current iteration index is a multiple of 100. You do this to observe how the error changes every 100 iterations.

• Line 24 starts the loop that goes through all the data instances.

• Line 28 computes the prediction result.

• Line 29 computes the error for every instance.

• Line 31 is where you accumulate the sum of the errors using the cumulative_error variable. You do this because you want to plot a point with the error for all the data instances. Then, on line 32, you append the error to cumulative_errors, the array that stores the errors. You’ll use this array to plot the graph.

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

为了让事情不那么复杂，您将使用一个只有 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_vectors和target值进行调用。您指定它应该运行10000时间。这是显示神经网络实例的错误的图表：

显示累积训练误差的图表

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

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

【生长吧！Python】有奖征文火热进行中：https://bbs.huaweicloud.cn/blogs/278897