人工智能基础

知识点地图#

• 知识类别：人工智能导论——从符号主义（搜索、知识表示）到 连接主义（机器学习、神经网络）的两大传统与它们的现代合流。
• 解决什么问题：让机器在解空间里做决策（搜索）、表达并推理世界 知识（表示与推理）、从数据中归纳规律（学习）。
• 什么时候用到：理解大语言模型的技术谱系、评估「这个场景该用 规则还是学习」、为后续深入学习 ML/NLP 打底。

1. 人工智能概述#

1.1 AI 发展历程#

1.2 AI 分类#

2. 搜索算法#

2.1 无信息搜索#

$b$：分支因子，$d$：解深度，$m$：最大深度

2.2 启发式搜索#

A* 算法：

$f(n) = g(n) + h(n)$

• $g(n)$：从起点到 $n$ 的实际代价
• $h(n)$：从 $n$ 到目标的启发式估计

最优性条件：$h(n)$ 是可采纳的（不高估实际代价）。

A* 的效率：

$\text{有效分支因子} = b^* : N = 1 + b^* + (b^*)^2 + ...$

2.3 对抗搜索#

Minimax 算法：

$V(s) = \begin{cases} \text{utility}(s) & \text{终止状态} \\ \max_{a}V(\text{result}(s,a)) & \text{MAX 节点} \\ \min_{a}V(\text{result}(s,a)) & \text{MIN 节点} \end{cases}$

Alpha-Beta 剪枝：

• $\alpha$：MAX 节点当前最优值
• $\beta$：MIN 节点当前最优值
• 剪枝条件：$\alpha \geq \beta$

最佳情况下搜索节点数：$O(b^{d/2})$

3. 知识表示与推理#

3.1 一阶谓词逻辑#

基本元素：

• 常量：John, 5
• 变量：$x$, $y$
• 谓词：$Likes(x, y)$
• 函数：$Father(John)$
• 量词：$\forall$, $\exists$

推理规则：

• 假言推理（Modus Ponens）：$P, P \to Q \vdash Q$
• 全称实例化：$\forall x P(x) \vdash P(a)$
• 存在实例化：$\exists x P(x) \vdash P(c)$

3.2 语义网络#

用图结构表示概念间的关系：

[鸟] --is-a--> [动物]
[企鹅] --is-a--> [鸟]
[企鹅] --cannot--> [飞]

3.3 本体论#

使用 OWL（Web Ontology Language）定义概念层次和关系：

• 类（Class）
• 属性（Property）
• 个体（Individual）
• 公理（Axiom）

4. 机器学习#

4.1 学习范式#

4.2 线性回归#

$\hat{y} = \mathbf{w}^T \mathbf{x} + b$

损失函数（MSE）：

$L = \frac{1}{n}\sum_{i=1}^{n}(y_i - \hat{y}_i)^2$

正规方程：

$\mathbf{w}^* = (\mathbf{X}^T\mathbf{X})^{-1}\mathbf{X}^T\mathbf{y}$

4.3 逻辑回归#

$P(y=1|\mathbf{x}) = \sigma(\mathbf{w}^T\mathbf{x} + b) = \frac{1}{1+e^{-(\mathbf{w}^T\mathbf{x}+b)}}$

交叉熵损失：

$L = -\frac{1}{n}\sum_{i=1}^{n}[y_i\log\hat{y}_i + (1-y_i)\log(1-\hat{y}_i)]$

4.4 支持向量机（SVM）#

最大间隔：

$\max_{\mathbf{w},b} \frac{2}{\|\mathbf{w}\|} \quad \text{s.t.} \quad y_i(\mathbf{w}^T\mathbf{x}_i+b) \geq 1$

核技巧：

$K(\mathbf{x}_i, \mathbf{x}_j) = \phi(\mathbf{x}_i)^T\phi(\mathbf{x}_j)$

常用核函数：

4.5 模型评估#

偏差-方差权衡：

$\text{泛化误差} = \text{偏差}^2 + \text{方差} + \text{噪声}$

5. 神经网络#

5.1 多层感知机（MLP）#

$\mathbf{h} = \sigma(\mathbf{W}_1\mathbf{x} + \mathbf{b}_1)$

$\mathbf{y} = \mathbf{W}_2\mathbf{h} + \mathbf{b}_2$

反向传播：

$\frac{\partial L}{\partial \mathbf{W}} = \frac{\partial L}{\partial \mathbf{y}} \cdot \frac{\partial \mathbf{y}}{\partial \mathbf{h}} \cdot \frac{\partial \mathbf{h}}{\partial \mathbf{W}}$

5.2 常用激活函数#

5.3 优化算法#

Adam 更新规则：

$m_t = \beta_1 m_{t-1} + (1-\beta_1)g_t$

$v_t = \beta_2 v_{t-1} + (1-\beta_2)g_t^2$

$\theta_t = \theta_{t-1} - \frac{\eta}{\sqrt{\hat{v}_t}+\epsilon}\hat{m}_t$

5.4 正则化技术#

6. 深度学习#

6.1 CNN（卷积神经网络）#

核心操作：

• 卷积：提取局部特征
• 池化：降维，增强平移不变性
• 全连接：分类决策

经典架构：

残差连接：

$\mathbf{y} = F(\mathbf{x}) + \mathbf{x}$

解决深层网络的梯度消失问题。

6.2 Transformer#

自注意力机制：

$\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V$

多头注意力：

$\text{MultiHead}(Q,K,V) = \text{Concat}(\text{head}_1, ..., \text{head}_h)W^O$

$\text{head}_i = \text{Attention}(QW_i^Q, KW_i^K, VW_i^V)$

6.3 大语言模型（LLM）#

基于 Transformer Decoder 的生成式模型：

• GPT 系列：自回归生成
• BERT：双向编码
• LLaMA：开源大模型

缩放定律：

$L(N) \approx \left(\frac{N_c}{N}\right)^{\alpha}$

模型性能随参数量 $N$、数据量 $D$、计算量 $C$ 的增加而可预测地提升。

动手实践#

任务：不借助任何机器学习库，手写一个单层感知机学习逻辑或（XOR 前后 各做一次），用实验验证本文第 5 节「单层网络无法解决线性不可分问题」的论断。

1. 实现 4 个样本的 XOR 真值表训练：感知机收敛（误判为 0）即成功；
2. 对 OR 真值表重复同一训练，观察它能收敛；
3. 对比两者的错误曲线，用「能否画出一条 separating line」解释差异；
4. 进阶：在输入层加一个隐藏节点（手写 2-2-1 结构），再试 XOR。

提示：感知机更新规则 w += lr * (y - y_hat) * x；XOR 永远不收敛 是数学事实，设定最大迭代轮数（如 100）后输出「未收敛」即实验结论； 加隐藏层后建议直接写两个固定的隐藏单元分别模拟 OR 与 NAND， 只训练输出层，避免手写反向传播。

# perceptron_lab.py —— 单层感知机：OR 可收敛，XOR 不收敛
def train(X, y, epochs=100, lr=0.5):
    w = [0.0, 0.0]; b = 0.0
    for ep in range(epochs):
        errors = 0
        for (x1, x2), t in zip(X, y):
            y_hat = 1 if w[0]*x1 + w[1]*x2 + b > 0 else 0
            if y_hat != t:                      # 感知机学习规则
                w[0] += lr * (t - y_hat) * x1
                w[1] += lr * (t - y_hat) * x2
                b    += lr * (t - y_hat)
                errors += 1
        if errors == 0:
            return True, ep                     # 收敛
    return False, epochs

OR  = [([0,0],0), ([0,1],1), ([1,0],1), ([1,1],1)]
XOR = [([0,0],0), ([0,1],1), ([1,0],1), ([1,1],0)]
print("OR :", train([s for s,_ in OR],  [t for _,t in OR]))
print("XOR:", train([s for s,_ in XOR], [t for _,t in XOR]))
# 预期：OR 在个位数轮收敛；XOR 输出未收敛 —— 证明单层线性不可分