常见12种传统机器学习算法-----代码框架和算法流程

（一）算法框架

1. KNN（K-Nearest Neighbors）

   1. 收集并标注样本

   2. 数据归一化/标准化（距离度量敏感）

   3. 选择距离度量（欧氏、曼哈顿等）

   4. 选取 K 值（奇数、交叉验证）*

   5. 训练阶段：只需把训练集存起来（惰性学习）

   6. 预测阶段：找 K 个最近邻投票/平均

   7. 评估：混淆矩阵、Accuracy、F1

   8. 调优：K、距离权重、降维、KD-Tree/球树加速*

2. 线性回归（Linear Regression）

   1. 明确连续型预测目标

   2. 收集特征与标签，处理缺失、异常值

   3. 特征缩放（标准化）

   4. 选择损失函数：MSE

   5. 求解参数：正规方程* 或梯度下降

   6. 评估：R²、RMSE、MAE

   7. 诊断：残差图、多重共线性（VIF）*

   8. 正则化调优：Ridge/Lasso/Elastic Net

3. 逻辑回归（Logistic Regression）

   1. 明确二分类/多分类任务

   2. 构造特征矩阵 X，标签 y∈{0,1}

   3. 特征缩放

   4. 设定 Sigmoid/Softmax 函数*

   5. 最大似然估计 + 梯度下降/牛顿法

   6. 评估：AUC-ROC、LogLoss、混淆矩阵

   7. 正则化调优：L1/L2 及超参数 C

   8. 概率校准：Platt Scaling/Isotonic*

4. 决策树（Decision Tree）

   1. 数据准备：连续特征离散化可选

   2. 选择划分准则：Gini、Entropy、MSE（回归）*

   3. 控制树复杂度：max_depth、min_samples_split*

   4. 训练：递归划分直至停止条件

   5. 剪枝：预剪枝 + 后剪枝（代价复杂度剪枝 CCP）*

   6. 评估：Accuracy/F1（分类）或 RMSE（回归）

   7. 可视化解释树结构*

   8. 调优：网格搜索超参数

5. 随机森林（Random Forest，集成学习）

   1. 数据准备同决策树

   2. 设定森林规模 n_estimators*

   3. 设定随机性：max_features、Bootstrap 采样*

   4. 并行训练大量决策树

   5. 聚合：分类用多数投票，回归用平均*

   6. 评估：OOB 误差*、交叉验证

   7. 特征重要性：Gini/Permutation importance*

   8. 调优：n_estimators、max_depth、max_features

6. 朴素贝叶斯（Naïve Bayes）

   1. 文本/特征需满足条件独立假设*

   2. 计算先验 P(c)

   3. 计算似然 P(xi|c)：
      • 离散：多项式/伯努利*
      • 连续：高斯分布*

   4. 应用贝叶斯公式得后验*

   5. 预测：argmax P(c|x)

   6. 评估：Accuracy、Precision、Recall

   7. 平滑：拉普拉斯平滑 α*

   8. 调优：α、特征选择

7. SVM（Support Vector Machine）

   1. 准备数值型特征，需标准化

   2. 选择核函数：线性、RBF、多项式*

   3. 设定惩罚参数 C 与核参数 γ/d*

   4. 训练：求解凸二次规划*

   5. 获得支持向量与决策边界*

   6. 评估：Accuracy、F1、ROC

   7. 调优：GridSearchCV 调 C, γ

   8. 概率估计：Platt Scaling 或 SVC(probability=True)

8. K-means 聚类

   1. 仅特征 X，无需标签

   2. 特征标准化

   3. 选取 K：肘部法、轮廓系数、Gap Statistic*

   4. 初始化质心：K-means++*

   5. 迭代：分配 → 更新质心，直至收敛

   6. 评估：SSE、轮廓系数、Calinski-Harabasz*

   7. 可视化：PCA/t-SNE 二维散点

   8. 调优：K、距离度量、MiniBatch 加速

9. DBSCAN（Density-Based Clustering）

   1. 特征标准化

   2. 设定邻域半径 ε 和 MinPts*

   3. 扫描密度：核心点、边界点、噪声点*

   4. 形成簇：密度可达合并*

   5. 无需预设簇数 K

   6. 评估：轮廓系数、Dunn Index、可视化

   7. 调优：ε-plot (k-distance graph)*、MinPts

   8. 处理高维：先用 PCA 降维

10. TF-IDF（文本向量化）

    1. 语料收集与分词

    2. 构建词汇表

    3. 计算词频 TF

    4. 计算逆文档频率 IDF*

    5. 生成 TF-IDF 矩阵*

    6. 可选：降维（Truncated SVD/LSA）

    7. 下游任务：文本分类、聚类、检索

    8. 调优：n-gram 范围、停用词、最大特征数

11. 词向量转换 + 评论学习项目

    1. 收集评论文本并标注情感/类别

    2. 文本清洗：去 HTML、去停用词、分词

    3. 选择词向量模型：Word2Vec(Skip-Gram/CBOW)、GloVe、FastText*

    4. 训练词向量或加载预训练

    5. 文本向量化：平均词向量、TF-IDF 加权平均、RNN/CNN*

    6. 训练下游分类器（LSTM、Bi-LSTM、TextCNN）

    7. 评估：Accuracy、F1、AUC

    8. 调优：向量维度、窗口大小、网络结构、学习率

12. PCA（Principal Component Analysis）

    1. 仅特征 X

    2. 标准化（零均值）

    3. 计算协方差矩阵 Σ

    4. 求 Σ 的特征值与特征向量*

    5. 按累计解释方差 ≥ 阈值选 k 个主成分*

    6. 投影数据到低维空间

    7. 评估：保留方差百分比、重构误差

    8. 调优：k、白化、核 PCA（非线性）

13. SVD（Singular Value Decomposition）

    1. 构造原始矩阵 A (m×n)

    2. 去中心化（可选）

    3. 执行 SVD：A = U Σ Vᵀ*

    4. 按奇异值大小截断保留 k 个成分*

    5. 得到低秩近似 A ≈ U_k Σ_k V_kᵀ

    6. 应用：
       • 协同过滤推荐*
       • 隐性语义分析 LSA*

    7. 评估：Frobenius 范数误差、RMSE（推荐）

    8. 调优：k、正则化（FunkSVD、ALS）

14. 数据清洗（通用前置步骤）

    1. 缺失值处理：删除、均值/中位数填充、插值、模型预测填充

    2. 异常值检测：Z-score、IQR、Isolation Forest

    3. 重复样本去重

    4. 数据类型转换

    5. 单位/量纲统一

    6. 字符串规范化（大小写、编码、拼写）

    7. 时间格式统一

    8. 保存清洗后数据集版本控制

（二）对应算法的代码框架

# ========== 1. KNN ==========
from sklearn.datasets import load_iris                 # 加载经典鸢尾花数据集
from sklearn.model_selection import train_test_split   # 将数据拆成训练集和测试集
from sklearn.preprocessing import StandardScaler       # 特征标准化工具
from sklearn.neighbors import KNeighborsClassifier     # K 近邻分类器
from sklearn.metrics import classification_report      # 详细分类报告

X, y = load_iris(return_X_y=True)                     # X 为特征矩阵，y 为标签向量
X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.3, random_state=42)         # 70% 训练，30% 测试

scaler = StandardScaler()                             # 初始化标准化器
X_train = scaler.fit_transform(X_train)               # 对训练集拟合并转换
X_test  = scaler.transform(X_test)                    # 用同样参数转换测试集

clf = KNeighborsClassifier(n_neighbors=5)             # 选择 5 个邻居进行投票
clf.fit(X_train, y_train)                             # 训练（惰性学习，只是存储样本）
print(classification_report(y_test, clf.predict(X_test)))  # 输出 Precision、Recall、F1

# ========== 2. 线性回归（PyTorch 版） ==========
import torch                                          # 导入 PyTorch
X = torch.tensor([[1,1],[2,2],[3,3]], dtype=torch.float32)   # 3×2 特征
y = torch.tensor([[3],[5],[7]], dtype=torch.float32)         # 3×1 标签

model = torch.nn.Linear(2, 1)                         # 定义单层线性层：输入2维，输出1维
criterion = torch.nn.MSELoss()                        # 均方误差损失
optim   = torch.optim.SGD(model.parameters(), lr=0.01)  # 随机梯度下降优化器

for epoch in range(300):                              # 训练 300 轮
    optim.zero_grad()                                 # 清空梯度
    loss = criterion(model(X), y)                     # 前向+计算损失
    loss.backward()                                   # 反向传播
    optim.step()                                      # 更新权重
print('w=', model.weight.data, 'b=', model.bias.data) # 打印学到的参数

# ========== 3. 逻辑回归 ==========
from sklearn.datasets import load_breast_cancer       # 乳腺癌二分类数据
from sklearn.linear_model import LogisticRegression   # 逻辑回归
from sklearn.model_selection import train_test_split  # 数据划分
from sklearn.metrics import roc_auc_score             # AUC 评估

X, y = load_breast_cancer(return_X_y=True)            # 加载数据
X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.3, random_state=0)         # 训练/测试划分

clf = LogisticRegression(max_iter=5000)               # 最大迭代 5000
clf.fit(X_train, y_train)                             # 训练
print('AUC=', roc_auc_score(y_test, clf.predict_proba(X_test)[:,1]))  # 计算 AUC

# ========== 4. 决策树 ==========
from sklearn.tree import DecisionTreeClassifier, plot_tree  # 决策树及可视化
import matplotlib.pyplot as plt                        # 绘图
from sklearn.datasets import load_iris                # 数据集

X, y = load_iris(return_X_y=True)                     # 加载数据
clf = DecisionTreeClassifier(max_depth=3, random_state=0)  # 最大深度3
clf.fit(X, y)                                         # 训练

plt.figure(figsize=(8,4))                             # 设置画布大小
plot_tree(clf, filled=True, feature_names=load_iris().feature_names)  # 画树
plt.show()                                            # 显示

# ========== 5. 随机森林 ==========
from sklearn.ensemble import RandomForestClassifier   # 随机森林
from sklearn.datasets import load_iris                # 数据集

X, y = load_iris(return_X_y=True)                     # 加载数据
clf = RandomForestClassifier(n_estimators=200, random_state=42)  # 200棵树
clf.fit(X, y)                                         # 训练
print('特征重要性:', clf.feature_importances_)         # 查看每个特征的重要性

# ========== 6. 朴素贝叶斯（多项式，文本示例） ==========
from sklearn.datasets import fetch_20newsgroups       # 新闻组文本数据
from sklearn.feature_extraction.text import CountVectorizer  # 词袋模型
from sklearn.naive_bayes import MultinomialNB         # 多项式朴素贝叶斯
from sklearn.metrics import accuracy_score            # 准确率

cats = ['alt.atheism', 'sci.space']                   # 只用两个类别
data = fetch_20newsgroups(subset='train', categories=cats)  # 训练集
X, y = data.data, data.target                         # 文本与标签

vec = CountVectorizer(stop_words='english')           # 初始化向量化器，去掉停用词
X_vec = vec.fit_transform(X)                          # 文本→词频矩阵

clf = MultinomialNB()                                 # 朴素贝叶斯
clf.fit(X_vec, y)                                     # 训练

test = fetch_20newsgroups(subset='test', categories=cats)   # 测试集
X_test = vec.transform(test.data)                     # 用同样词汇表转换
print('Acc=', accuracy_score(test.target, clf.predict(X_test)))  # 输出准确率

# ========== 7. SVM ==========
from sklearn.svm import SVC                           # 支持向量机
from sklearn.datasets import load_iris                # 数据集

X, y = load_iris(return_X_y=True)                     # 加载数据
clf = SVC(kernel='rbf', gamma='scale', C=1.0)         # RBF 核，自动 gamma
clf.fit(X, y)                                         # 训练
print('训练Acc=', clf.score(X, y))                    # 训练集准确率

# ========== 8. K-means ==========
from sklearn.cluster import KMeans                    # K 均值聚类
from sklearn.datasets import make_blobs               # 生成模拟数据
import matplotlib.pyplot as plt                       # 绘图

X, _ = make_blobs(n_samples=400, centers=4, random_state=42)  # 生成 4 簇数据
kmeans = KMeans(n_clusters=4, random_state=0).fit(X)  # 训练聚类器
plt.scatter(X[:,0], X[:,1], c=kmeans.labels_, cmap='viridis')  # 画样本点
plt.scatter(kmeans.cluster_centers_[:,0], kmeans.cluster_centers_[:,1],
            marker='x', s=200, c='red')                # 画质心
plt.show()                                            # 展示

# ========== 9. DBSCAN ==========
from sklearn.cluster import DBSCAN                   # 密度聚类
from sklearn.datasets import make_moons              # 生成月牙形数据

X, _ = make_moons(n_samples=300, noise=0.05, random_state=0)  # 生成数据
labels = DBSCAN(eps=0.3, min_samples=5).fit_predict(X)  # 训练并预测
plt.scatter(X[:,0], X[:,1], c=labels, cmap='plasma')  # 画聚类结果
plt.show()

# ========== 10. TF-IDF ==========
from sklearn.feature_extraction.text import TfidfVectorizer   # TF-IDF

docs = ['The sky is blue.',
        'The sun is bright.',
        'The sun in the sky is bright.']          # 三句话
vec = TfidfVectorizer()                              # 初始化向量化器
tfidf = vec.fit_transform(docs)                      # 计算 TF-IDF 矩阵
print(vec.get_feature_names_out())                   # 词汇表
print(tfidf.toarray())                               # 三句话的 TF-IDF 向量

# ========== 11. 词向量 + 评论情感（FastText 简例） ==========
# 先 pip install fasttext-wheel
import fasttext                                      # Facebook FastText

# 构造极简训练/测试文本文件
with open('train.txt', 'w', encoding='utf-8') as f:
    f.write('__label__pos 这家酒店很棒\n__label__neg 房间很脏')
with open('test.txt', 'w', encoding='utf-8') as f:
    f.write('__label__pos 服务好\n__label__neg 空调坏了')

model = fasttext.train_supervised(input='train.txt', epoch=25, wordNgrams=2)  # 训练
print(model.test('test.txt'))                         # 输出测试集 Precision/Recall

# ========== 12. PCA ==========
from sklearn.decomposition import PCA                 # 主成分分析
from sklearn.datasets import load_iris                # 数据集
import matplotlib.pyplot as plt                       # 绘图

X, y = load_iris(return_X_y=True)                     # 加载数据
X_pca = PCA(n_components=2).fit_transform(X)          # 降到 2 维
plt.scatter(X_pca[:,0], X_pca[:,1], c=y, cmap='rainbow')  # 画散点
plt.title('PCA 2D Projection')                        # 标题
plt.show()                                            # 显示

# ========== 13. SVD ==========
import numpy as np                                   # 数值计算
from scipy.linalg import svd                         # 奇异值分解
import matplotlib.pyplot as plt                      # 绘图

# 构造含噪信号
t = np.linspace(0, 2*np.pi, 1000)                    # 1000 个时间点
signal = np.sin(t) + 0.5*np.random.randn(1000)       # 正弦波+高斯噪声

L = 200                                               # 窗口长度
A = np.lib.stride_tricks.sliding_window_view(signal, L)  # Hankel 矩阵

U, S, VT = svd(A, full_matrices=False)                # 执行 SVD
k = 10                                                # 保留前 10 个奇异值
A_denoised = (U[:, :k] * S[:k]) @ VT[:k, :]          # 低秩近似
# 重构一维信号（简单平均重叠位置）
denoised = np.array([A_denoised[i, 0] for i in range(A_denoised.shape[0])])
plt.plot(signal, label='noisy')                       # 原始含噪
plt.plot(denoised, label='denoised')                  # 去噪后
plt.legend(); plt.show()

# ========== 14. 数据清洗 ==========
import pandas as pd                                  # 数据处理
from sklearn.impute import SimpleImputer             # 缺失值填充
from sklearn.preprocessing import StandardScaler     # 标准化

df = pd.read_csv('raw.csv')                           # 读原始 CSV
# 1. 缺失值：数值列用中位数填充
num_cols = df.select_dtypes(include='number').columns
df[num_cols] = SimpleImputer(strategy='median').fit_transform(df[num_cols])
# 2. 异常值：3σ 法删除
df = df[((df - df.mean()).abs() < 3*df.std()).all(axis=1)]
# 3. 标准化
df[num_cols] = StandardScaler().fit_transform(df[num_cols])
df.to_csv('clean.csv', index=False)                   # 保存清洗后数据