深度学习神经网络基本概念与Python数据分析进阶教程

时间：2026-06-13 15:34

神经元通过加权求和与激活函数输出信号，多个神经元组成输入层、隐藏层和输出层实现特征提取。前向传播逐层计算得到输出，反向传播利用梯度下降调整权重和偏置以最小化损失函数。Python代码示例展示了神经网络的基本实现过程。

用Python进行AI数据分析进阶教程61：深度学习神经网络核心概念与实践

61、深度学习神经网络的基本概念【用Python进行AI数据分析进阶教程】

深度学习神经网络基本原理与核心概念

关键词：神经元、激活函数、前向传播、反向传播、损失函数、梯度下降

摘要：本文系统讲解神经网络的核心概念，涵盖神经元的结构与功能、网络层的组成方式、前向传播与反向传播的工作机制。神经元作为神经网络的基础计算单元，接收输入信号，通过加权求和与激活函数处理后输出结果。多个神经元组成不同的网络层（输入层、隐藏层、输出层），实现特征的逐层提取与最终预测。前向传播负责数据从输入层到输出层的逐层传递，而反向传播则利用梯度下降法调整权重与偏置，以最小化损失函数，持续提升模型精度。文章同时提供简洁的Python代码示例，演示神经网络的基本实现流程，并强调参数初始化、激活函数选择及学习率设定对模型性能的重要影响。

在学习神经网络之前，我们首先需要理解其最基本的构成单元——神经元。它类似于人脑中的神经细胞，能够接收外部信号，经过加权求和与激活函数处理后，再输出结果。一旦掌握这个基础，后续的神经网络层、前向传播与反向传播也就更容易理解了。

一、神经元

神经元是神经网络中的基础计算单元，结构上可比拟生物神经元。它接收多个输入信号，对这些输入进行加权求和，再通过激活函数进行非线性变换，最终产生输出。

这里需要掌握几个关键要素：

加权求和：每个输入都对应一个权重，神经元将输入与对应权重相乘后求和，再加上偏置。
激活函数：为网络引入非线性能力，使其能够学习复杂模式。常用的激活函数包括 Sigmoid、ReLU 等。

特别值得注意：激活函数的选择会直接影响网络的性能与训练速度。权重的初始化同样至关重要，不恰当的初始化可能导致梯度消失或梯度爆炸问题。

具体实例：一个简单的神经元接收两个输入 x1 和 x2，对应的权重为 w1 和 w2，偏置为 b，经过加权求和和 Sigmoid 激活函数后输出。

代码实现如下：

# 导入 numpy 库，它是 Python 中用于科学计算的基础库，
# 提供了强大的多维数组对象和处理这些数组的函数
import numpy as np

# 定义 sigmoid 激活函数，该函数接收一个数值 x，返回 1 / (1 + e^(-x)) 的值
# sigmoid 函数常用于神经网络中，将输入值映射到 (0, 1) 区间，为神经元引入非线性特性
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

# 定义输入向量 x，这里使用 numpy 数组表示，包含两个元素 0.5 和 0.3
# 可以把这个输入向量看作是某个神经元接收到的外部信号
x = np.array([0.5, 0.3])

# 定义权重向量 w，同样使用 numpy 数组表示，包含两个元素 0.2 和 0.4
# 权重用于衡量输入信号的重要程度，不同的权重会对输入信号产生不同的影响
w = np.array([0.2, 0.4])

# 定义偏置值 b，它是一个标量，值为 0.1
# 偏置的作用是为神经元的输出提供一个基础的偏移量，有助于模型更好地拟合数据
b = 0.1

# 进行加权求和操作，np.dot(x, w) 计算输入向量 x 和权重向量 w 的点积
# 点积运算将输入向量的每个元素与对应的权重元素相乘，然后将结果相加
# 再加上偏置值 b，得到神经元的净输入 z
z = np.dot(x, w) + b

# 将加权求和的结果 z 输入到 sigmoid 激活函数中，得到神经元的最终输出
# 激活函数会对净输入进行非线性变换，使神经元能够学习到更复杂的模式
output = sigmoid(z)

# 打印神经元的最终输出结果
print(output)

输出结果及解析：运行上述代码后，会输出一个介于 0 和 1 之间的数值，示例输出如下：

0.5683760438232362

这个输出结果是神经元经过加权求和和 sigmoid 激活函数处理后得到的最终输出值。由于 sigmoid 函数将输入映射到 (0, 1) 区间，所以输出值稳定在这个范围内。这个值可以被理解为神经元对输入信号处理后给出的响应，在实际应用中可能代表某种概率或分类结果。例如，在二分类问题中，该值可直接表示样本属于某一类别的概率。

代码中的核心环节：

sigmoid 函数实现了 Sigmoid 激活函数的计算逻辑。
np.dot(x, w) 计算输入与权重的点积，即加权求和的一部分。
z = np.dot(x, w) + b 完成加权求和并加上偏置。
output = sigmoid(z) 通过激活函数得到神经元的最终输出。

二、神经网络层

单个神经元的能力有限，将多个神经元组合起来便构成了神经网络层。常见的层次结构包括输入层、隐藏层和输出层。输入层负责接收原始数据，隐藏层对数据进行特征提取与非线性变换，输出层则给出最终的预测结果。

需要掌握的核心要点：

层的连接方式：相邻层的神经元之间通常采用全连接方式，即每个神经元与下一层的所有神经元都建立连接。
层的深度：增加隐藏层的数量可以提升网络的表达能力，但同时也会增加训练难度和计算开销。

实际操作中需留意：隐藏层的数量及每层神经元的个数需要根据具体问题灵活调整，过多或过少都可能影响最终性能。不同层也可以选用不同的激活函数，以适应不同的数据分布。

举例说明：一个简单的三层神经网络，包含一个输入层（2 个神经元）、一个隐藏层（3 个神经元）和一个输出层（1 个神经元）。

代码实现如下：

# 导入 numpy 库，numpy 是 Python 中用于科学计算的基础库，
# 提供了多维数组对象和处理这些数组的函数
import numpy as np

# 定义 sigmoid 激活函数，它会将输入值 x 通过公式 1 / (1 + e^(-x)) 进行转换
# sigmoid 函数的输出范围是 (0, 1)，常被用于神经网络中引入非线性特征
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

# 输入数据，这里使用 numpy 数组表示，它是一个一维数组，包含两个元素 0.5 和 0.3
# 可以将其看作是输入层接收到的原始数据
x = np.array([0.5, 0.3])

# 输入层到隐藏层的权重矩阵 w1，它是一个 3 行 2 列的二维 numpy 数组
# 每一行代表隐藏层中一个神经元与输入层神经元连接的权重
w1 = np.array([[0.2, 0.4], [0.1, 0.3], [0.3, 0.2]])

# 隐藏层的偏置向量 b1，它是一个一维的 numpy 数组，包含三个元素
# 每个元素对应隐藏层中一个神经元的偏置值
b1 = np.array([0.1, 0.2, 0.1])

# 隐藏层到输出层的权重向量 w2，它是一个一维的 numpy 数组，包含三个元素
# 每个元素代表隐藏层中一个神经元与输出层神经元连接的权重
w2 = np.array([0.2, 0.3, 0.4])

# 输出层的偏置值 b2，它是一个标量
# 用于调整输出层神经元的输出
b2 = 0.1

# 计算隐藏层的输入 z1
# np.dot(w1, x) 实现了输入数据 x 与权重矩阵 w1 的点积运算
# 然后将点积结果与偏置向量 b1 相加，得到隐藏层每个神经元的输入值
z1 = np.dot(w1, x) + b1

# 计算隐藏层的输出 h
# 将隐藏层的输入 z1 传入 sigmoid 激活函数进行处理
# 得到隐藏层每个神经元经过激活后的输出值
h = sigmoid(z1)

# 计算输出层的输入 z2
# np.dot(w2, h) 实现了隐藏层输出 h 与权重向量 w2 的点积运算
# 然后将点积结果与偏置值 b2 相加，得到输出层神经元的输入值
z2 = np.dot(w2, h) + b2

# 计算输出层的输出 output
# 将输出层的输入 z2 传入 sigmoid 激活函数进行处理
# 得到整个神经网络的最终输出值
output = sigmoid(z2)

# 打印神经网络的最终输出结果
print(output)

输出结果及解析：运行上述代码后，会得到一个介于 0 和 1 之间的数值，示例输出如下：

0.6270208884304376

这个输出值是整个简单神经网络经过前向传播计算后得到的最终结果。由于使用了 sigmoid 激活函数，输出值被映射到了 (0, 1) 区间。在实际应用场景中，这个值可以代表不同的含义，例如在二分类问题里，可将其视为样本属于某一类别的概率。

代码关键解读：

w1 和 w2 分别是输入层到隐藏层、隐藏层到输出层的权重矩阵。
b1 和 b2 分别是隐藏层和输出层的偏置向量。
z1 = np.dot(w1, x) + b1 计算隐藏层的输入。
h = sigmoid(z1) 计算隐藏层的输出。
z2 = np.dot(w2, h) + b2 计算输出层的输入。
output = sigmoid(z2) 计算输出层的输出。

三、前向传播

前向传播是指数据从输入层经过隐藏层传递到输出层的过程，通过逐层计算加权求和与激活函数，最终得到网络的输出结果。

核心要点非常直接：

逐层计算：按照网络的层次结构，依次计算每一层的输出。
信息传递：将前一层的输出作为下一层的输入，逐步向前推进。

实际操作中需注意：计算过程中要确保矩阵乘法的维度匹配。激活函数的选择会直接影响前向传播的数值结果。

具体例子：上述的三层神经网络的前向传播过程，代码同上，这里就不再重复了。

四、反向传播

前向传播完成后，网络给出了一个输出，但这个输出与真实答案之间通常会存在差距。如何缩小这个差距？这就需要反向传播算法。它是训练神经网络的核心方法，通过计算损失函数对每个权重和偏置的梯度，然后利用梯度下降法更新这些参数，以最小化损失函数。

关键要素包括：

损失函数：衡量网络输出与真实标签之间的差异，常用损失函数有均方误差（MSE）、交叉熵损失等。
梯度计算：借助链式法则，计算损失函数对每个参数的偏导数（梯度）。
参数更新：根据梯度的大小和方向调整权重与偏置，通常使用学习率来控制更新的步长。

有几个常见陷阱需要避开：学习率的选择极为关键，过大可能导致无法收敛，过小则会使训练速度过慢。梯度消失或梯度爆炸问题会影响训练效果，因此需要选择合适的激活函数和参数初始化策略。

举例说明：使用简单的两层神经网络完成二分类任务，通过反向传播迭代更新权重和偏置。

代码直接呈现：

import numpy as np

# 定义激活函数及其导数
# 定义 sigmoid 激活函数，它将输入值映射到 (0, 1) 区间，常用于神经网络中引入非线性
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

# 定义 sigmoid 函数的导数，用于反向传播时计算梯度
def sigmoid_derivative(x):
    return x * (1 - x)

# 输入数据
# 这是一个 4x2 的二维数组，代表有 4 个样本，每个样本有 2 个特征
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])

# 真实标签
# 这是一个 4x1 的二维数组，代表 4 个样本对应的真实标签
y = np.array([[0], [1], [1], [0]])

# 随机初始化权重
# 设置随机数种子为 1，确保每次运行代码时随机数生成的结果一致，方便调试和复现
np.random.seed(1)

# 初始化输入层到隐藏层的权重矩阵，形状为 (2, 4)，
# 即输入层有 2 个神经元，隐藏层有 4 个神经元
# 权重值在 [-1, 1) 之间随机生成
weights0 = 2 * np.random.random((2, 4)) - 1

# 初始化隐藏层到输出层的权重矩阵，形状为 (4, 1)，
# 即隐藏层有 4 个神经元，输出层有 1 个神经元
# 权重值在 [-1, 1) 之间随机生成
weights1 = 2 * np.random.random((4, 1)) - 1

# 学习率
# 学习率控制了每次权重更新的步长，过大可能导致无法收敛，过小则会使训练速度变慢
learning_rate = 0.1

# 训练迭代次数
# 表示整个训练过程中，将对所有样本进行 10000 次迭代训练
epochs = 10000

# 开始训练循环
for epoch in range(epochs):
    # 前向传播
    # layer0 就是输入层，直接赋值为输入数据 X
    layer0 = X
    # 计算隐藏层的输入，通过输入层与权重矩阵 weights0 做点积，
    # 然后将结果传入 sigmoid 激活函数
    layer1 = sigmoid(np.dot(layer0, weights0))
    # 计算输出层的输入，通过隐藏层与权重矩阵 weights1 做点积，
    # 然后将结果传入 sigmoid 激活函数
    layer2 = sigmoid(np.dot(layer1, weights1))

    # 计算损失
    # 计算输出层的误差，即真实标签 y 与输出层的输出 layer2 之间的差值
    layer2_error = y - layer2

    # 反向传播
    # 计算输出层的梯度，
    # 通过误差 layer2_error 乘以 sigmoid 函数的导数 sigmoid_derivative(layer2)
    layer2_delta = layer2_error * sigmoid_derivative(layer2)

    # 计算隐藏层的误差，通过输出层的梯度 layer2_delta 与权重矩阵 weights1 的转置做点积
    layer1_error = layer2_delta.dot(weights1.T)

    # 计算隐藏层的梯度，通过隐藏层的误差 layer1_error 
    # 乘以 sigmoid 函数的导数 sigmoid_derivative(layer1)
    layer1_delta = layer1_error * sigmoid_derivative(layer1)

    # 更新权重
    # 更新隐藏层到输出层的权重矩阵，通过学习率乘以隐藏层输出的转置与输出层梯度的点积
    weights1 += learning_rate * layer1.T.dot(layer2_delta)
    # 更新输入层到隐藏层的权重矩阵，通过学习率乘以输入层输出的转置与隐藏层梯度的点积
    weights0 += learning_rate * layer0.T.dot(layer1_delta)

    # 每 1000 次迭代打印一次损失值
    if epoch % 1000 == 0:
        # 计算平均绝对误差作为损失值
        print(f"Epoch {epoch}: Loss = {np.mean(np.abs(layer2_error))}")

# 打印训练后的最终输出
print("Final output after training:")
print(layer2)

输出结果及解析：

（1）训练过程中的损失输出：在训练过程中，每 1000 次迭代会打印一次损失值，示例输出如下：

Epoch 0: Loss = 0.4963223369400464
Epoch 1000: Loss = 0.02312523038363046
Epoch 2000: Loss = 0.01963742367771122
Epoch 3000: Loss = 0.01782771494000314
Epoch 4000: Loss = 0.01668770803238463
Epoch 5000: Loss = 0.01590140087013971
Epoch 6000: Loss = 0.015317104073283232
Epoch 7000: Loss = 0.01487712340330345
Epoch 8000: Loss = 0.014543440366179964
Epoch 9000: Loss = 0.014285454393128697

这些输出清晰展示了随着训练迭代次数的增加，损失值逐步下降，说明模型在不断学习，预测结果越来越贴近真实标签。

（2）最终输出：

Final output after training:
[[0.00431706]
 [0.99543723]
 [0.99541771]
 [0.00436144]]

这是训练完成后模型对输入数据 X 的最终预测结果。可以看到，模型的预测结果已经非常接近真实标签 y，验证了反向传播与梯度下降的有效性。例如，第一个样本 [0, 0] 的预测结果接近 0，第二个样本 [0, 1] 的预测结果接近 1，以此类推。

代码重点语句解读：

sigmoid_derivative 函数实现了 Sigmoid 函数的导数，用于反向传播时梯度计算。
layer0 = X 表示输入层。
layer1 = sigmoid(np.dot(layer0, weights0)) 和 layer2 = sigmoid(np.dot(layer1, weights1)) 完成前向传播。
layer2_error = y - layer2 计算输出层的误差。
layer2_delta = layer2_error * sigmoid_derivative(layer2) 计算输出层的梯度。
layer1_error = layer2_delta.dot(weights1.T) 计算隐藏层的误差。
layer1_delta = layer1_error * sigmoid_derivative(layer1) 计算隐藏层的梯度。
weights1 += learning_rate * layer1.T.dot(layer2_delta) 和 weights0 += learning_rate * layer0.T.dot(layer1_delta) 更新权重。