ESC
输入关键词搜索文章
目录

机器学习

2026/04/22 00:00:00·2026/05/19 10:23:00
课程/机器学习·78 min read
article

统计学习与监督学习概论

统计学习的分类

基本分类

按算法分类

在线学习：一个一个。随机梯度下降、强化学习 批量学习：一次接受所有的数据

按技巧分类

统计学习方法三要素

模型评估与模型选择

模型验证方法

正则化

用于惩罚模型的复杂度

可能是 L2 范数，也可能是 L1 范数

交叉验证

把模型分割成训练、验证、测试集

泛化能力

泛化误差

生成模型与判别模型

判别模型

K 近邻法

监督学习应用

分类

TP, FP TN, FN 精确率 召回率 \(R = \frac{TP}{TP + FN}\) F1

标注

隐马尔可夫模型，条件随机场

词性标注

信息抽取

回归

感知机

感知机模型

感知机模型是一种二分类线性分类模型，其输入为实例的特征向量，输出为实例的类别（通常取+1和-1）。模型定义为：

$$f(x) = \text{sign}(w \cdot x + b)$$

其中：

感知机对应于特征空间中的一个分离超平面 \(w \cdot x + b = 0\)，通过误分类驱动的学习策略（如随机梯度下降）调整参数，使超平面能够将正负样本完全分开。

k 近邻

什么是 k 近邻

k 近邻（k-NN）是一种基于实例的监督学习算法，主要用于分类和回归。其核心思想是：对于新样本，在训练集中找到与之最相似的 k 个近邻，通过投票（分类）或均值（回归）预测结果。

关键特点：

适用于小规模、低维数据，但对噪声和维度敏感。

Python 实现

以下是 k 近邻算法的 Python 实现：

import numpy as np
from collections import Counter
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

class KNN:
    def __init__(self, k=3):
        self.k = k

    def fit(self, X, y):
        self.X_train = X
        self.y_train = y

    def predict(self, X):
        predictions = [self._predict(x) for x in X]
        return np.array(predictions)

    def _predict(self, x):
        # 计算所有训练样本的距离
        distances = [np.linalg.norm(x - x_train) for x_train in self.X_train]

        # 获取最近的 k 个样本的索引
        k_indices = np.argsort(distances)[:self.k]

        # 获取对应的标签
        k_nearest_labels = [self.y_train[i] for i in k_indices]

        # 多数投票
        most_common = Counter(k_nearest_labels).most_common(1)
        return most_common[0][0]

# 示例使用
if __name__ == "__main__":
    # 加载数据
    iris = load_iris()
    X, y = iris.data, iris.target

    # 分割数据
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

    # 训练和预测
    knn = KNN(k=3)
    knn.fit(X_train, y_train)
    predictions = knn.predict(X_test)

    print(f"准确率: {accuracy_score(y_test, predictions):.2f}")

/关键点/：

也可直接使用 =sklearn.neighbors.KNeighborsClassifier=。

聚类算法

什么是聚类

聚类是一种无监督学习方法，旨在将数据集中的样本划分为若干组（簇），使得同一簇内的样本相似度高，不同簇间的样本相似度低。常用于数据探索、模式发现、降维等任务。

K-means

K-means

朴素贝叶斯

决策树

决策树与学习

决策树模型

决策树是一种基于树结构的分类与回归模型，通过一系列规则对数据进行划分。每个内部节点表示一个特征测试，每个分支代表测试结果，每个叶节点表示一个类别或回归值。

/核心思想/：递归地选择最优特征进行数据划分，直到满足停止条件（如节点纯度足够高或样本数过少）。

优势

  1. 显式表示因子：清晰地展示函数分解结构
  2. 统一框架：可以表示有向和无向图模型
  3. 高效推断：支持消息传递算法
  4. 模块化：便于理解和实现复杂模型

因子图为概率图模型提供了一个强大而直观的表示工具，特别适合处理具有复杂依赖关系的问题。

决策树学习

决策树学习旨在构建一棵与训练数据拟合良好且泛化能力强的树。主要包括三个步骤：

  1. /特征选择/：选择最优划分特征，常用准则包括信息增益、信息增益比、基尼指数等。
  2. /决策树生成/：递归地构建树结构，直至满足停止条件。
  3. /决策树剪枝/：防止过拟合，提升模型泛化能力。

因子图

因子图与Sum-Product算法 - 知乎 因子图是一种用于表示多变量函数因子分解的无向二分图。它在概率图模型（如贝叶斯网络、马尔可夫随机场）和状态估计问题（如SLAM、通信解码）中广泛应用。

基本结构

因子图包含两类节点：

边只连接变量节点和因子节点，形成二分图结构。

数学表示

考虑一个多变量函数：

$$g(x_1, x_2, \dots, x_n) = \prod_{j=1}^m f_j(S_j)$$
其中：

示例

考虑函数：

$$g(x_1, x_2, x_3, x_4, x_5) = f_A(x_1)f_B(x_2)f_C(x_1, x_2, x_3)f_D(x_3, x_4)f_E(x_3, x_5)$$

对应的因子图结构为：

使用 dotfile 画一个示例

以下是用 Graphviz dot 语言绘制的因子图示例：

/图例说明/：

该图清晰地展示了函数 \( g(x_1, x_2, x_3, x_4, x_5) = f_A(x_1)f_B(x_2)f_C(x_1, x_2, x_3)f_D(x_3, x_4)f_E(x_3, x_5) \) 的因子分解结构。

在概率推断中的应用

在概率模型中，因子图常用于表示联合概率分布的因子分解。例如，对于联合分布：

$$P(X) = \frac{1}{Z} \prod_{j} \psi_j(C_j)$$
其中 \( \psi_j \) 是势函数，\( C_j \) 是团。

和积算法

因子图上的主要推断算法是和积算法（Sum-Product Algorithm），用于计算边际分布：

  1. 从变量节点到因子节点的消息：
$$\mu_{x \to f}(x) = \prod_{h \in \mathcal{N}(x) \setminus \{f\}} \mu_{h \to x}(x)$$
  1. 从因子节点到变量节点的消息：
$$\mu_{f \to x}(x) = \sum_{\mathbf{y}} \left[ f(\mathbf{y}, x) \prod_{y \in \mathcal{N}(f) \setminus \{x\}} \mu_{y \to f}(y) \right]$$

其中 \( \mathcal{N}(\cdot) \) 表示邻居节点集合。

import numpy as np

class FactorGraph:
    """简单的因子图实现示例"""

    def __init__(self):
        self.variable_nodes = {}
        self.factor_nodes = {}
        self.edges = []

    def add_variable(self, name, domain):
        """添加变量节点"""
        self.variable_nodes[name] = {'domain': domain, 'neighbors': []}

    def add_factor(self, name, variables, potential_func):
        """添加因子节点"""
        self.factor_nodes[name] = {
            'variables': variables,
            'potential': potential_func,
            'neighbors': []
        }
        # 添加边
        for var in variables:
            self.edges.append((f'f_{name}', f'v_{var}'))
            self.variable_nodes[var]['neighbors'].append(f'f_{name}')
            self.factor_nodes[name]['neighbors'].append(f'v_{var}')

    def belief_propagation(self, variable, evidence=None):
        """简化的信念传播示例"""
        if evidence is None:
            evidence = {}

        # 这里实现简化的消息传递
        messages = {}

        # 初始化消息
        for var in self.variable_nodes:
            messages[f'v_{var}'] = np.ones(len(self.variable_nodes[var]['domain']))

        # 应用证据
        for var, value in evidence.items():
            if var in self.variable_nodes:
                domain = self.variable_nodes[var]['domain']
                idx = domain.index(value)
                msg = np.zeros(len(domain))
                msg[idx] = 1.0
                messages[f'v_{var}'] = msg

        return messages

# 示例用法
fg = FactorGraph()
fg.add_variable('x1', [0, 1])
fg.add_variable('x2', [0, 1])
fg.add_factor('A', ['x1', 'x2'], lambda x,y: np.exp(-(x-y)**2))

print("变量节点:", fg.variable_nodes)
print("因子节点:", fg.factor_nodes)
print("边:", fg.edges)

Sum-Product 算法

Sum-Product(x){
    if(x是变量节点){
         if(x为叶子节点)
             return 1;
         subFx = {x的子节点(全为因子节点)};
         result = 1;
         for(x_i in subFx){
           result = result * Sum-Product(x_i);
         }
         return result ;
    }
    if(x是因子节点) {
             if(x是叶子节点)
                return f(xp);//f为x表示的因子，xp为x的父节点
             subVx = {x的子节点(全为变量节点)};
             result = 1;
             for(x_i in subFx){
                 result = Sum-Product(x_i);
             }
             return marginal(xC,f(xp,xC)*result)
             //f为x表示的因子,xC为x的子节点集合，xp为x父节点
             //marginal()为对f关于xC求边缘概率
    }
}

信息增益（ID3算法）

设训练集 \(D\) 有 \(K\) 个类别，样本属于第 \(k\) 类的概率为 \(p_k\)，则 \(D\) 的经验熵为：

$$H(D) = -\sum_{k=1}^K p_k \log_2 p_k$$

给定特征 \(A\) 有 \(n\) 个取值，将 \(D\) 划分为 \(n\) 个子集 \(D_1, D_2, \dots, D_n\)，特征 \(A\) 对 \(D\) 的条件熵为：

$$H(D|A) = \sum_{i=1}^n \frac{|D_i|}{|D|} H(D_i)$$

信息增益定义为：

$$g(D, A) = H(D) - H(D|A)$$

选择信息增益最大的特征作为划分特征。

信息增益比（C4.5算法）

为解决信息增益对取值较多特征的偏好，引入信息增益比：

$$g_R(D, A) = \frac{g(D, A)}{H_A(D)}$$

其中 \(H_A(D)\) 为特征 \(A\) 的固有值：

$$H_A(D) = -\sum_{i=1}^n \frac{|D_i|}{|D|} \log_2 \frac{|D_i|}{|D|}$$

基尼指数（CART算法）

数据集 \(D\) 的基尼指数定义为：

$$\text{Gini}(D) = 1 - \sum_{k=1}^K p_k^2$$

特征 \(A\) 下集合 \(D\) 的基尼指数为：

$$\text{Gini}(D, A) = \sum_{i=1}^n \frac{|D_i|}{|D|} \text{Gini}(D_i)$$

选择使基尼指数最小的特征作为划分特征。

决策树生成算法

以ID3算法为例：

import numpy as np
from collections import Counter

class DecisionTree:
    def __init__(self, max_depth=None):
        self.max_depth = max_depth
        self.tree = None

    def fit(self, X, y, depth=0):
        # 停止条件：所有样本属于同一类或达到最大深度
        if len(np.unique(y)) == 1 or (self.max_depth and depth >= self.max_depth):
            return Counter(y).most_common(1)[0][0]

        n_features = X.shape[1]
        best_gain = 0
        best_feature = None

        # 计算当前节点的熵
        current_entropy = self._entropy(y)

        # 遍历所有特征，选择信息增益最大的特征
        for feature in range(n_features):
            gain = self._information_gain(X[:, feature], y, current_entropy)
            if gain > best_gain:
                best_gain = gain
                best_feature = feature

        # 如果无法继续划分，返回多数类
        if best_gain == 0:
            return Counter(y).most_common(1)[0][0]

        # 递归构建子树
        tree = {}
        feature_values = np.unique(X[:, best_feature])
        for value in feature_values:
            mask = X[:, best_feature] == value
            subtree = self.fit(X[mask], y[mask], depth + 1)
            tree[(best_feature, value)] = subtree

        return tree

    def _entropy(self, y):
        """计算熵"""
        counts = np.bincount(y)
        probabilities = counts / len(y)
        return -np.sum([p * np.log2(p) for p in probabilities if p > 0])

    def _information_gain(self, feature, y, current_entropy):
        """计算信息增益"""
        unique_values = np.unique(feature)
        conditional_entropy = 0

        for value in unique_values:
            mask = feature == value
            subset_y = y[mask]
            if len(subset_y) > 0:
                conditional_entropy += (len(subset_y) / len(y)) * self._entropy(subset_y)

        return current_entropy - conditional_entropy

    def predict(self, X):
        predictions = [self._predict_single(x, self.tree) for x in X]
        return np.array(predictions)

    def _predict_single(self, x, tree):
        if not isinstance(tree, dict):
            return tree

        for (feature, value), subtree in tree.items():
            if x[feature] == value:
                return self._predict_single(x, subtree)

        # 如果找不到匹配的分支，返回默认值
        return 0

# 示例使用
if __name__ == "__main__":
    from sklearn.datasets import load_iris
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import accuracy_score

    # 加载数据
    iris = load_iris()
    X, y = iris.data, iris.target

    # 分割数据
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

    # 训练决策树
    dt = DecisionTree(max_depth=3)
    dt.tree = dt.fit(X_train, y_train)
    predictions = dt.predict(X_test)

    print(f"决策树准确率: {accuracy_score(y_test, predictions):.2f}")

决策树剪枝

决策树容易过拟合训练数据，剪枝通过去除部分分支来简化模型，提高泛化能力。常用方法包括：

CART算法使用代价复杂度剪枝，定义损失函数：

$$C_\alpha(T) = C(T) + \alpha |T|$$

其中：

通过交叉验证选择最优的 \(\alpha\)，得到剪枝后的最优子树。

决策树优缺点

/优点/：

/缺点/：

实际应用中常使用集成方法（如随机森林、梯度提升树）来克服这些缺点。

逻辑斯谛回归与最大熵模型

支持向量机

EM 算法

什么是 EM 算法

EM 算法（Expectation-Maximization）是一种迭代优化算法，用于在概率模型中含有隐变 量（未观测数据）时估计参数。它通过交替执行两步来逐步逼近最大似然估计或最大后验估 计：

  1. E步（期望步）：基于当前参数估计，计算隐变量的后验概率或期望。
  2. M步（最大化步）：利用E步的结果，更新参数以最大化似然函数（或期望似然）。

特点：

数学解释

EM算法是一种迭代优化方法，用于含隐变量的概率模型参数估计。其核心是通过交替执行两 步来最大化似然函数：

  1. E步（期望步）：基于当前参数估计 \(\theta^{(t)}\)，计算隐变量 \(Z\) 的条件分布 \(P(Z|X,\theta^{(t)})\)，并构造完全数据的对数似然函数关于隐变量的期望：

    $$Q(\theta|\theta^{(t)}) = \mathbb{E}_{Z|X,\theta^{(t)}}[\log P(X,Z|\theta)]$$

  2. M步（最大化步）：更新参数以最大化 \(Q\) 函数：

    $$\theta^{(t+1)} = \arg\max_{\theta} Q(\theta|\theta^{(t)})$$

收敛性：每次迭代保证似然函数 \(P(X|\theta)\) 单调不减，但可能收敛到局部最优解。常用于 高斯混合模型、隐马尔可夫模型等。

马尔可夫模型

马尔可夫模型主要用来模拟和分析物理现象中的空间、时间和上下文关联作用。

时间一路向前，可以用有向图表达；空间可以用无向图表达。

首先我们来了解什么是马尔可夫模型：

马尔可夫模型是一种描述状态序列的随机过程，核心是马尔可夫性：系统下一时刻的状态仅依赖于当前状态，与过去状态无关。

简言之，它利用“无记忆性”简化复杂系统的概率建模。

吉布斯分布

吉布斯分布（Gibbs distribution）是一种基于能量函数的概率分布，形式为：

$$P(x) = \frac{1}{Z} e^{-E(x)/T}$$

其中：

在统计物理中，它描述系统在热平衡下的状态分布；在机器学习中，常用于无向图模型（如马尔可夫随机场）和能量模型。

/Hammersley-Clifford 定理/： 一个随机场是马尔可夫随机场当且仅当其联合分布可表示为吉布斯分布：

$$P(\mathbf{x}) = \frac{1}{Z} \exp\left(-\sum_{c \in C} V_c(\mathbf{x}_c)\right)$$

马尔可夫模型、隐马尔可夫模型与马尔可夫决策链

马尔可夫模型、隐马尔可夫模型与马尔可夫决策过程对比：

特性 马尔可夫模型 (MM) 隐马尔可夫模型 (HMM) 马尔可夫决策过程 (MDP)
状态可观测性 完全可观测 状态隐藏，仅观测可见 完全可观测
动作 无 无 有（智能体决策）
奖励 无 无 有（环境反馈）
目标 描述状态转移 从观测推断隐藏状态 学习最优策略最大化累积奖励
核心问题 状态预测 概率计算、参数学习、解码 策略优化、值函数估计
应用 简单序列预测 语音识别、生物序列分析 机器人控制、游戏AI

/关系/：

简言之：MM描述状态转移，HMM处理不完全观测，MDP引入决策与优化。

马尔可夫性质

马尔可夫性质是隐马尔可夫模型（HMM）的两个核心假设之一，具体包括：

  1. 齐次马尔可夫假设 状态序列满足马尔可夫性：下一时刻状态 \(X_{t+1}\) 仅依赖于当前状态 \(X_t\)，与历史状态 \(X_{t-1}, X_{t-2}, \dots\) 独立。 数学表达：

    $$P(X_{t+1} | X_t, X_{t-1}, \dots, X_1) = P(X_{t+1} | X_t)$$
    该假设简化了状态转移的建模，仅需估计 \(P(X_{t+1} | X_t)\)。

  2. 观测独立性假设 任意时刻的观测 \(O_t\) 仅由当前状态 \(X_t\) 决定，与其他时刻的观测和状态无关。 数学表达：

    $$P(O_t | X_T, O_T, X_{T-1}, O_{T-1}, \dots, X_1, O_1) = P(O_t | X_t)$$
    该假设使观测概率可局部计算，降低模型复杂度。

作用：这两个假设保证了HMM的高效推断（如用前向-后向算法计算概率，维特比算法解码状态序列）。

二阶马尔可夫链模型

二阶马尔可夫链模型扩展了马尔可夫性，使下一状态依赖于最近两个时刻的状态：

本质是记忆长度=2的马尔可夫过程，平衡了复杂度与表达能力。

一般来说，我们最多使用到二阶马尔可夫链模型，对于更深的模型，我们比较少去探究。

马尔可夫模型的联合概率分布

对于马尔可夫模型，联合概率分布可分解为：

马尔可夫链（状态完全可观测）：

$$P(X_1, X_2, \dots, X_T) = P(X_1) \prod_{t=1}^{T-1} P(X_{t+1} | X_t)$$

隐马尔可夫模型（含观测序列 \(O_t\)）：

$$P(X_{1:T}, O_{1:T}) = P(X_1)P(O_1 | X_1) \prod_{t=2}^{T} P(X_t | X_{t-1}) P(O_t | X_t)$$

核心思想：利用条件独立性（马尔可夫性+观测独立性）将联合分布分解为局部概率的乘积。

马尔可夫模型与扩散模型

马尔可夫模型与扩散模型

马尔可夫模型与扩散模型的核心联系在于：扩散模型本质上是特殊形式的马尔可夫链。

/扩散模型框架/：

  1. 前向过程：通过马尔可夫链逐步添加噪声

    $$q(x_{1:T}|x_0) = \prod_{t=1}^T q(x_t|x_{t-1})$$
    其中 \(q(x_t|x_{t-1}) = \mathcal{N}(x_t; \sqrt{1-\beta_t}x_{t-1}, \beta_t I)\)

  2. 反向过程：通过马尔可夫链逐步去噪

    $$p_\theta(x_{0:T}) = p(x_T) \prod_{t=1}^T p_\theta(x_{t-1}|x_t)$$
    学习参数 \(\theta\) 来近似真实的反向转移

/关键区别/：

/关系总结/：扩散模型借用了马尔可夫链的框架结构，但目标是从噪声中生成高质量数据

隐马尔可夫模型

马尔可夫模型与时间序列

马尔可夫模型与时间序列的关系：

马尔可夫模型在时间序列中的应用：

关键区别：

结合应用：

简言之，马尔可夫模型为时间序列提供了基于状态转移的建模视角，特别适合具有明显状态切换的序列数据。

什么是隐马尔可夫模型

是一种用于建模时序数据的统计模型，描述由隐藏的马尔可夫链随机生成不可观测的状态序列，再由各个状态生成观测序列的过程。

/核心要素/：

/三个基本问题/：

  1. 概率计算：给定模型和观测序列，计算该序列出现的概率
  2. 学习问题：根据观测序列估计模型参数
  3. 解码问题：给定模型和观测序列，求最可能的状态序列

/典型应用/：

隐马尔可夫模型的数学表示

/模型参数/：

/三个核心概率分布/：

  1. /状态转移概率矩阵/：

    $$A = [a_{ij}]_{N \times N}, \quad a_{ij} = P(i_{t+1} = q_j | i_t = q_i)$$

  2. /观测概率矩阵/：

    $$B = [b_j(k)]_{N \times M}, \quad b_j(k) = P(o_t = v_k | i_t = q_j)$$

  3. /初始状态概率向量/：

    $$\pi = (\pi_1, \pi_2, \dots, \pi_N), \quad \pi_i = P(i_1 = q_i)$$

/完整模型表示/：

$$\lambda = (A, B, \pi)$$

/联合概率/：

$$P(O, I | \lambda) = \pi_{i_1}b_{i_1}(o_1)a_{i_1i_2}b_{i_2}(o_2)\cdots a_{i_{T-1}i_T}b_{i_T}(o_T)$$

隐马尔可夫模型的例子

以下是一个简单的隐马尔可夫模型例子——天气预测模型：

/场景/： 根据观察到的海藻湿度（观测）推断天气状态（隐藏状态）。

/定义/：

/参数/：

  1. 初始概率 \( \pi = [0.6, 0.4] \)（初始为晴天的概率0.6，雨天0.4）

  2. 状态转移矩阵 \( A \)：

    $$A = \begin{bmatrix} 0.7 & 0.3 \\ 0.4 & 0.6 \end{bmatrix}$$

    • 晴天→晴天：0.7，晴天→雨天：0.3
    • 雨天→晴天：0.4，雨天→雨天：0.6

  3. 观测概率矩阵 \( B \)：

    $$B = \begin{bmatrix} 0.6 & 0.3 & 0.1 \\ 0.1 & 0.4 & 0.5 \end{bmatrix}$$

    • 晴天生成 Dry:0.6, Damp:0.3, Soggy:0.1
    • 雨天生成 Dry:0.1, Damp:0.4, Soggy:0.5

/示例推断/： 若观测序列 \( O = (\text{Dry}, \text{Soggy}) \)，可用前向算法计算 \( P(O|\lambda) \)，或维特比算法解码最可能天气序列（如：\( \text{Sunny} \rightarrow \text{Rainy} \)）。

/应用/：

HMM 的三个问题

隐马尔可夫模型主要解决以下三个基本问题：

  1. /概率计算问题/（评估问题）

    • /问题描述/：给定模型 \(\lambda = (A, B, \pi)\) 和观测序列 \(O = (o_1, o_2, \dots, o_T)\)，计算该观测序列出现的概率 \(P(O|\lambda)\)
    • /解决方法/：前向算法、后向算法
    • /应用/：模型比较、序列分类、行为识别

  2. /学习问题/（参数估计问题）

    • /问题描述/：给定观测序列 \(O\)，估计模型参数 \(\lambda = (A, B, \pi)\) 使得 \(P(O|\lambda)\) 最大
    • /解决方法/：Baum-Welch算法（EM算法在HMM中的特例）
    • /应用/：从数据中学习HMM参数

  3. /解码问题/（预测问题）

    • 问题描述/：给定模型 \(\lambda\) 和观测序列 \(O\)，求最可能的状态序列 \(I^ = argmax_I P(I|O,λ)\)
    • /解决方法/：维特比算法（动态规划）
    • /应用/：状态识别、序列标注、语音识别

前向算法

前向算法用于高效计算观测序列的概率 \(P(O|\lambda)\)，通过动态规划避免直接枚举所有可能状态序列。

/定义前向概率/：

$$\alpha_t(i) = P(o_1, o_2, \dots, o_t, i_t = q_i | \lambda)$$
表示到时刻 \(t\) 部分观测序列为 \(o_1, o_2, \dots, o_t\) 且时刻 \(t\) 状态为 \(q_i\) 的概率。

/算法步骤/：

  1. /初始化/：

    $$\alpha_1(i) = \pi_i b_i(o_1), \quad i = 1,2,\dots,N$$

  2. /递推/：对 \(t = 1, 2, \dots, T-1\)

    $$\alpha_{t+1}(j) = \left[\sum_{i=1}^N \alpha_t(i)a_{ij}\right]b_j(o_{t+1}), \quad j = 1,2,\dots,N$$

  3. /终止/：

    $$P(O|\lambda) = \sum_{i=1}^N \alpha_T(i)$$

*复杂度分析：计算复杂度为 \(O(N^2T)\)，远优于直接计算的 \(O(2TN^T)\)。

后向算法

后向算法与前向算法对称，同样用于计算 \(P(O|\lambda)\)，定义后向概率：

$$\beta_t(i) = P(o_{t+1}, o_{t+2}, \dots, o_T | i_t = q_i, \lambda)$$
表示在时刻 \(t\) 状态为 \(q_i\) 的条件下，从 \(t+1\) 到 \(T\) 的观测序列的概率。

/算法步骤/：

  1. /初始化/：

    $$\beta_T(i) = 1, \quad i = 1,2,\dots,N$$

  2. /递推/：对 \(t = T-1, T-2, \dots, 1\)

    $$\beta_t(i) = \sum_{j=1}^N a_{ij}b_j(o_{t+1})\beta_{t+1}(j), \quad i = 1,2,\dots,N$$

  3. /终止/：

    $$P(O|\lambda) = \sum_{i=1}^N \pi_i b_i(o_1)\beta_1(i)$$

/应用/：前后向概率结合可用于计算其他有用概率，如状态的后验概率。

维特比算法

维特比算法是一种动态规划算法，用于寻找最可能的隐藏状态序列（即维特比路径），常用于隐马尔可夫模型（HMM）的解码问题。其核心思想是利用动态规划逐步累积概率，并回溯得到最优路径。

问题定义

给定：

目标：找到最可能的隐藏状态序列 \(Q^/ = (q_1, q_2, \dots, q_T)\)，使得 \(P(Q \mid O)\) 最大。

动态规划步骤

定义两个变量：

代码示例

以下是一个简单的 Python 实现，假设已知 HMM 参数和观测序列。

import numpy as np

def viterbi(obs, states, start_p, trans_p, emit_p):
    """
    维特比算法实现
    :param obs: 观测序列，如 [0, 1, 2]
    :param states: 隐藏状态列表，如 ['A', 'B']
    :param start_p: 初始概率，如 {'A': 0.6, 'B': 0.4}
    :param trans_p: 转移概率，如 {'A': {'A': 0.7, 'B': 0.3}, 'B': {'A': 0.4, 'B': 0.6}}
    :param emit_p: 发射概率，如 {'A': {0: 0.5, 1: 0.4, 2: 0.1}, 'B': {0: 0.1, 1: 0.3, 2: 0.6}}
    :return: 最可能的隐藏状态序列及其概率
    """
    V = [{}]  # 存储每个时间步的 δ 和 ψ
    # 初始化
    for st in states:
        V[0][st] = {"prob": start_p[st] * emit_p[st][obs[0]], "prev": None}

    # 递推
    for t in range(1, len(obs)):
        V.append({})
        for st in states:
            max_tr_prob = max(V[t-1][prev_st]["prob"] * trans_p[prev_st][st] for prev_st in states)
            for prev_st in states:
                if V[t-1][prev_st]["prob"] * trans_p[prev_st][st] == max_tr_prob:
                    max_prob = max_tr_prob * emit_p[st][obs[t]]
                    V[t][st] = {"prob": max_prob, "prev": prev_st}
                    break

    # 终止并回溯
    opt_path = []
    max_prob = max(value["prob"] for value in V[-1].values())
    previous = None
    for st, data in V[-1].items():
        if data["prob"] == max_prob:
            opt_path.append(st)
            previous = st
            break

    for t in range(len(V) - 2, -1, -1):
        opt_path.insert(0, V[t + 1][previous]["prev"])
        previous = V[t + 1][previous]["prev"]

    return opt_path, max_prob

# 示例参数
states = ['A', 'B']
obs = [0, 1, 2]  # 观测序列
start_p = {'A': 0.6, 'B': 0.4}
trans_p = {'A': {'A': 0.7, 'B': 0.3}, 'B': {'A': 0.4, 'B': 0.6}}
emit_p = {'A': {0: 0.5, 1: 0.4, 2: 0.1}, 'B': {0: 0.1, 1: 0.3, 2: 0.6}}

path, prob = viterbi(obs, states, start_p, trans_p, emit_p)
print(f"最优隐藏状态序列: {path}")
print(f"对应概率: {prob}")

应用场景

维特比算法通过动态规划高效地解决了 HMM 的解码问题，其时间复杂度为 \(O(T \cdot N^2)\)，其中 \(T\) 是观测序列长度，\(N\) 是隐藏状态数。

Baum-Welch 算法

Baum-Welch算法是EM算法在HMM中的具体实现，用于解决学习问题——从观测序列估计模型参数。

/定义一些概率/：

  1. /在时刻 \(t\) 处于状态 \(q_i\) 的概率/：

    $$\gamma_t(i) = P(i_t = q_i | O, \lambda) = \frac{\alpha_t(i)\beta_t(i)}{\sum_{j=1}^N \alpha_t(j)\beta_t(j)}$$

  2. /在时刻 \(t\) 处于状态 \(q_i\) 且在时刻 \(t+1\) 处于状态 \(q_j\) 的概率/：

    $$\xi_t(i,j) = P(i_t = q_i, i_{t+1} = q_j | O, \lambda) = \frac{\alpha_t(i)a_{ij}b_j(o_{t+1})\beta_{t+1}(j)}{\sum_{i=1}^N\sum_{j=1}^N \alpha_t(i)a_{ij}b_j(o_{t+1})\beta_{t+1}(j)}$$

/参数重估公式/（M步）：

  1. /初始状态概率/：

    $$\hat{\pi}_i = \gamma_1(i)$$

  2. /状态转移概率/：

    $$\hat{a}_{ij} = \frac{\sum_{t=1}^{T-1} \xi_t(i,j)}{\sum_{t=1}^{T-1} \gamma_t(i)}$$

  3. /观测概率/：

    $$\hat{b}_j(k) = \frac{\sum_{t=1}^T \gamma_t(j)\mathbb{I}(o_t = v_k)}{\sum_{t=1}^T \gamma_t(j)}$$
    其中 \(\mathbb{I}(o_t = v_k)\) 是指示函数，当 \(o_t = v_k\) 时为1，否则为0。

/算法流程/：

  1. 初始化模型参数 \(\lambda^{(0)}\)
  2. 重复直到收敛：
    • E步：用当前参数 \(\lambda^{(n)}\) 计算 \(\gamma_t(i)\) 和 \(\xi_t(i,j)\)
    • M步：用重估公式更新参数得到 \(\lambda^{(n+1)}\)

/特点/：保证每次迭代似然函数 \(P(O|\lambda)\) 单调递增，但可能收敛到局部最优。

RNN 与隐马尔可夫模型

*RNN（循环神经网络）与隐马尔可夫模型（HMM）对比

特性 隐马尔可夫模型 (HMM) 循环神经网络 (RNN)
模型类型 概率图模型（生成式） 神经网络（判别式/生成式）
状态表示 离散隐状态 连续隐状态（隐藏层向量）
序列建模 马尔可夫假设（当前状态只依赖前一状态） 通过隐藏状态记忆历史信息
参数学习 EM算法（前向-后向算法） 反向传播通过时间（BPTT）
非线性关系 线性建模能力有限 强大的非线性建模能力
上下文依赖 有限历史依赖 理论上可建模长程依赖（实际有梯度问题）
应用场景 语音识别、词性标注 语言建模、机器翻译、时序预测

关键区别：

随机场

随机场基本概念

位点空间 Site Space

/核心思想/：每个位置的变量取值受其邻域变量影响，形成局部依赖的全局分布。

相空间 Phase Space

/全局配置/：每个节点取一个值，形成 \(\mathbf{x} = (x_1, x_2, \dots, x_n) \in \Omega\)

随机场

定义在位点空间上的随机变量集合 \(\mathbf{X} = \{X_v\}_{v \in V}\)，其联合分布由局部相互作用决定。

随机场是定义在概率空间 \((\Omega, \mathcal{F}, P)\) 上的随机变量集合，其中：

$$x=\{x(s)|s\in S, x(S)\in \Omega\}$$
，其中 \(S\) 是位点空间，\(x(s)\) 是位置 \(s\) 处的随机变量取值。

邻域系统

一个位点的邻域定义为与此位点距离小于一个阈值的位点的集合。

\(\mathcal{N} = \{\mathcal{N}_s | s \in S\}\)，其中 \(\mathcal{N}_s \subset S\) 是位置 \(s\) 的邻域，满足：

常见邻域：

局部特性：随机场的联合分布由局部条件概率决定，通常表示为吉布斯分布：

$$P(\mathbf{x}) = \frac{1}{Z} \exp\left(-\sum_{c \in C} V_c(\mathbf{x}_c)\right)$$
其中 \(C\) 是团集合，\(V_c\) 是团势函数，\(Z\) 是配分函数。

关键特性

常见类型

关键特性

马尔可夫随机场

马尔可夫随机场（MRF）是满足局部马尔可夫性的随机场，即：

$$P(X_s | X_{\setminus s}) = P(X_s | X_{N_s})$$

其中 \(X_{\setminus s}\) 表示除 \(s\) 外所有变量，\(X_{N_s}\) 是 \(s\) 的邻域变量。

/等价表述/：

/Hammersley-Clifford 定理/： MRF 与吉布斯分布等价，即：

$$P(\mathbf{x}) = \frac{1}{Z} \exp\left(-\sum_{c \in C} V_c(\mathbf{x}_c)\right)$$
其中 \(C\) 是图的团集合，\(V_c\) 是团势函数。

/应用/：

马尔可夫随机场由五个要素组成：

  1. 位点空间 \(S\)：有限的节点集合
  2. 相空间 \(\Omega\)：每个节点的取值空间
  3. 邻域系统 \(\mathcal{N}\)：定义节点间的依赖关系
  4. /局部特征函数/：定义节点及其邻域的相互作用
  5. /全局概率分布/：通过局部特征构建的联合分布

/关键优势/：能够显式建模变量间的空间依赖关系，适用于具有局部交互的结构化数据。

吉布斯分布与 MRF 的等价性

其中：

/关键点/：

/意义/：为 MRF 提供了具体的概率计算框架，使模型参数化更直观。

应用实例

无向图模型应用实例

  1. 图像去噪

    • 观测：含噪图像像素值
    • 隐藏：真实图像像素值
    • 势函数：相邻像素相似性（平滑约束） + 观测一致性
    • 方法：MRF + 最大后验估计（MAP）

  2. 自然语言处理

    • 条件随机场（CRF）用于序列标注
    • 节点：词性标签
    • 边：相邻标签的转移概率
    • 观测：词语序列

  3. 社交网络分析

    • 节点：用户
    • 边：社交关系
    • 任务：社区发现、影响力传播建模

  4. 生物信息学

    • 蛋白质结构预测
    • 基因调控网络建模

  5. 立体视觉

    • 像素视差估计
    • 相邻像素视差平滑约束

核心优势：显式建模变量间的依赖关系，适用于具有空间/拓扑结构的数据。

条件随机场

判别式图模型，对条件概率\( P(Y|X) \)建模，用于序列标注。

概率无向图模型

图 transclusion

图是由结点和边组成的集合。

团

*团（Clique） 在图论中，团是一个无向图的完全子图，即其中任意两个顶点都直接相连。

在概率无向图模型（如马尔可夫随机场）中，团的定义用于分解联合概率（Hammersley-Clifford定理）：

$$P(X) = \frac{1}{Z} \prod_{C} \psi_C(X_C)$$
其中 \(C\) 是极大团，\(\psi_C\) 是团势函数，\(Z\) 是归一化常数。 最大团的定义是：

*团与最大团

/示例/：

无向图的联合概率分布

无向图的联合概率分布可以写作图的最大团的势函数。

根据Hammersley-Clifford定理，概率无向图模型（马尔可夫随机场）的联合概率分布可分解为：

$$P(X) = \frac{1}{Z} \prod_{C \in \mathcal{C}} \psi_C(X_C)$$

其中：

/关键点/：

玻尔兹曼分布

无向图的势函数只需要是一个非负函数就行，这有一些太灵活了。在一些常用的势函数中，我们可以来看看玻尔兹曼分布。其使用的势函数是指数的 能量函数 。

玻尔兹曼分布（或称吉布斯分布）为势函数提供了具体的参数化形式：

$$\psi_C(X_C) = \exp\left(-E_C(X_C)\right)$$

其联合概率分布可表示为：

$$P(X) = \frac{1}{Z} \exp\left(-\sum_{C \in \mathcal{C}} E_C(X_C)\right) = \frac{1}{Z} \exp\left(-E(X)\right)$$

其中 \(E(X) = \sum_{C} E_C(X_C)\) 是整个配置 \(X\) 的总能量，\(Z\) 是配分函数，用于确保概率分布的归一化。

概玄图模型

概率图模型是用图结构表示随机变量间依赖关系的框架，分为两类：

核心概念：

应用：

条件随机场（CRF）是判别式的无向图模型，直接建模条件概率 \(P(Y|X)\)，在序列标注任务中表现优异。

成对马尔可夫性 局部马尔可夫性

概率无向图模型

概率无向图模型（马尔可夫随机场）是用无向图表示随机变量间概率依赖关系的模型。

核心性质（马尔可夫性）：

因子分解： 通过极大团分解为势函数的乘积：

$$P(Y) = \frac{1}{Z} \prod_{C} \psi_C(Y_C)$$
其中 \(Z\) 是归一化常数，\(\psi_C\) 是团 \(C\) 上的势函数。

特点：

条件随机场的定义与形式

定义

条件随机场（Conditional Random Field, CRF）是一种判别式无向图模型，用于在给定输入序列 \(X\) 的条件下，建模输出序列 \(Y\) 的条件概率分布。

/形式化定义/： 设 \(G = (V, E)\) 是一个无向图，\(Y = \{Y_v\}_{v \in V}\) 是与图中节点对应的随机变量。若在给定随机变量 \(X\) 的条件下，随机变量 \(Y_v\) 满足马尔可夫性，即：

$$P(Y_v | X, Y_w, w \neq v) = P(Y_v | X, Y_w, w \sim v)$$
其中 \(w \sim v\) 表示与 \(v\) 相邻的节点，则称 \((Y, X)\) 构成一个条件随机场。

/常用形式/（线性链条件随机场）： 对于序列标注任务，通常使用线性链结构：

$$P(Y|X) = \frac{1}{Z(X)} \exp\left(\sum_{t=1}^T \sum_{k=1}^K \lambda_k f_k(y_{t-1}, y_t, X, t)\right)$$
其中：

线性链条件随机场

线性链条件随机场是条件随机场在序列标注任务中最常用的形式，其图结构为链状，每个输出变量 \(Y_t\) 只与前一个输出变量 \(Y_{t-1}\) 和输入序列 \(X\) 相关。

/条件概率分布/：

$$P(Y|X) = \frac{1}{Z(X)} \exp\left(\sum_{t=1}^T \left[ \sum_{k=1}^K \lambda_k f_k(y_t, X, t) + \sum_{l=1}^L \mu_l g_l(y_{t-1}, y_t, X, t) \right]\right)$$

其中：

/特点/：

参数化形式

线性链条件随机场的参数化形式通常表示为：

$$P(Y|X) = \frac{1}{Z(X)} \exp\left(\sum_{t=1}^T \left[ \sum_{k=1}^K \lambda_k f_k(y_t, X, t) + \sum_{l=1}^L \mu_l g_l(y_{t-1}, y_t, X, t) \right]\right)$$

为简化表达，常将状态特征和转移特征统一表示：

$$P(Y|X) = \frac{1}{Z(X)} \exp\left(\sum_{t=1}^T \sum_{k=1}^K w_k f_k(y_{t-1}, y_t, X, t)\right)$$

其中：

/矩阵形式/： 定义 \(M_t(y_{t-1}, y_t | X) = \exp\left(\sum_{k=1}^K w_k f_k(y_{t-1}, y_t, X, t)\right)\) 则条件概率可表示为：

$$P(Y|X) = \frac{1}{Z(X)} \prod_{t=1}^T M_t(y_{t-1}, y_t | X)$$
其中 \(Z(X)\) 可通过前向-后向算法高效计算。

这种参数化形式便于模型训练（极大似然估计）和解码（维特比算法）。

链上推理

链上推理（Chain Inference）是指在链式结构图模型（如线性链条件随机场）中进行概率 计算和状态推断的过程，主要包括前向-后向算法和维特比算法。

时间复杂度分析

线性链条件随机场的时间复杂度主要取决于前向-后向算法和维特比算法：

/训练阶段/（前向-后向算法）：

/解码阶段/（维特比算法）：

/关键优化/：

/实际应用/：

代码示例

以下是一个简化的线性链条件随机场实现：

import numpy as np

class LinearChainCRF:
    def __init__(self, n_labels):
        self.n_labels = n_labels
        self.weights = None

    def forward_algorithm(self, features):
        """前向算法计算配分函数 Z(X)"""
        T = len(features)  # 序列长度
        alpha = np.zeros((T, self.n_labels))

        # 初始化
        alpha[0] = np.exp(features[0])

        # 递推
        for t in range(1, T):
            for j in range(self.n_labels):
                alpha[t, j] = np.sum(alpha[t-1] * np.exp(features[t, j]))

        # 配分函数
        Z = np.sum(alpha[-1])
        return alpha, Z

    def viterbi_decode(self, features):
        """维特比算法解码最优序列"""
        T = len(features)
        delta = np.zeros((T, self.n_labels))
        psi = np.zeros((T, self.n_labels), dtype=int)

        # 初始化
        delta[0] = features[0]

        # 递推
        for t in range(1, T):
            for j in range(self.n_labels):
                scores = delta[t-1] + features[t, j]
                delta[t, j] = np.max(scores)
                psi[t, j] = np.argmax(scores)

        # 回溯
        path = np.zeros(T, dtype=int)
        path[-1] = np.argmax(delta[-1])
        for t in range(T-2, -1, -1):
            path[t] = psi[t+1, path[t+1]]

        return path

# 示例使用
if __name__ == "__main__":
    # 假设有3个标签，序列长度为4
    n_labels = 3
    T = 4

    # 随机生成特征分数（实际中由特征函数计算）
    np.random.seed(42)
    features = np.random.randn(T, n_labels, n_labels)

    crf = LinearChainCRF(n_labels)
    best_path = crf.viterbi_decode(features)
    print(f"最优标签序列: {best_path}")

强化学习

*强化学习（RL） 是机器学习的一个分支，关注智能体如何通过与环境交互学习最优策略以最大化累积奖励。

核心要素：

主要方法：

  1. /基于值函数/：学习状态或状态-动作对的价值（如Q-learning、DQN）
  2. /基于策略/：直接学习策略函数（如策略梯度）
  3. /演员-评论家/：结合值函数与策略学习

关键挑战：

应用：游戏AI、机器人控制、推荐系统等。

马尔可夫决策过程

*马尔可夫决策过程（MDP） 是强化学习中的经典框架，用于建模序贯决策问题。其核心要素包括：

目标：寻找最优策略 \(\pi^*(a \mid s)\)，最大化累积期望回报：

$$\mathbb{E}\left[ \sum_{t=0}^{\infty} \gamma^t R_t \right]$$

求解方法：

隐马尔可夫模型与马尔可夫决策过程的关系

*隐马尔可夫模型（HMM） 与 马尔可夫决策过程（MDP） 都是基于马尔可夫性质的序列模型，但目标与结构不同：

维度 HMM MDP
问题类型 无监督学习（概率生成模型） 强化学习（决策优化）
状态 隐藏状态（不可直接观测） 完全可观测的状态
动作 无显式动作 有显式动作选择
目标 建模观测序列的生成概率（如解码、评估、学习） 寻找最优策略以最大化累积奖励
核心要素 初始状态分布、状态转移矩阵、观测概率矩阵 状态、动作、转移概率、奖励函数、折扣因子

关系：

强化学习与马尔可夫决策过程

*强化学习与马尔可夫决策过程的关系

特性 马尔可夫决策过程 (MDP) 强化学习 (RL)
本质 数学框架 学习方法
关系 RL 的理论基础与问题描述形式 解决 MDP 问题的算法集合
状态可知性 通常假设完全已知 可处理状态未知或部分观测的情况 (POMDP)
模型依赖性 依赖转移概率 \(P(s'\ s,a)\) 和奖励函数 \(R(s,a)\) 分为模型基于（已知动力学）和模型无关（如 Q-learning）
目标 提供形式化定义：寻找最优策略 \(\pi^*\) 以最大化期望回报 通过试错交互实际学习最优策略
方法举例 值迭代、策略迭代（要求已知完整模型） Q-learning、策略梯度、DQN（可从交互中学习）

核心联系：

高斯混合模型

什么是高斯混合模型

*高斯混合模型（GMM） 是一种概率生成模型，用于对复杂数据分布进行建模，假设数据由多个高斯分布组合而成。

/核心思想/： 用 \( K \) 个高斯分布的加权和来近似任意连续概率密度函数：

$$p(x) = \sum_{k=1}^K \pi_k \mathcal{N}(x \mid \mu_k, \Sigma_k)$$
其中：

/特点/：

后验概率，M步更新参数）

/应用/：

蒙特卡罗方法

蒙特卡罗方法是一类基于随机采样的数值计算方法，通过生成大量随机样本并统计其性质来近似求解复杂问题。

基本思想

通过随机抽样和统计模拟来近似计算数学期望、积分、优化等复杂问题。其核心是利用大数定律：当样本数量足够大时，样本均值收敛于期望值。

主要步骤

  1. /构造概率模型/：将待求解问题转化为概率模型
  2. /随机抽样/：从概率分布中生成大量独立样本
  3. /统计计算/：基于样本计算所需的统计量
  4. /结果分析/：评估估计精度和收敛性

数学基础

对于积分问题：

$$I = \int_a^b f(x)dx = (b-a) \mathbb{E}[f(X)]$$
其中 \(X \sim U(a,b)\)，则蒙特卡罗估计为：
$$\hat{I} = \frac{b-a}{N} \sum_{i=1}^N f(x_i)$$

根据大数定律，当 \(N \to \infty\) 时，\(\hat{I} \to I\)。

误差分析

蒙特卡罗估计的标准误差为：

$$\sigma_{\hat{I}} = \frac{\sigma_f}{\sqrt{N}}$$
其中 \(\sigma_f\) 是 \(f(x)\) 的标准差。

这表明误差以 \(O(1/\sqrt{N})\) 的速率收敛，与问题维度无关，使其特别适合高维积分。

应用领域

Python 实现示例：计算圆周率

import numpy as np
import matplotlib.pyplot as plt

def monte_carlo_pi(n_samples):
    """使用蒙特卡罗方法估计圆周率"""
    # 在单位正方形内生成随机点
    x = np.random.uniform(-1, 1, n_samples)
    y = np.random.uniform(-1, 1, n_samples)

    # 计算落在单位圆内的点数
    inside_circle = (x**2 + y**2) <= 1
    pi_estimate = 4 * np.sum(inside_circle) / n_samples

    return pi_estimate, x, y, inside_circle

# 不同样本量的实验
sample_sizes = [100, 1000, 10000, 100000]
results = []

plt.figure(figsize=(12, 8))
for i, n in enumerate(sample_sizes):
    pi_est, x, y, inside = monte_carlo_pi(n)
    results.append((n, pi_est, abs(pi_est - np.pi)))

    # 绘制散点图
    plt.subplot(2, 2, i+1)
    plt.scatter(x[inside], y[inside], color='blue', s=1, alpha=0.5, label='圆内')
    plt.scatter(x[~inside], y[~inside], color='red', s=1, alpha=0.5, label='圆外')
    plt.title(f'N={n}, π≈{pi_est:.4f}, 误差={abs(pi_est-np.pi):.4f}')
    plt.axis('equal')
    plt.legend()

plt.tight_layout()
plt.show()

# 输出结果
print("蒙特卡罗方法估计圆周率结果：")
print("样本数\t估计值\t\t绝对误差")
for n, est, err in results:
    print(f"{n}\t{est:.6f}\t{err:.6f}")

蒙特卡罗方法的变体

  1. /重要性采样/：针对罕见事件或峰值分布
  2. /马尔可夫链蒙特卡罗/：从复杂分布中采样
  3. /拟蒙特卡罗/：使用低差异序列代替随机数
  4. /序贯蒙特卡罗/：用于动态系统状态估计

优缺点

/优点/：

/缺点/：

稀疏学习与压缩感知

RANSAC

机器学习：RANSAC算法做直线拟合 在实际应用中获取到的数据，常常会包含有噪声数据，这些噪声数据会使对模型的构建造成干扰，我们称这样的噪声数据点为outliers，那些对于模型构建起积极作用的我们称它们为inliers，RANSAC做的一件事就是先随机的选取一些点，用这些点去获得一个模型(这个讲得有点玄，如果是在做直线拟合的话，这个所谓的模型其实就是斜率)，然后用此模型去测试剩余的点，如果测试的数据点在误差允许的范围内，则将该数据点判为inlier，否则判为outlier。

Categories:课程 / 机器学习
Tags:article