通用分类算法的建模过程

主流分类算法对照（和朴素贝叶斯并列）

1. 概率生成式（和图里这套思想一类：先建模数据分布）

朴素贝叶斯（图中）
假设特征条件独立，每个类用高斯分布拟合；优点快、小数据也能用；缺点独立假设经常不成立。
高斯判别分析 GDA
不做朴素独立假设，直接对整组特征做多维高斯；同一组类别共用协方差矩阵 → 线性决策边界；协方差不同 → 二次判别QDA（二次决策边界）。

2. 判别式模型（不去建模数据长什么样，直接学决策边界）

逻辑回归 Logistic Regression
输出 sigmoid，直接拟合后验概率；线性分类；最常用基线。

刚好就是刚才聊的σ\sigmaσ sigmoid函数。

支持向量机 SVM

找最大间隔超平面；可以核函数（rbf、多项式），做非线性分类。
决策树 / 随机森林 / XGBoost/LightGBM

树模型，分层切分特征；不需要特征归一化；工业表格数据首选。

3. 距离‑度量类

K‑近邻 KNN：没有训练过程；预测的时候找距离最近K个样本投票；惰性学习。

4. 神经网络分类

全连接网络、CNN、Transformer；最后一层：

二分类：Sigmoid + BCEWithLogitsLoss
多分类：Softmax + CrossEntropyLoss

简单对比

算法	思路	决策边界
高斯朴素贝叶斯	生成式：每个类别生成长啥样	可以非线性
GDA线性判别LDA	生成式，多维高斯、共享协方差	直线/超平面
逻辑回归	判别式，直接优化分类损失	直线/超平面
QDA二次判别	生成式，每类独立协方差	二次曲线
SVM(RBF核)	判别式，核映射	任意非线性
随机森林	多棵树分裂	分段非线性

区分【生成式 vs 判别式】

✅生成式（图里贝叶斯、GDA）：P(x∣C)P(x|C)P(x∣C)，先看这个类别下数据是怎么生成出来的
✅判别式（逻辑回归、SVM、树）：P(C∣x)P(C|x)P(C∣x)，直接学输入→类别映射，不管原始数据分布

所有分类算法核心共同点

1. 终极目标完全一致

给定输入特征输出类别 CCC；本质都是找决策边界 ，把特征空间划分成若干区域，每个区域对应一个类别。

不管是生成式、判别式、树、神经网络，任务目标：最小化分类错误。

2. 都遵循贝叶斯决策底层思想（最根本）

理想最优是贝叶斯最小错误决策：

只是求后验概率的手段不一样

朴素贝叶斯 / LDA/GDA（生成式）：用贝叶斯公式
先算先验P(Ci)P(C_i)P(Ci)、类条件分布，间接得到后验（就是书上那张图的流程）
逻辑回归、神经网络：**直接拟合后验，不去建模数据怎么生成
SVM、决策树：不输出显式概率，但隐式逼近贝叶斯最优决策边界

3. 全部存在「假设」，没有万能算法

高斯朴素贝叶斯：特征条件独立，每类服从高斯分布
LDA：各类服从多维高斯、协方差矩阵相同
逻辑回归：对数几率线性
KNN：距离相近样本类别大概率一样（局部光滑假设）
SVM：样本在高维空间可分；核函数假设流形结构
决策树：局部特征切分足以区分类别
神经网络：数据的模式可以被网络函数族表达

假设和现实越吻合，效果越好；假设违背，效果就掉下来。

4. 都在优化某个损失/目标函数

朴素贝叶斯：最大化**联合对数似然
逻辑回归：最小化交叉熵损失
LDA：最大化类间离散度、最小化类内离散度
SVM：最大化间隔 + 惩罚错分样本
树模型：最小化基尼、熵、MSE
神经网络：最小化交叉熵

算法不同，只是目标函数形式、优化求解器不一样（梯度下降、解析解、贪心、拉格朗日对偶）

5. 基础前提：独立同分布 i.i.d

训练集、测试集来自同一个分布；

如果训练、测试分布漂移（分布偏移/表征漂移，前面聊过），所有算法全部掉点，这是全部算法共同的前提。

6. 输入都是特征空间里的向量

都把样本抽象成向量，在特征空间做运算：距离、内积、概率密度、矩阵变换；

KNN算向量距离；SVM算内积；贝叶斯算向量的联合概率密度；神经网络做矩阵乘法。

极简区分（共同点之上的分歧点）

目标一样、前提一样；区别只在于：要不要建模、用什么假设、用什么目标函数、怎么优化求解

共同点	分歧点
求 $\arg\ma(\boldsymbol x) P(C	(\boldsymbol x))$
依赖i.i.d	有的对分布很敏感(贝叶斯/LDA)，有的鲁棒更强(树模型)
都有模型假设	假设各不相同，假设错则性能退化

简短总结

全部分类算法，都是在特征空间里，用一套自己的假设+一套优化目标，去逼近贝叶斯最优分类面。

主流分类算法核心数学推导

统一目标：ddd维特征向量；二分类C∈{0,1}C\in\{0,1\}C∈{0,1}，多分类C1,C2...CkC_1,C_2\dots C_kC1,C2...Ck

一、高斯朴素贝叶斯（书上那张图）

贝叶斯公式：

朴素假设：特征条件独立

高斯假设：每个一维特征在类别下服从一维高斯分布

取对数（把乘积转求和，数值更稳定）对数后验：

先验
训练：直接统计每一类每个特征的均值μij\mu_{ij}μij、标准差σij\sigma_{ij}σij，无迭代，解析解直接算

二、线性判别分析 LDA（GDA，生成式，不假设特征独立）

假设：每一类服从d维多元高斯，**所有类别共用同一个协方差矩阵

同样代入贝叶斯，取对数，把和类别无关项全部消掉：

展开二次项：全部类别相同，可以消去，最后得到线性函数

→ 决策边界是超平面（直线）

QDA二次判别：每一类拥有独立协方差Σi\Sigma_iΣi，二次项无法消去，决策边界二次曲线

三、逻辑回归（判别式，二分类，直接拟合后验）

直接建模后验概率，使用sigmoid：

极大似然估计MLE，N个样本，对数似然：

损失函数（负对数似然，交叉熵 ）：

J=−L \mathcal J = -\mathcal L J=−L

对权重求导（利用 σ′(z)=σ(z)(1−σ(z))\sigma'(z)=\sigma(z)(1-\sigma(z))σ′(z)=σ(z)(1−σ(z))）

没有解析解，梯度下降求解。

多分类：拓展为Softma(\boldsymbol x)回归

四、支持向量机 SVM（线性硬间隔二分类）

训练样本：

约束：所有样本分类正确

间隔：ρ=2∥w∥2\displaystyle \rho=\frac{2}{\|\boldsymbol w\|_2}ρ=∥w∥22，最大化间隔等价最小化 12∥w∥2\frac12 \|w\|^221∥w∥2

KKT条件；大部分αi=0\alpha_i=0αi=0；只有支持向量 αi>0\alpha_i>0αi>0。

核SVM：把内积 → 核函数，隐式映射到高维空间，不需要显式写出映。

软间隔：增加松弛变量，允许少量样本越界，目标增加惩罚项

五、K‑近邻 KNN

无训练参数，惰性学习，没有优化求解过程

距离（常用L2欧氏距离）

预测：找距离最近KKK个训练样本，投票：

概率版本：{K近邻里面类别}

六、决策树（CART分类树）

遍历每个特征jjj、分割阈值ttt，把数据集切分成左右两部分

基尼不纯度（基尼系数）：衡量集合混乱程度

分裂后的基尼：

贪心选择最小化分裂后基尼 。

递归分裂，直到停止条件；随机森林就是多棵独立CART树，最后投票。

信息增益(ID3/C4.5)用熵：H(D)=−∑pklog⁡pk\displaystyle H(D)=-\sum p_k\log p_kH(D)=−∑pklogpk

七、全连接神经网络（分类）

极简总览

算法	有没有解析闭式解	优化方式
高斯朴素贝叶斯	✅解析解	统计均值方差，无迭代
LDA	✅解析解	矩阵直接算
逻辑回归	❌	梯度下降（极大似然）
SVM	✅对偶二次规划	QP求解器
KNN	------	无训练过程
CART决策树	✅每一步贪心最优	贪心搜索分割点
神经网络	❌	反向传播+梯度下降

求解概率密度函数

核心区分：参数法、非参数法、半参数法；还有深度学习密度估计

机器学习里，高斯朴素贝叶斯、LDA/QDA 属于参数密度估计；KNN其实对应非参数；VAE、扩散模型属于深度密度估计。

一、参数化密度估计（Parametric）

假设密度服从某一类已知函数形式（高斯、伯努利、伽马...），只需要求里面的未知参数 θ\thetaθ

1. 极大似然估计 MLE（最常用，前面贝叶斯/LDA全部用这个）

给定样本 {x1,x2,...,xn}\{x_1,x_2,...,x_n\}{x1,x2,...,xn}，选参数，让样本出现的联合概率密度最大

θ^MLE=arg⁡max⁡θ ∏i=1np(xi;θ) \hat\theta_{\text{MLE}}=\arg\max_{\theta}\; \prod_{i=1}^n p(x_i;\theta) θ^MLE=argθmaxi=1∏np(xi;θ)

取对数：

θ^MLE=arg⁡max⁡θ ∑i=1nlog⁡p(xi;θ) \hat\theta_{\text{MLE}}=\arg\max_{\theta}\; \sum_{i=1}^n \log p(x_i;\theta) θ^MLE=argθmaxi=1∑nlogp(xi;θ)

一维高斯：θ={μ,σ2}\theta=\{\mu,\sigma^2\}θ={μ,σ2}

MLE解析解：

μ^=1n∑xi,σ^2=1n∑(xi−μ^)2 \hat\mu=\frac1n\sum x_i,\quad \hat\sigma^2=\frac1n\sum(x_i-\hat\mu)^2 μ^=n1∑xi,σ^2=n1∑(xi−μ^)2

👉高斯朴素贝叶斯、LDA/QDA，就是用MLE算每一类的均值、协方差，得到 p(x∣Ci)p(x|C_i)p(x∣Ci)

2. 最大后验估计 MAP（贝叶斯参数估计）

给参数本身加先验分布 p(θ)p(\theta)p(θ)

θ^MAP=arg⁡max⁡θ $\sumilogp(xi∣θ)+logp(θ)$ \hat\theta_{\text{MAP}}=\arg\max_\theta \left $\\sum_i\\log p(x_i\|\\theta)+\\log p(\\theta)\\right$ θ^MAP=argθmax $i\sumlogp(xi∣θ)+logp(θ)$

相当于MLE + 正则项；防止小数据集方差爆炸。

参数法缺点：假设错了，再怎么调参数，密度都是错的；例如真实分布不是高斯，硬套高斯，结果有偏。

二、非参数密度估计 Non‑Parametric

不预设函数形式，完全由样本数据本身决定密度形状，没有固定少数参数

1. 直方图法 Histogram

把x轴切成一个个bin（区间）

f^(x)=区间内样本数总样本数×区间宽度 \hat f(x)=\frac{\text{区间内样本数}}{\text{总样本数} \times \text{区间宽度} } f^(x)=总样本数×区间宽度区间内样本数

缺点：不连续、边界锯齿；bin选太大太平滑，太小噪声严重。

2. 核密度估计 KDE（Kernel Density Estimate）⭐最重要

每个样本点放一个核函数（高斯核、均匀核），全部叠加起来得到整体密度

f^h(x)=1n h∑i=1nK(x−xih) \hat f_h(x)=\frac{1}{n\,h}\sum_{i=1}^n K\left(\frac{x-x_i}{h}\right) f^h(x)=nh1i=1∑nK(hx−xi)

K(⋅)K(\cdot)K(⋅)：核函数，最常用高斯核
hhh：带宽（bandwidth），超参数，控制平滑程度

带宽太大：过度平滑，抹平细节；带宽太小：过拟合，噪声很大
联系：如果朴素贝叶斯不用高斯假设，换成KDE，就叫核朴素贝叶斯。

3. K‑近邻密度估计（KNN密度）

以查询点xxx为中心，扩大邻域，直到刚好包含KKK个样本；VVV是这个邻域体积

f^(x)=Kn⋅V \hat f(x)=\frac{K}{n\cdot V} f^(x)=n⋅VK

👉KNN分类底层就是这套密度思想：P(C∣x)∝该类别K近邻数量V\displaystyle P(C|x)\propto \frac{\text{该类别K近邻数量}}{V}P(C∣x)∝V该类别K近邻数量

非参数缺点：样本量需求大；高维下维数灾难，需要指数级样本；推理慢。

三、半参数 Semi‑Parametric

一部分是确定参数形式，一部分是非参数；典型：高斯混合模型 GMM

由 KKK 个高斯叠加而成；每个高斯有参数αk,μk,Σk\alpha_k,\mu_k,\Sigma_kαk,μk,Σk；

没有闭式解，用EM‑期望最大化算法迭代求解。

EM算法两步迭代：

E步：估计每个样本来自每个高斯成分的后验责任
M步：利用"责任"更新每个高斯的 α,μ,Σ\alpha,\mu,\Sigmaα,μ,Σ

应用：GMM‑贝叶斯；聚类；异常检测（密度低=异常）。

四、深度密度估计（现代深度学习方法）

用神经网络直接拟合密度函数 pθ(x)p_\theta(x)pθ(x)，θ\thetaθ 网络权重，参数量巨大

VAE 变分自编码器
隐变量模型；边缘密度无法直接积分，变分下界ELBO优化，近似求边缘密度。
归一化流 Normalizing Flow
可逆神经网络；通过一系列可逆变换，把简单先验分布（标准高斯）映射成复杂数据分布；有精确对数似然，可以直接算PDF。
分数匹配 / 扩散模型（Score‑SDE）
不去直接拟合；神经网络拟合**对数密度的梯度（分数函数）；
通过朗之万采样，从分数还原概率密度本身。

扩散模型不直接输出密度值，学的是梯度场，靠采样得到分布。

方法总览对照表

类别	方法	求解/优化手段	是否预设分布形式	典型应用
参数法	MLE极大似然	解析解/梯度优化	✅是（高斯等）	高斯朴素贝叶斯、LDA/QDA
参数法	MAP最大后验	解析解/梯度优化	✅是，加参数先验	小样本参数估计、正则化
半参数	GMM高斯混合	EM迭代算法	部分（多个高斯叠加）	聚类、密度建模
非参数	直方图	统计计数	❌无	简单可视化、一维探索
非参数	KDE核密度估计	叠加核函数	❌无	一维二维密度拟合、核贝叶斯
非参数	KNN密度估计	邻域体积	❌无	KNN分类底层
深度密度	VAE	ELBO变分下界	隐变量假设	生成，近似密度
深度密度	流模型Flow	可逆变换+极大似然	可逆网络假设	精确对数似然、生成
深度密度	Score‑扩散	分数匹配，不学直接PDF	SDE随机微分方程	图像生成，学密度梯度场

关键总结，和前面分类算法串联

课本上那张高斯朴素贝叶斯图 ：用【参数法‑MLE】，假设每个类内特征服从一维高斯，算出 p(x∣Ci)p(x|C_i)p(x∣Ci)；
如果把高斯朴素贝叶斯，替换成 KDE，就变成非参数版本朴素贝叶斯，不再强制高斯；
LDA/QDA：多维高斯 + MLE；
逻辑回归、SVM、XGBoost：完全不去求解概率密度 KaTeX parse error: Can't use function '$' in math mode at position 1: \̲(̲p(x)$ （判别式模型），直接建模 P(C∣x)P(C|x)P(C∣x)；不需要关心数据本身是怎么分布生成出来的。

一句话

生成式模型 = 先要估计类条件概率密度 p(x∣C)p(x|C)p(x∣C) ；判别式模型：绕开密度估计，直接学习后验 P(C∣x)P(C|x)P(C∣x)。

下面全部只用 numpy 手写实现，不调用 sklearn 的模型库，直接对应前面数学推导，每一段都和公式一一对应，适合理解底层原理。

只依赖numpy；数据集依旧鸢尾花，做二分类简化（把标签0/1，方便手写推导）

python 复制代码

import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

# 加载并预处理成二分类问题
iris = load_iris()
X = iris.data
y = iris.target
# 只取前两类，变成二分类0‑1，简化手写推导
mask = (y <= 1)
X = X[mask]
y = y[mask]

scaler = StandardScaler()
X = scaler.fit_transform(X)

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42
)

1、手写：高斯朴素贝叶斯

对应公式：先验、每个特征一维高斯、对数后验

python 复制代码

class MyGaussianNB:
    def fit(self, X, y):
        self.classes = np.unique(y)
        self.n_classes = len(self.classes)
        n_samples, n_feat = X.shape
        # 1.先验概率 P(Ci)
        self.prior = np.zeros(self.n_classes)
        # 每一类每个特征的均值、方差
        self.mu = np.zeros((self.n_classes, n_feat))
        self.var = np.zeros((self.n_classes, n_feat))

        for idx, c in enumerate(self.classes):
            Xc = X[y == c]
            self.prior[idx] = len(Xc) / n_samples
            self.mu[idx] = np.mean(Xc, axis=0)
            self.var[idx] = np.var(Xc, axis=0) + 1e-6  # 防止除0

    def _gaussian_pdf(self, x, mu, var):
        # 一维高斯概率密度
        return np.exp(-(x - mu)**2 / (2*var)) / np.sqrt(2 * np.pi * var)

    def predict(self, X):
        preds = []
        for x in X:
            log_prob = []
            for c_idx in range(self.n_classes):
                # log(P(Ci)) + sum log p(xj|Ci)
                lp = np.log(self.prior[c_idx])
                lp += np.sum(np.log(self._gaussian_pdf(x, self.mu[c_idx], self.var[c_idx])))
                log_prob.append(lp)
            preds.append(self.classes[np.argmax(log_prob)])
        return np.array(preds)

model_gnb = MyGaussianNB()
model_gnb.fit(X_train, y_train)
pred_gnb = model_gnb.predict(X_test)
acc_gnb = np.mean(pred_gnb == y_test)
print(f"【手写高斯朴素贝叶斯】acc={acc_gnb:.4f}")

2、手写：逻辑回归（sigmoid + 梯度下降）

对应：z=wTx+b, σ(z)=11+e−zz=w^Tx+b,\ \sigma(z)=\frac{1}{1+e^{-z}}z=wTx+b, σ(z)=1+e−z1，负对数似然梯度下降

python 复制代码

def sigmoid(z):
    return 1.0/(1.0 + np.exp(-np.clip(z, -50, 50))) # 截断防溢出

class MyLogisticRegression:
    def __init__(self, lr=0.1, epochs=1000):
        self.lr = lr
        self.epochs = epochs

    def fit(self, X, y):
        n, d = X.shape
        self.w = np.zeros(d)
        self.b = 0.0
        for _ in range(self.epochs):
            z = X @ self.w + self.b
            a = sigmoid(z)
            # 梯度 ∂J/∂w = sum (a‑y) x
            dw = (1.0/n) * X.T @ (a - y)
            db = (1.0/n) * np.sum(a - y)
            self.w -= self.lr * dw
            self.b -= self.lr * db

    def predict(self, X):
        prob = sigmoid(X @ self.w + self.b)
        return (prob >= 0.5).astype(int)

model_lr = MyLogisticRegression(lr=0.1, epochs=1500)
model_lr.fit(X_train, y_train)
pred_lr = model_lr.predict(X_test)
acc_lr = np.mean(pred_lr == y_test)
print(f"【手写逻辑回归】acc={acc_lr:.4f}")

3、手写 LDA 线性判别分析（二分类）

对应公式：计算每类均值、全局共用协方差矩阵，计算判别函数 δi(x)\delta_i(x)δi(x)

python 复制代码

class MyLDA:
    def fit(self, X, y):
        self.classes = np.unique(y)
        c0, c1 = self.classes[0], self.classes[1]
        X0 = X[y==c0]
        X1 = X[y==c1]
        # 均值向量
        mu0 = np.mean(X0, axis=0)
        mu1 = np.mean(X1, axis=0)
        # 类内协方差，共用协方差Σ
        cov0 = np.cov(X0.T, bias=True)
        cov1 = np.cov(X1.T, bias=True)
        n0, n1 = len(X0), len(X1)
        self.Sigma = (n0*cov0 + n1*cov1)/(n0+n1)
        self.invSigma = np.linalg.inv(self.Sigma + 1e-6*np.eye(self.Sigma.shape[0]))
        self.mu0, self.mu1 = mu0, mu1

    def predict(self, X):
        w = self.invSigma @ (self.mu1 - self.mu0)
        b = -0.5*(self.mu1.T @ self.invSigma @ self.mu1
                  - self.mu0.T @ self.invSigma @ self.mu0)
        score = X @ w + b
        return (score>0).astype(int)

model_lda = MyLDA()
model_lda.fit(X_train, y_train)
pred_lda = model_lda.predict(X_test)
acc_lda = np.mean(pred_lda == y_test)
print(f"【手写LDA】acc={acc_lda:.4f}")

4、手写 KNN

距离公式：L2=∥x−xi∥2L_2=\|x-x_i\|_2L2=∥x−xi∥2，K近邻投票

python 复制代码

class MyKNN:
    def __init__(self, k=5):
        self.k = k
    def fit(self, X, y):
        self.X_train = X
        self.y_train = y
    def predict(self, X):
        pred = []
        for x in X:
            dist = np.sqrt(np.sum((self.X_train - x)**2, axis=1))
            idx = np.argsort(dist)[:self.k]
            topk_y = self.y_train[idx]
            pred.append(np.bincount(topk_y).argmax())
        return np.array(pred)

model_knn = MyKNN(k=5)
model_knn.fit(X_train, y_train)
pred_knn = model_knn.predict(X_test)
acc_knn = np.mean(pred_knn == y_test)
print(f"【手写KNN k=5】acc={acc_knn:.4f}")

5、手写 CART‑Gini 简单决策树（极简版）

只实现最核心：基尼系数，递归分裂

python 复制代码

def gini(y):
    _, cnt = np.unique(y, return_counts=True)
    p = cnt / len(y)
    return 1.0 - np.sum(p**2)

class MyDecisionTree:
    class Node:
        def __init__(self):
            self.feat = None
            self.thresh = None
            self.left = None
            self.right = None
            self.label = None

    def fit(self, X, y, max_depth=4):
        self.root = self._build(X, y, depth=0, max_depth=max_depth)

    def _build(self, X, y, depth, max_depth):
        node = self.Node()
        # 全部同一类 / 达到最大深度：叶子节点
        if len(np.unique(y)) == 1 or depth >= max_depth:
            node.label = np.bincount(y).argmax()
            return node
        best_gini = 1e9
        best_f, best_t = None, None
        n, d = X.shape
        # 遍历特征+阈值
        for f in range(d):
            vals = np.unique(X[:,f])
            for t in vals:
                mask_left = X[:,f] <= t
                y_l, y_r = y[mask_left], y[~mask_left]
                g = (len(y_l)*gini(y_l)+len(y_r)*gini(y_r)) / n
                if g < best_gini:
                    best_gini = g
                    best_f, best_t = f, t
        if best_f is None:
            node.label = np.bincount(y).argmax()
            return node
        node.feat = best_f
        node.thresh = best_t
        mask_left = X[:,best_f] <= best_t
        node.left = self._build(X[mask_left], y[mask_left], depth+1, max_depth)
        node.right = self._build(X[~mask_left], y[~mask_left], depth+1, max_depth)
        return node

    def _one_sample(self, x, node):
        if node.label is not None:
            return node.label
        if x[node.feat] <= node.thresh:
            return self._one_sample(x, node.left)
        else:
            return self._one_sample(x, node.right)

    def predict(self, X):
        out = [self._one_sample(x, self.root) for x in X]
        return np.array(out)

model_dt = MyDecisionTree()
model_dt.fit(X_train, y_train, max_depth=4)
pred_dt = model_dt.predict(X_test)
acc_dt = np.mean(pred_dt == y_test)
print(f"【手写CART决策树】acc={acc_dt:.4f}")

补充说明

SVM对偶二次规划、神经网络反向传播，如果完全从零手写，代码量非常大；

SVM：单纯numpy手写QP求解器非常繁琐，工业不会自己写；
MLP手写反向传播可以再加；

关键对比提示

手写版本只用来理解数学推导，没有做工程优化，速度、数值稳定性不如sklearn；
生成式模型(贝叶斯、LDA)：fit阶段就是统计均值、协方差，没有迭代；
逻辑回归：迭代梯度下降，没有解析解；
KNN：fit只是存数据，计算全部发生predict；
决策树：贪心搜索最优分割点。

各分类算法：适用场景、数据特点、优缺点

结合数学推导，数据长什么样、任务特点，决定选哪个算法

1. 高斯朴素贝叶斯（书上的图）

✅适合数据

小数据集、低维特征；离散特征 / 连续特征都可以
特征之间相关性弱 （尽量满足条件独立假设）
✅场景：文本分类（垃圾邮件）、短文本、简单基线、实时推理、算力极低设备
❌不适合：特征强相关、高维图像、噪声很大的表格数据

特点：速度极快，直接统计均值方差，不需要迭代训练；一旦特征高度相关，效果直接崩盘

2. LDA 线性判别分析（GDA）

✅适合数据

连续数值型特征；各类大致服从多维高斯分布；样本量中等
特征维度不爆炸，不要几万维
✅场景：模式识别、人脸降维+分类；工业简单表格；作为降维手段 比单纯分类用得更多
❌不适合：非高斯分布；类别方差差异巨大；离群点多；高维稀疏数据

QDA（二次判别）：适合各类协方差差异很大，但需要更多样本，参数量爆炸，小数据集容易过拟合

3. 逻辑回归

✅适合数据

表格结构化数据，连续、离散都支持；线性可分或者近似线性可分
特征需要做归一化；高维稀疏也能扛（广告点击率CTR）
✅场景：风控评分、广告CTR预估、医疗二分类、基线模型；需要输出可解释概率
❌不适合：本身强非线性、复杂交互，不加特征工程很难处理

特点：输出概率，参数可以直接解释，工业界最强基线；复杂非线性必须手动构造交叉特征

4. SVM 支持向量机

✅适合数据

中小样本；中低维；样本干净，噪声不能特别多
数据非线性 → 用RBF核；高维稀疏优先线性SVM
✅场景：传统图像小数据集、小样本工业检测、文本分类；样本数几千～几万最优
❌不适合：百万、千万级超大样本（训练速度慢）；噪声特别多、离群点多

特点：核函数可以处理非线性；大样本下计算复杂度很高，现在大数据场景逐步被树模型/神经网络替代

5. KNN K近邻

✅适合数据

样本量不大；特征距离有物理意义；特征已经做好归一化
✅场景：小样本检索、简单基线、低维演示、推荐系统召回；几乎没有训练阶段
❌不适合：样本百万以上（推理巨慢）；高维灾难（高维空间距离失效）；不平衡数据集

惰性学习：训练时间≈0，全部开销压在预测阶段

6. CART决策树 / 随机森林 / XGBoost / LightGBM（树集成）

✅适合数据

工业结构化表格数据，混合连续+类别特征；不需要归一化 ；特征存在复杂非线性、特征交互
✅场景：几乎所有工业表格业务：风控、异常检测、工业故障预测、竞赛表格任务
❌不适合：原始图像、原始长文本（需要先提取特征，不能直接喂原始像素/字符）

特点：鲁棒强，对异常值耐受；是表格数据的天花板；随机森林偏防过拟合；XGBoost精度更高，调参更细

7. 全连接神经网络 / CNN / Transformer

✅适合数据

大数据！样本几十万起步；原始图像、语音、长文本、多模态；高度非线性，特征很难人工设计
✅场景：图像分类、NLP文本分类、多模态具身感知；端到端原始输入
❌不适合：几百、几千条极小样本，极易过拟合；纯简单表格反而不如XGBoost；黑盒，可解释差

汇总速查表

算法	数据类型	样本规模	核心适用场景	核心前提/短板
高斯朴素贝叶斯	连续/离散	小	文本过滤、快速基线	假设特征独立，强相关时失效
LDA	连续数值	中小	模式识别、降维+分类	数据近似高斯分布
逻辑回归	结构化表格、稀疏高维	中小‑大	风控、广告CTR，需要可解释概率	复杂非线性依赖人工特征工程
SVM	数值型	中小样本	小样本图像、传统模式识别	千万级样本训练慢，怕噪声
KNN	数值特征	小样本	检索、演示基线	大数据推理慢、高维灾难
树集成(XGBoost等)	工业混合表格	中小‑大	故障预测、风控、数据竞赛	不擅长原始像素、原始文本
深度神经网络	图像、语音、文本多模态	大数据量	端到端感知任务	小样本容易过拟合，黑盒

工程选择口诀

原始图像、语音、大文本 → 神经网络系列
业务表格、结构化工业数据 → 优先XGBoost/LightGBM；要可解释概率再看逻辑回归
样本很少、追求速度 → 朴素贝叶斯、LDA
传统小样本模式识别 → SVM‑RBF
只做演示、小数据集 → KNN