飞哥学习人工智能之路第二讲:神经网络本文将带你从宏观到微观深入理解人工智能：梳理人工智能的三大流派及其演进逻辑。核心机

作为一线程序员高强度使用各种AI大模型和工具近1年，我深刻感受到了AI大模型的强大和便捷，但是一直在应用层不知道底层原理，很多概念理解的似是而非，没有体系化的知识体系,所以开始了这个自学人工智能之路。
1.我会结合视频教程、文档、大模型等学习资源，将自己学习人工智能的过程做个整理和记录。
2.后续会结合实际使用的案例和项目（有实际工作中的项目，也有自己兴趣使然的作品），逐步讲解一些经验和教训,希望能给大家带来一些帮助。
3.其中的一些错误和共鸣点欢迎大家指正和交流。

第二讲：人工智能核心概念-神经网络

文章导读：本文将带你从宏观到微观深入理解人工智能：

宏观流派回顾：梳理人工智能的三大流派及其演进逻辑。

核心机制拆解：通过“下山”比喻和手算推演，彻底搞懂损失函数与梯度下降的核心原理。

工作流程揭秘：详解前向/反向传播的工作流程与链式法则的数学本质，揭示机器“学习”的奥秘。

📊 统计信息：全文约 13000 字 | 预计阅读时长 32 分钟

第一部分：人工智能的本质与流派

1.1 什么是人工智能

人工智能是指利用数字计算机或者由数字计算机控制的机器，模拟、延伸和扩展人类的智能，感知环境、获取知识并使用知识获得最佳结果的理论、方法、技术和应用系统。

1.2 核心理念：一切皆函数

Function，一切皆是函数。现实世界 -> 符号化 -> 抽象 -> 输出 -> 解释预测现实世界

1.3 发展历程的三大流派

1.3.1 符号主义 (Symbolism)

试图用各种定理（如逻辑定理、数学定理等）去抽象解释预测现实世界。

流程：
- 1. 抽象（如函数、算法等）
- 2. 输出（如结果、决策等）
- 3. 解释现实世界（如理解、预测等）
困境：由于现实世界问题的多维度和复杂性，直接将问题符号化并抽象化是非常困难的。
解决路线：承认人类的局限，通过已知的规律去拟合，使其符合大多数的情况。

1.3.2 联结主义 (Connectionism)

联结主义是指基于神经元之间的连接和交互来模拟人类智能的一种人工智能模型。它认为，人工智能系统由大量的简单神经元组成，这些神经元通过连接和交互来处理信息。联结主义的目标是通过训练和调整神经元之间的连接权重，使系统能够学习和执行各种任务。简单的说，联结主义就是模拟人类的神经元之间的连接和交互，来实现人工智能的功能。

核心思想：猜 + 简化处理很多实际中的高深模型只是个线性回归问题，比如房价预测、股票预测等。

f_0(x) = wx + b

演进过程与困境：
1. 困境1：非线性问题 很多问题都是非线性的，此时需要非线性函数，比如平方、sin、e、sigmoid、ReLU等。
  
  此时得到了激活函数：
```
f_1(x) = g(f_0(x))
```
  它的作用就是尽可能模拟符合所有数据（需要排除掉一些异常值）。
2. 困境2：多变量 存在多个变量的情况：
```
f_2(x_1, x_2) = g_1(f_1(x_1) + f_1(x_2))
```
3. 困境3：深度不足 一层激活函数可能模拟的还不够好，此时需要继续嵌套使用激活函数：
```
f_3(x_1, x_2) = g_2(f_2(x_1, x_2)) + b_2
```
4. 困境4：不可解释性与神经网络的诞生 太多层的函数嵌套会导致人类无法理解和解释。此时引入神经元概念，每个神经元都是一个函数，它的输入是上一层神经元的输出，输出是下一层神经元的输入。每个神经元都有自己的权重和偏置，通过训练和调整这些参数，使神经元能够学习和执行各种任务。
  
  多层激活函数可以表示多级链接，从而形成神经网络：
  
  最终的可能是很多层，虽然有时看起来很复杂，但是拆分到某一步可能就是很简单的一个函数：
  
  回到之前的问题，如果输入的参数比较多，根本看不出规律，此时该如何处理？

1.3.3 融合主义 (Fusionism)

以联结主义（特别是深度学习）强大的感知和学习能力为基础，融合符号主义的知识与逻辑推理，并结合行为主义的环境交互，最终构建出具备感知、认知、决策和行动能力的通用智能体（智能体），其实就是融合了符号主义和行为主义的优势。这个概念在很多领域都有应用，比如机器人、自动驾驶、智能客服等。这里只是引出这个概念，后续会详细讲解。

第二部分：揭秘神经网络的“学习”机制

接上一部分得到结论：神经网络的本质是激活函数嵌套线性函数，所以如何得到一个最好的线性函数是一个关键问题。

f(x) = wx + b

如何才能得到一个最理想的线性函数？

现在引出两个非常关键的概念：损失函数和梯度下降

2.1 核心概念：损失函数与梯度下降

2.1.1 核心概念拆解

损失函数 (Loss Function)：是用来衡量模型预测值与真实值之间差异的函数。它通常用于评估模型的性能，并指导优化算法的方向。
梯度下降 (Gradient Descent)：是一种优化算法，用于寻找函数的局部最小值。它通过迭代地更新参数，使函数值逐渐减小，最终到达一个局部最小值点。

理解了它们之间的关系，就真正把握了机器学习模型训练的核心逻辑。它们的关系可以概括为一句话：损失函数是“目标”，梯度下降是“方法”。

2.1.2 形象比喻：下山

梯度下降-下山比喻如果把训练模型比喻成**“下山”**：

损失函数 就是你所在的地形（哪块高，哪块低）。它告诉你“你现在所在的位置（当前的模型参数）有多糟糕，离山底（最优解）还有多远”。
梯度下降 就是你下山的策略（怎么迈腿）。它利用脚下的坡度（梯度），决定下一步往哪个方向走，才能最快地到达山底。

2.1.3 协同工作循环

这就是机器学习训练中最经典的一个循环：

前向传播（计算损失）： 用当前的参数做预测，然后代入损失函数，算出一个 Loss（误差值）。
反向传播（计算梯度）： 看看这个 Loss 是怎么来的，通过链式法则算出每个参数对 Loss 的影响程度（这就是梯度）。
参数更新（梯度下降）： 拿着这个梯度，按照梯度下降的规则（比如“沿着梯度反方向走一小步”）去更新参数。
重复： 回到第1步，用新参数继续算 Loss。随着循环进行，Loss 会越来越小，模型也越来越准。

总结：

损失函数 定义了 “你要去哪儿”（目标是让损失值最小）。
梯度下降 定义了 “怎么到达那里”（通过一步一步调整参数）。

可以这样理解：梯度下降是依据损失函数提供的梯度信息，来导航到最低点的过程。

学习到这里你肯定会和我有一样的疑问：损失函数有哪些形式？主要有两大类损失函数：回归损失（用于预测连续值，如温度、价格）和分类损失（用于预测类别，如是否为垃圾邮件）。

2.2 常见损失函数形式

2.2.1 回归损失 (Regression)

这类问题的特点是预测连续数值。

① 均方误差 (MSE)

英文：Mean Square Error
公式： $Loss = \frac{1}{n}\sum_{i=1}^{n} (y_i - \hat{y}_i)^2$
特点：
- 惩罚大误差：因为进行了平方，离群点的误差会被放大，惩罚严厉。
- 平滑：数学性质好，方便求导。
缺点：对异常值（Outliers）特别敏感。

② 平均绝对误差 (MAE)

英文：Mean Absolute Error
公式： $Loss = \frac{1}{n}\sum_{i=1}^{n} |y_i - \hat{y}_i|$
特点：
- 鲁棒性强：对异常值不那么敏感。
缺点：在误差接近0的地方不够光滑（有尖点），不易精确收敛。

③ Huber损失

特点：MSE和MAE的结合体。误差大时用MAE，误差小时用MSE。是很多回归任务的“万金油”。

2.2.2 分类损失 (Classification)

这类问题的特点是预测离散标签（如：猫还是狗？）。

① 交叉熵损失 (Cross Entropy)

别名：负对数似然
公式（二分类）： $Loss = -[y \log(\hat{y}) + (1-y) \log(1-\hat{y})]$
形象理解：如果模型很自信但猜错了，或者猜对了但不够自信，都会受到惩罚。它鼓励模型不仅要猜对，还要猜得笃定。
地位：深度学习和逻辑回归标配。

② Hinge Loss

适用：支持向量机 (SVM)。关注最大边界。

2.2.3 总结对比

任务类型	损失函数	核心思想	适用场景
回归	均方误差 (MSE)	惩罚大误差	简单回归，误差小且无异常值
	平均绝对误差 (MAE)	抗异常值	数据有较多异常值
	Huber	MSE + MAE 折中	稳健且光滑，万金油
分类	交叉熵 (Cross Entropy)	衡量概率分布差距	深度学习和逻辑回归标配
	Hinge	关注最大边界	支持向量机

2.3 实战推演：手算梯度下降

我们来一个最简单的例子来看下梯度下降具体优化过程，手把手演示梯度下降是如何一步步找到最优系数的。

场景设定：

数据：只有一个点 $(x, y) = (2, 4)$
模型： $\hat{y} = w x$ （为了简化，先不考虑截距，只求斜率 $w$ ）
损失函数：均方误差 MSE $Loss(w) = (\hat{y} - y)^2 = (w \cdot 2 - 4)^2$ 即 $Loss(w) = (2w - 4)^2$
目标：找到使 $Loss(w)$ 最小的 $w$ 。

2.3.1 第1步：写出损失函数并求导

$Loss(w) = (2w - 4)^2 = 4w^2 - 16w + 16$

对 $w$ 求导（梯度就是导数，因为这里只有一个参数）： $\frac{dLoss}{dw} = 8w - 16$

梯度含义：当 $w$ 取某个值时，这个导数告诉我们要让损失增加的方向。我们往反方向走，就能让损失下降。

2.3.2 第2步：初始化参数

设初始值： $w_0 = 0$ 学习率（步长） $\eta = 0.1$ （这个值要手工设定，不能太大也不能太小）。

2.3.3 第3步：开始迭代演算

迭代 1

当前 $w = 0$
计算梯度： $\nabla = 8 \times 0 - 16 = -16$
梯度为负，说明在 $w=0$ 处，向右走（增加 $w$ ）能让损失下降。
梯度下降更新公式： $w_{\text{新}} = w_{\text{旧}} - \eta \cdot \nabla$ 代入： $w_1 = 0 - 0.1 \times (-16) = 0 + 1.6 = 1.6$
计算新损失： $Loss(1.6) = (2\times 1.6 - 4)^2 = (3.2 - 4)^2 = (-0.8)^2 = 0.64$
初始损失 $Loss(0) = (0-4)^2 = 16$ ，损失从 16 降到了 0.64！

迭代 2

当前 $w = 1.6$
梯度： $\nabla = 8 \times 1.6 - 16 = 12.8 - 16 = -3.2$
更新： $w_2 = 1.6 - 0.1 \times (-3.2) = 1.6 + 0.32 = 1.92$
新损失： $(2\times 1.92 - 4)^2 = (3.84 - 4)^2 = (-0.16)^2 = 0.0256$

迭代 3

当前 $w = 1.92$
梯度： $\nabla = 8 \times 1.92 - 16 = 15.36 - 16 = -0.64$
更新： $w_3 = 1.92 - 0.1 \times (-0.64) = 1.92 + 0.064 = 1.984$
损失： $(3.968 - 4)^2 = (-0.032)^2 = 0.001024$

迭代 4

当前 $w = 1.984$
梯度： $\nabla = 8 \times 1.984 - 16 = 15.872 - 16 = -0.128$
更新： $w_4 = 1.984 - 0.1 \times (-0.128) = 1.984 + 0.0128 = 1.9968$
损失：约 0.00001

2.3.4 第4步：观察收敛

真实最优解是多少？ $Loss(w) = (2w - 4)^2 = 0 \Rightarrow 2w - 4 = 0 \Rightarrow w = 2$

我们的轨迹：

$w_0 = 0$
$w_1 = 1.6$
$w_2 = 1.92$
$w_3 = 1.984$
$w_4 = 1.9968$

可以看到， $w$ 在不断接近 2，损失在不断接近 0。如果继续迭代下去，会无限逼近 $w=2$ ，但理论上永远不会正好等于 2（除非学习率设置得特别巧妙），这就是“数值解”而非“解析解”的特点。

2.3.5 关键点复盘

迭代	$w$ 值	梯度	更新量	损失
0	0.0	-16	+1.6	16.0
1	1.6	-3.2	+0.32	0.64
2	1.92	-0.64	+0.064	0.0256
3	1.984	-0.128	+0.0128	0.001024
4	1.9968	-0.0256	+0.00256	≈0.000065

观察结论：

梯度越来越小：越接近最优解，坡度越缓，步子迈得越小。
损失下降越来越慢：这是正常现象，梯度下降后期需要更多步来微调。
更新量 = -学习率 × 梯度：梯度为负时，我们增加 $w$ ；梯度为正时，我们会减少 $w$ （虽然本例没出现）。

2.3.6 如果学习率不同会怎样？

$\eta = 0.01$ （太小）：从 0 出发，第一步只走到 0.16，要很多步才能到 2，训练太慢。
$\eta = 0.1$ （合适）：上面演示的，几步就接近了。
$\eta = 1.0$ （太大）：
- $w_0=0$ ，梯度 -16，更新： $w_1 = 0 - 1\times(-16) = 16$
- $w_1=16$ ，梯度 $8\times16-16=112$ ，更新： $w_2 = 16 - 1\times112 = -96$
- 直接震荡飞出去，无法收敛（发散）。

2.3.7 扩展到多元参数

如果模型是 $\hat{y} = w_1 x + w_0$ （有斜率和截距），损失函数是 $Loss(w_1, w_0)$ ，那么：

梯度是一个向量 $\left( \frac{\partial Loss}{\partial w_1}, \frac{\partial Loss}{\partial w_0} \right)$
更新时同时更新两个： $w_1 := w_1 - \eta \frac{\partial Loss}{\partial w_1}$ $w_0 := w_0 - \eta \frac{\partial Loss}{\partial w_0}$ 逻辑完全一样，只是要分别求偏导。

2.3.8 总结

定义损失函数 $J(\theta)$ （比如 MSE、交叉熵）
求梯度 $\nabla J(\theta)$ （对每个参数求偏导）
参数更新 $\theta := \theta - \eta \nabla J(\theta)$
重复直到收敛（梯度接近 0 或损失不再下降）

这个例子虽然简单，但它展示了梯度下降最本质的运作机制：利用梯度指引方向，沿着最陡的下坡路一步步走到谷底。任何复杂的深度学习模型，参数更新原理都和这个一模一样，只是计算梯度的方式更复杂（靠反向传播算法）。

2.4 神经网络的工作流程（前向/反向传播）

前向/反向传播

整个神经网络的工作流程，其实就是你之前学的损失函数和梯度下降的超级加强版。

2.4.1 第一步：前向传播（计算损失）

你把一张猫的图片（输入 $X$ ）传给网络。
数据从输入层流到隐藏层，每个神经元做计算并通过激活函数，一层层传递。
最后输出层给出一个预测（ $\hat{y}$ ）。
使用损失函数（比如你学过的交叉熵损失）计算预测值和真实标签（“猫”）之间的差距，得到一个损失值 $L$ 。

2.4.2 第二步：反向传播（计算梯度）

这是神经网络的核心算法。它就像一个反向的快递系统。
从输出层的损失 $L$ 开始，利用微积分中的链式法则，反向一层层地计算出每一个权重对最终损失的影响（也就是梯度）。
这样，网络里的每一个神经元，都知道自己刚才的预测“贡献”了多少误差，以及应该往哪个方向调整。

2.4.3 第三步：参数更新（梯度下降）

拿着刚才计算出的每个权重的梯度，使用你学过的梯度下降（或者 Adam 等优化器）来更新每一层的权重 $W$ 和偏置 $b$ 。 $W_{\text{新}} = W_{\text{旧}} - \eta \cdot \nabla W$
这一步和你之前手动算的 $w := w - \eta \cdot \nabla w$ 原理完全一样，只不过现在网络里可能有几百万个这样的 $w$ 需要同时更新。

2.4.4 第四步：重复

不断重复前向传播、反向传播、梯度下降。随着迭代次数的增加，损失越来越小，网络对猫的识别越来越准。

2.5 链式法则及其作用

链式法则示意图

什么是链式法则，它的作用是什么？这是一个非常关键的问题。链式法则是微积分中的一种基本规则，但在深度学习里，它正是让反向传播得以实现的数学基石。

基于我们刚才聊的神经网络，我可以这样给你定义：链式法则就是计算“复合函数”导数的方法。它告诉我们：当一层层的函数嵌套起来时，最终的输出对最里层输入的导数，等于每一层函数导数的乘积。

2.5.1 为什么神经网络需要它？

在神经网络里，数据是这样流动的（前向传播）：

输入 $x$ 先和权重 $w$ 线性组合： $z = w \cdot x$
然后经过激活函数 $\sigma$ ： $a = \sigma(z)$
如果有多层，这个 $a$ 又会成为下一层的输入，继续重复。

最终，网络的输出 $\hat{y}$ 和真实值 $y$ 比较，得到损失 $L$ 。

用数学表达这个链条就是： $x \to z \to a \to \hat{y} \to L$ 或者说： $L = f(\hat{y}) = f(\sigma(z)) = f(\sigma(w \cdot x))$

问题：我们想更新最底层的权重 $w$ ，就需要知道 $\frac{\partial L}{\partial w}$ （损失对 $w$ 的梯度）。但是， $L$ 并不直接包含 $w$ ，中间隔了好几层函数。

链式法则就是用来解开这个“套娃”的。

2.5.2 链式法则的数学形式

链式法则的公式非常简单： $\frac{dL}{dw} = \frac{dL}{da} \cdot \frac{da}{dz} \cdot \frac{dz}{dw}$

翻译成大白话：你想知道“调整 $w$ 对最终损失 $L$ 的影响有多大”，就把它拆解成三段来看：

$\frac{dL}{da}$ ：输出层的变化对损失的影响。
$\frac{da}{dz}$ ：神经元内部状态 $z$ 的变化对激活值 $a$ 的影响（也就是激活函数的导数）。
$\frac{dz}{dw}$ ：权重 $w$ 的变化对神经元内部状态 $z$ 的影响（也就是 $x$ 本身）。

把它们乘起来，就得到了我们需要的梯度。

2.5.3 一个具体的数值例子

让我们用一个极简的网络来演算，沿用我们之前线性回归的思路，但这次加上一层激活函数。

假设网络结构：

输入 $x = 2$
权重 $w = 3$
没有偏置（为了更简单）
激活函数是 Sigmoid（虽然我们之前没用过，但它是经典的激活函数，能把任何数压到 0~1 之间）
损失函数是 MSE（假设真实值 $y = 0.5$ ）

第1步：前向传播（看看损失有多大）

$z = w \cdot x = 3 \times 2 = 6$
$a = \sigma(z) = \sigma(6) \approx 0.9975$ （Sigmoid 公式： $\frac{1}{1+e^{-z}}$ ，6 代入后非常接近 1）
$L = (a - y)^2 = (0.9975 - 0.5)^2 \approx 0.2475$

第2步：反向传播（用链式法则算梯度 $\frac{\partial L}{\partial w}$ ）

我们需要这三样东西：

① $\frac{\partial L}{\partial a}$ ：损失对激活值的导数
- $L = (a - y)^2$
- 导数（对 a）： $2(a - y) = 2 \times (0.9975 - 0.5) = 2 \times 0.4975 = 0.995$
② $\frac{\partial a}{\partial z}$ ：激活函数（Sigmoid）的导数
- Sigmoid 有一个很好的性质：它的导数 = $\sigma(z) \times (1 - \sigma(z))$
- 代入 $a \approx 0.9975$ ： $0.9975 \times (1 - 0.9975) = 0.9975 \times 0.0025 \approx 0.0025$
③ $\frac{\partial z}{\partial w}$ ：线性部分对权重的导数
- $z = w \cdot x$
- 导数（对 w）： $x = 2$

第3步：乘起来 $\frac{\partial L}{\partial w} = \frac{\partial L}{\partial a} \cdot \frac{\partial a}{\partial z} \cdot \frac{\partial z}{\partial w}$ $\frac{\partial L}{\partial w} = 0.995 \times 0.0025 \times 2$ $\frac{\partial L}{\partial w} \approx 0.004975$

结果解释：我们算出梯度大约是 0.005。这意味着，如果我们在当前位置（ $w=3$ ）稍微增加一点 $w$ ，损失 $L$ 会上升大约 0.005 倍。所以为了减小损失，我们应该减小 $w$ （这正是梯度下降要做的事： $w_{\text{新}} = w_{\text{旧}} - \eta \cdot \nabla$ ）。

2.5.4 为什么这个法则如此重要？

局部计算：在反向传播中，每一层只需要计算自己那部分的导数（比如这层只需要算 $\frac{\partial a}{\partial z}$ ），然后把结果乘以后面传来的数，再往前传。这种“局部计算，全局传递”的模式，让计算机可以高效地训练几百层深的网络。
误差的分配：你可以把链式法则理解为“责任分配机制”。最终的误差（L）通过链式法则，一层层地把“责任”（梯度）分解到每一个参数头上，告诉每个权重：“你对这次错误负多大的责任，以及该往哪个方向改”。

2.5.5 总结

链式法则 = 复合函数的求导规则。

在神经网络里，它的作用就是把输出层的误差信号，通过一连串的乘法运算，准确地反向传播到网络深处的每一个权重上，从而计算出每个权重的梯度，让梯度下降能够正常进行。

2.6 神经网络核心机制

此时我们再来讲述正式介绍下神经网络,基于我们之前聊的线性回归、损失函数、梯度下降、链式法则，你现在已经具备了理解神经网络的基础。

简单来说，神经网络就是通过组合多个简单的“神经元”（类似于加权的线性回归单元），并引入非线性激活函数，从而能够学习和表示极其复杂的模式。

为了帮你清晰地理解，我们还是从你已经掌握的知识出发，一步步“搭建”一个神经网络。

2.6.1 从“神经元”说起

你之前理解的线性回归： $\hat{y} = w_1 x_1 + w_2 x_2 + b$ 。它接收输入（ $x_1, x_2$ ），乘以权重（ $w$ ），加上偏置（ $b$ ），然后输出。

在神经网络里，做这个计算的单元就叫神经元（或节点）。

一个神经元 = 你之前学的线性回归 + 一个“激活函数”

为什么要加激活函数？

如果没有激活函数，无论堆叠多少层神经元，最终都只是复杂的线性变换，本质上和一个简单的线性回归没区别，无法处理复杂问题（比如图像识别）。
激活函数引入非线性，让网络有能力学习曲线、边界和复杂特征。

2.6.2 搭建一个简单的神经网络

把多个神经元像搭积木一样连接起来，就形成了神经网络。

输入层：接收原始数据（比如图片的像素值）。
隐藏层：中间的一层或多层神经元。它们负责自动提取特征。比如识别一张脸，第一层可能学的是边缘，第二层学的是眼睛鼻子，第三层学的是整张脸。
输出层：最后一层，输出结果（比如是猫的概率）。

2.6.3 总结：神经网络到底是什么？

结构上：它是多层神经元的堆叠。
能力上：它通过隐藏层和激活函数，能够自动从数据中学习复杂的特征和模式，而不需要人手动去设计特征（这是它和传统机器学习的一大区别）。
训练上：它利用你之前学的损失函数作为目标，利用梯度下降作为方法，再加上一个叫反向传播的算法来高效计算梯度，从而找到最优的参数。

用一句话串联你学过的所有概念： 神经网络利用反向传播计算损失函数对每一层参数的梯度，然后通过梯度下降更新参数，从而让模型能够拟合极其复杂的非线性关系。

到此人工智能中核心中的核心-神经网络已经介绍结束，欢迎大家持续关注!

                                                完成于2026/02/18 13:27