涵盖随机变量、条件概率、全概率公式、贝叶斯公式、独立性与互斥，并补充手工计算示例、Python代码示例及学习资料链接。

---

1. 概率基础

核心目标：掌握概率的核心概念及常用公式，理解贝叶斯公式的本质与应用，区分独立性与互斥性，为后续学习朴素贝叶斯分类器、贝叶斯优化、概率模型（如EM算法）奠定基础——AI中大量场景依赖概率思维（如分类任务的概率预测、模型参数的后验估计）。
说明：知识点侧重“AI实战应用”，不深究复杂的概率公理推导，重点掌握“如何理解”“如何计算”“如何应用”。

---

1.1 随机变量

1.1.1 定义与分类

• 随机变量：将随机试验的结果映射为实数的变量。通俗说，就是“取值随机会而定的变量”。
• 离散型随机变量：取值有限或可数无限（如掷骰子的点数、分类任务的类别标签）。概率描述用概率质量函数（PMF） $P(X=x)$。
• 连续型随机变量：取值充满一个区间（如身高、模型预测的概率值）。概率描述用概率密度函数（PDF） $f(x)$，满足 ${\int }_{-\infty }^{\infty }f(x)dx=1$，且 $P(a\le X\le b)={\int }_a^{b}f(x)dx$。

在AI中的应用：

• 离散型：分类标签（如猫/狗）、词频统计。
• 连续型：高斯分布（用于初始化神经网络权重、生成模型）、特征值（如图像像素强度）。

1.1.2 手工计算示例

例1（离散）：掷一颗均匀骰子，记 $X$ 为点数。求 $P(X=3)$ 和 $P(X\ge 5)$。
解：$P(X=3)=\frac{1}{6}$；$P(X\ge 5)=P(X=5)+P(X=6)=\frac{2}{6}=\frac{1}{3}$。

例2（连续）：连续随机变量 $X$ 服从区间 $[0,2]$ 上的均匀分布，其PDF为 $f(x)=\frac{1}{2}$（$0\le x\le 2$）。求 $P(0.5\le X\le 1.5)$。
解：$P(0.5\le X\le 1.5)={\int }_{0.5}^{1.5}\frac{1}{2}dx=\frac{1}{2}\times (1.5-0.5)=0.5$。

例3（AI分类场景）：二分类任务中，离散随机变量 $X$（标签）取值为 { 0 , 1 } \{0,1\} {0,1}，概率 $P(X=0)=0.3$，$P(X=1)=0.7$，验证概率和为1：$0.3+0.7=1$。

1.1.3 Python代码示例

import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import uniform

# 离散随机变量：模拟掷骰子10000次
dice_rolls = np.random.randint(1, 7, size=10000)
prob_3 = np.sum(dice_rolls == 3) / 10000
print(f"P(X=3) 模拟值: {prob_3:.4f} (理论值 1/6 ≈ 0.1667)")

# 连续随机变量：均匀分布U(0,2)
x = np.linspace(-0.5, 2.5, 200)
pdf = uniform.pdf(x, loc=0, scale=2)   # loc=下限, scale=区间长度
plt.plot(x, pdf, 'b-', label='PDF f(x)=1/2')
plt.fill_between(x, 0, pdf, where=(x>=0.5)&(x<=1.5), alpha=0.3, color='red', label='P(0.5≤X≤1.5)')
plt.title('均匀分布 U(0,2) 的概率密度')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.legend()
plt.grid(alpha=0.3)
plt.show()

---

1.2 条件概率

1.2.1 定义与公式

条件概率：在事件 $B$ 已经发生的条件下，事件 $A$ 发生的概率，记为 $P(A|B)$。
公式：
$$P(A|B)=\frac{P(A\cap B)}{P(B)},P(B)>0$$

乘法公式：
$$P(A\cap B)=P(A|B)P(B)=P(B|A)P(A)$$

通俗理解：“在 $B$ 发生的前提下 $A$ 发生的概率”，本质是“缩小样本空间”——只考虑 $B$ 发生的所有可能结果，再计算其中 $A$ 发生的比例。

在AI中的应用：朴素贝叶斯分类器的核心基础、特征之间的关联分析、模型的后验概率计算。

1.2.2 手工计算示例

例1（朴素贝叶斯场景）：一批样本中，有100个正例（$B$）、200个负例，正例中80个具有特征 $A$。求 $P(A|B)$（正例中具有特征 $A$ 的概率）。
解：$P(B)=\frac{100}{300}=\frac{1}{3}$，$P(A\cap B)=\frac{80}{300}=\frac{4}{15}$，
$P(A|B)=\frac{4/15}{1/3}=\frac{4}{5}=0.8$。
解读：正例样本中，80%具有特征 $A$，这是朴素贝叶斯中“特征条件概率”的核心计算逻辑。

例2（简单验证）：掷骰子，事件 $B$=“点数为偶数”（ { 2 , 4 , 6 } \{2,4,6\} {2,4,6}），事件 $A$=“点数为4”，求 $P(A|B)$。
解：$P(B)=0.5$，$P(A\cap B)=\frac{1}{6}$，$P(A|B)=\frac{1/6}{0.5}=\frac{1}{3}$。

1.2.3 Python代码示例（模拟验证）

import numpy as np

# 模拟不放回抽球（条件概率）
np.random.seed(42)
n_trials = 100000
first_red = 0
both_red = 0

for _ in range(n_trials):
    balls = ['R','R','R','B','B']
    np.random.shuffle(balls)
    if balls[0] == 'R':
        first_red += 1
        if balls[1] == 'R':
            both_red += 1

conditional_prob = both_red / first_red
print(f"P(第二个红|第一个红) 模拟值: {conditional_prob:.4f} (理论值 0.5)")

---

1.3 全概率公式

1.3.1 定义与公式

设 { B 1 , B 2 , … , B n } \{B_1, B_2, \dots, B_n\} {B1​,B2​,…,Bn​} 是样本空间的一个划分（互斥且完备），则对任意事件 $A$ 有：
$$P(A)=\sum _{i=1}^{n}P(A|B_i)P(B_i)$$

通俗理解：总概率等于每个“原因” $B_i$ 下 $A$ 发生的概率乘以该“原因”的概率，再求和。

在AI中的应用：贝叶斯公式的前置基础（贝叶斯公式中 $P(A)$ 需用全概率公式计算）、朴素贝叶斯的概率归一化、混合模型中的边缘概率计算。

1.3.2 手工计算示例

问题：某工厂有3条生产线（$B_1,B_2,B_3$），产量占比分别为 $P(B_1)=0.5$，$P(B_2)=0.3$，$P(B_3)=0.2$；各生产线的次品率分别为 $P(A|B_1)=0.02$，$P(A|B_2)=0.03$，$P(A|B_3)=0.05$（$A$为“产品是次品”）。求该厂产品的总次品率 $P(A)$。
解：
$$P(A)=0.02\times 0.5+0.03\times 0.3+0.05\times 0.2=0.01+0.009+0.01=0.029$$
即次品率为2.9%。

1.3.3 Python代码示例

# 全概率公式直接计算
p_A_given_B1 = 0.02
p_B1 = 0.5
p_A_given_B2 = 0.03
p_B2 = 0.3
p_A_given_B3 = 0.05
p_B3 = 0.2

p_A = p_A_given_B1 * p_B1 + p_A_given_B2 * p_B2 + p_A_given_B3 * p_B3
print(f"总次品率 = {p_A:.4f}")

# 模拟验证
np.random.seed(42)
samples = 100000
defective = 0
for _ in range(samples):
    factory = np.random.choice(['B1','B2','B3'], p=[0.5,0.3,0.2])
    if factory == 'B1':
        if np.random.rand() < 0.02: defective += 1
    elif factory == 'B2':
        if np.random.rand() < 0.03: defective += 1
    else:
        if np.random.rand() < 0.05: defective += 1
print(f"模拟次品率: {defective/samples:.4f}")

---

1.4 贝叶斯公式 —— 朴素贝叶斯、贝叶斯优化的基础

1.4.1 定义与推导

贝叶斯公式描述了已知结果 $A$ 发生后，归因于某个“原因” $B_i$ 的后验概率：
$$P(B_i|A)=\frac{P(A|B_i)P(B_i)}{{\sum }_{j=1}^{n}P(A|B_j)P(B_j)}=\frac{P(A|B_i)P(B_i)}{P(A)}$$

• $P(B_i)$：先验概率（原因的先验信念）
• $P(A|B_i)$：似然概率（原因 $B_i$ 下结果 $A$ 的可能性）
• $P(B_i|A)$：后验概率（观察到 $A$ 后对原因的更新）

核心本质：“逆概率”计算——由“结果”反推“原因”。

在AI中的应用：

• 朴素贝叶斯分类器：假设特征条件独立，用贝叶斯公式计算后验类别概率。
• 贝叶斯优化：利用先验分布（高斯过程）更新后验，高效搜索超参数。
• 垃圾邮件过滤：根据词频计算邮件属于垃圾邮件的概率。

1.4.2 手工计算示例

例1（工厂次品溯源）：沿用1.3节的工厂数据，已知产品是次品（$A$），求它来自生产线 $B_1$ 的概率 $P(B_1|A)$。
解：$P(B_1|A)=\frac{P(A|B_1)P(B_1)}{P(A)}=\frac{0.02\times 0.5}{0.029}\approx 0.345$。
解读：观察到次品后，来自 $B_1$ 的概率从先验50%降为34.5%。

例2（朴素贝叶斯分类）：二分类任务中，正类先验 $P(Y=1)=0.6$，负类先验 $P(Y=0)=0.4$；特征 $X=1$ 在正类中的条件概率 $P(X=1|Y=1)=0.8$，在负类中 $P(X=1|Y=0)=0.3$。求样本 $X=1$ 属于正类的后验概率 $P(Y=1|X=1)$。
解：
先计算 $P(X=1)=0.8\times 0.6+0.3\times 0.4=0.48+0.12=0.6$，
$P(Y=1|X=1)=\frac{0.8\times 0.6}{0.6}=0.8$。
即样本具有特征 $X=1$ 时，属于正类的概率为80%，朴素贝叶斯分类器会将其判为正类。

1.4.3 Python代码实现（朴素贝叶斯分类器完整示例）

import numpy as np
from collections import defaultdict

# 训练数据（天气与打网球）
data = [
    ('Sunny', 'No'), ('Sunny', 'No'), ('Overcast', 'Yes'),
    ('Rainy', 'Yes'), ('Rainy', 'Yes'), ('Rainy', 'No'), ('Overcast', 'Yes')
]

# 先验与条件概率计数
prior = defaultdict(int)
cond = defaultdict(lambda: defaultdict(int))
vocab = set()

for outlook, play in data:
    prior[play] += 1
    cond[play][outlook] += 1
    vocab.add(outlook)

total = len(data)
classes = list(prior.keys())
alpha = 1.0   # 拉普拉斯平滑
v = len(vocab)

def naive_bayes_predict(outlook):
    probs = {}
    for cls in classes:
        prior_prob = prior[cls] / total
        likelihood = (cond[cls][outlook] + alpha) / (prior[cls] + alpha * v)
        probs[cls] = prior_prob * likelihood
    # 归一化
    total_prob = sum(probs.values())
    for cls in probs:
        probs[cls] /= total_prob
    return probs

result = naive_bayes_predict('Sunny')
print(f"P(Yes|Sunny) = {result['Yes']:.4f}, P(No|Sunny) = {result['No']:.4f}")

1.4.4 贝叶斯优化简介（概念+代码示意）

核心思想：在优化黑盒函数时，用高斯过程（GP）作为先验，根据已评估的点计算后验均值和方差，通过采集函数（如EI）选择下一个最有可能提升的点。

# 示意代码（使用scikit-optimize库）
# pip install scikit-optimize
from skopt import gp_minimize
import numpy as np

def objective(x):
    return (x - 2)**2 + 0.5

res = gp_minimize(objective, [(-10.0, 10.0)], n_calls=20, random_state=42)
print(f"最优参数: x={res.x[0]:.4f}, 最小值={res.fun:.4f}")

---

1.5 独立性与互斥

1.5.1 定义与区别

• 独立事件：事件 $A$ 的发生不影响 $B$ 的概率，即 $P(A|B)=P(A)$，等价于 $P(A\cap B)=P(A)P(B)$。
• 互斥事件：$A$ 与 $B$ 不能同时发生，即 $A\cap B=\varnothing$，因此 $P(A\cap B)=0$。

重要结论：

• 独立 ⇒ 不互斥（除非概率为0）
• 互斥 ⇒ 不独立（除非某个概率为0）

在AI中的应用：

• 朴素贝叶斯的“特征条件独立”假设（特征在给定类别下独立）。
• 随机梯度下降中，样本独立同分布（i.i.d.）假设。
• 多类别分类中，不同类别标签是互斥事件。

1.5.2 手工计算示例

例1（独立但不互斥）：抛两枚硬币，$A$=“第一枚正面”，$B$=“第二枚正面”。
$P(A)=0.5$，$P(B)=0.5$，$P(A\cap B)=0.25=P(A)P(B)$，故独立。$A$与$B$可同时发生，不互斥。

例2（互斥但不独立）：掷一颗骰子，$A$=“点数为奇数”，$B$=“点数为偶数”。
$P(A)=0.5$，$P(B)=0.5$，$P(A\cap B)=0$，故互斥。但 $P(A)P(B)=0.25\ne 0$，所以不独立。

1.5.3 Python代码验证

import numpy as np

# 模拟掷骰子验证互斥性
np.random.seed(42)
rolls = np.random.randint(1, 7, size=10000)
A = (rolls % 2 == 1)   # 奇数
B = (rolls % 2 == 0)   # 偶数

p_A = np.mean(A)
p_B = np.mean(B)
p_AB = np.mean(A & B)

print(f"P(A)={p_A:.3f}, P(B)={p_B:.3f}, P(A∩B)={p_AB:.3f}")
print(f"P(A)P(B)={p_A*p_B:.3f} → 不相等，所以不独立（互斥事件）")

# 验证独立性：抛两枚硬币
coin1 = np.random.choice([0,1], size=10000)
coin2 = np.random.choice([0,1], size=10000)
p_A2 = np.mean(coin1 == 1)
p_B2 = np.mean(coin2 == 1)
p_AB2 = np.mean((coin1 == 1) & (coin2 == 1))
print(f"\n抛硬币: P(A)P(B)={p_A2*p_B2:.3f}, P(AB)={p_AB2:.3f} → 独立成立")

---

1.6 综合代码实践：垃圾邮件分类（朴素贝叶斯完整示例）

import numpy as np
from collections import defaultdict

# 邮件数据（词袋模型）
emails = [
    ("free money now", "spam"),
    ("meeting tomorrow", "ham"),
    ("free meeting", "ham"),
    ("money free cash", "spam"),
    ("schedule meeting", "ham")
]

def tokenize(text):
    return text.split()

class NaiveBayesClassifier:
    def __init__(self, alpha=1.0):
        self.alpha = alpha
        self.class_prior = defaultdict(int)
        self.word_count = defaultdict(lambda: defaultdict(int))
        self.class_total = defaultdict(int)
        self.vocab = set()

    def fit(self, X, y):
        for text, label in zip(X, y):
            self.class_prior[label] += 1
            words = tokenize(text)
            for w in words:
                self.word_count[label][w] += 1
                self.vocab.add(w)
        for label in self.class_prior:
            self.class_total[label] = sum(self.word_count[label].values())

    def predict_proba(self, text):
        words = tokenize(text)
        log_probs = {}
        for label in self.class_prior:
            log_prob = np.log(self.class_prior[label] / sum(self.class_prior.values()))
            for w in words:
                count = self.word_count[label][w]
                prob_word = (count + self.alpha) / (self.class_total[label] + self.alpha * len(self.vocab))
                log_prob += np.log(prob_word)
            log_probs[label] = log_prob
        exp_probs = np.exp(list(log_probs.values()))
        total = np.sum(exp_probs)
        return {label: exp_probs[i]/total for i, label in enumerate(log_probs.keys())}

clf = NaiveBayesClassifier(alpha=0.5)
X = [email[0] for email in emails]
y = [email[1] for email in emails]
clf.fit(X, y)

test_email = "free money meeting"
proba = clf.predict_proba(test_email)
print(f"邮件 '{test_email}' 分类概率: {proba}")

---

1.7 学习资料链接（聚焦AI应用，避免纯理论）

• 可汗学院：概率基础（条件概率、贝叶斯）
• 3Blue1Brown：贝叶斯定理的直观理解（视频）
• 朴素贝叶斯分类器（Scikit-learn官方文档）
• 贝叶斯优化论文与教程
• NumPy概率计算常用方法
• 独立性与互斥性通俗讲解

---

1.8 小结与学习建议

概念	核心公式	AI重要性
随机变量	PMF / PDF	★★★
条件概率	$P(A|B)=P(AB)/P(B)$	★★★★
全概率公式	$P(A)=\sum P(A|B_i)P(B_i)$	★★★★
贝叶斯公式	$P(B_i|A)=\frac{P(A|B_i)P(B_i)}{P(A)}$	★★★★★
独立性	$P(AB)=P(A)P(B)$	★★★★
互斥	$P(AB)=0$	★★★

学习路径：

1. 先手工计算小例子，理解公式含义。
2. 用Python模拟随机试验，验证概率结果。
3. 动手实现朴素贝叶斯分类器（垃圾邮件分类）并理解其假设。
4. 了解贝叶斯优化的基本思想（先验→后验→采集函数）。

注意：概率是AI中处理不确定性的核心工具，贝叶斯公式尤为重要，后续学习贝叶斯统计、概率图模型、变分推断等都会反复用到。无需深究概率公理，重点掌握“公式怎么用”“在AI中对应什么场景”。