9. 机器学习汇总（数据、模型、流程、心血管疾病预测）

1. 数据

• 表格类数据 tabular data
• 互相独立，互不影响
• 离散型数据的数字化：
  • zero index（状态很少时）
    • 0,1,2,…, N-1
  • one - hot（状态比较多时）
    • 1个特征变N个特征
    • [0, 0, 1, …, 0]
• 连续型数据的数字化问题：
  • 直接使用原始数据即可
• 预处理：
  • 中心化：
    • 以零为中心，正负都有
    • x - mu
  • 归一化：
    • 把数据变为[0, 1]
    • (x - _min) / (_max - _min)
  • 规范化：
    • 减去均值，除以标准差
    • (x - mu) / sigma

2. 模型

• 分类：

  • KNN（K紧邻）

    • 简单，好理解
    • 规则+数据（非典型人工智能算法）
    • 惰性计算
    • 训练时很快
    • 预测时很慢
    • 准确率中等

  • 高斯朴素贝叶斯（GNB）

    • 本质是利用了条件概率/贝叶斯公式
    • 计算每个类别的概率，然后选择最大的
    • 前提假设：
      • 特征互相条件独立
      • 满足高斯分布
      • 使用概率密度函数的值代替概率
    • 训练时很快
    • 预测时很快
    • 准确率偏低

  • 决策树：

    • 利用信息论中的熵的内涵
    • 模型训练的过程，就是降低熵（混乱程度）的过程
    • 分类问题：
      • 信息熵（标准计算）
        • -[p1log(p1) + p2log(p2) + … pn*log(pn)]
      • 基尼系数（工程化简）
        • [p1*(1-p1) + p2*(1-p2) + … + pn*(1-pn)]
    • 回归问题：
      • 方差
    • 剪枝算法：
      • 样本越多，越容易构建出一棵很复杂的树！
      • 如果不加限制，决策树会一直分裂到底，容易过拟合，层数很深
      • 策略：限制最大深度；每次分裂的最小样本数等
      • 好处：算法可以很复杂，也可以很简单！！！
      • 这是集成学习的基础！！！
    • 训练时速度中等
    • 推理时速度较快
    • 解释性比较好，树的每一次判断都清晰可见
    • 可以对特征进行重要性排序

  • 支持向量机

    • 适合于：少样本、少特征！
    • 最强个体！
    • 把事儿办了 VS 把事儿办好
    • 低维空间分不开的数据，映射到高纬分开！
    • 训练时：很慢！
    • 推理时：很慢！
    • 准确率：很好！

  • 逻辑回归：

    • 属于深度学习！
    • 二分类算法！
    • 看上去非常二，实际上很重要！
    • 打分函数！
    • sigmoid概率模拟

  • 随机森林：

    • 集成学习！！！
    • base estimator：
      • 决策树
    • 随机：
      • 行级随机（对样本进行了随机采样）
      • 列级随机（最多使用了根下N的特征）
    • 森林：
      • 多棵决策树构成（默认：100棵）
    • Bagging + Voting 的融合体
    • 训练时，速度比较快！
    • 测试时，速度比较快！
    • 准确率：比较好！

  • 其它集成学习：

    • AdaBoost
    • GradientBoost
    • XGBoost
    • LightGBM
    • …
• 回归：
  • KNN
  • 决策树
  • 线性回归
  • 支持向量机
  • 随机森林
  • 集成学习！！！
• 聚类：
  • KMeans K均值算法
• 降维：
  • PCA 主成分分析法

3. 流程

1. 分析问题，搞定输入和输出；
   • 输入：哪些特征？如何数字化？
   • 输出：分类？回归？
2. 根据输入和输出，构建数据集！
3. 遴选一种算法，完成输入到输出的映射！
4. 模型评估、部署、上线应用！

4. 代码（预测心血管疾病）

4.0 读入数据，数据规范化处理

from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
import numpy as np
import time

# 读取数据
X=[]
y=[]
file_name='./心血管疾病数据集.csv'
with open(file = file_name,mode='r',encoding='utf8') as f:
    line_first = np.array(f.readline().strip().split(','))
    for line in f:  
        if line:
            line = f.readline().strip().split(',')
            X.append(line[:-1])
            y.append(line[-1])

# 将数据转为numpy数组
X=np.array(X)
y=np.array(y)

# 把所有数据都转为float类型
X=X.astype(float)
y=y.astype(float)
# 删掉第1列id
X=X[:,1:]

# 切分数据
from sklearn.model_selection import train_test_split
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2)

# 数据预处理（规范化）
_mean = X_train.mean(axis=0)
_std = X_train.std(axis=0)
X_train = (X_train-_mean)/(_std+1e-9)
X_test = (X_test-_mean)/(_std+1e-9)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

4.1 KNN

"""
    测试1：KNN
"""
from sklearn.neighbors import KNeighborsClassifier
knn = KNeighborsClassifier(n_neighbors=5)
# 取一个时间戳
start_fit = time.time()
knn.fit(X=X_train, y=y_train)
# 取一个时间戳
start_predict = time.time()
y_pred = knn.predict(X=X_test)
# 取一个时间戳
stop_predict = time.time()
# 评估
acc = ( y_pred== y_test).mean()

# 打印结果
print(f"""KNN: 
 --> 训练耗时：{start_predict-start_fit} 秒；
 --> 推理耗时：{stop_predict-start_predict} 秒；
 --> 准确率：{acc} ;""")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

KNN:
–> 训练耗时：0.04751253128051758 秒；
–> 推理耗时：1.3453574180603027 秒；
–> 准确率：0.6402857142857142 ;

4.2 高斯朴素贝叶斯

"""
    测试2：高斯朴素贝叶斯
"""
from sklearn.naive_bayes import GaussianNB
gnb = GaussianNB()
# 取一个时间戳
start_fit = time.time()
gnb.fit(X=X_train, y=y_train)
# 取一个时间戳
start_predict = time.time()
y_pred = gnb.predict(X=X_test)
# 取一个时间戳
stop_predict = time.time()
# 评估
acc = ( y_pred== y_test).mean()

# 打印结果
print(f"""GNB: 
 --> 训练耗时：{start_predict-start_fit} 秒；
 --> 推理耗时：{stop_predict-start_predict} 秒；
 --> 准确率：{acc} ;""")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

GNB:
–> 训练耗时：0.009502649307250977 秒；
–> 推理耗时：0.0010018348693847656 秒；
–> 准确率：0.5931428571428572 ;

4.3 决策树

"""
    测试3：决策树
"""
from sklearn.tree import DecisionTreeClassifier
dtc = DecisionTreeClassifier()
# 取一个时间戳
start_fit = time.time()
dtc.fit(X=X_train, y=y_train)
# 取一个时间戳
start_predict = time.time()
y_pred = dtc.predict(X=X_test)
# 取一个时间戳
stop_predict = time.time()
# 评估
acc = ( y_pred==y_test).mean()

# 打印结果
print(f"""DTC: 
 --> 训练耗时：{start_predict-start_fit} 秒；
 --> 推理耗时：{stop_predict-start_predict} 秒；
 --> 准确率：{acc} ;""")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

DTC:
–> 训练耗时：0.11947154998779297 秒；
–> 推理耗时：0.002510547637939453 秒；
–> 准确率：0.6367142857142857 ;

4.4 随机森林

"""
    测试4：随机森林
"""
from sklearn.ensemble import RandomForestClassifier
rfc = RandomForestClassifier()
# 取一个时间戳
start_fit = time.time()
rfc.fit(X=X_train, y=y_train)
# 取一个时间戳
start_predict = time.time()
y_pred = rfc.predict(X=X_test)
# 取一个时间戳
stop_predict = time.time()
# 评估
acc = ( y_pred==y_test).mean()

# 打印结果
print(f"""RFC: 
 --> 训练耗时：{start_predict-start_fit} 秒；
 --> 推理耗时：{stop_predict-start_predict} 秒；
 --> 准确率：{acc} ;""")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

RFC:
–> 训练耗时：3.7813894748687744 秒；
–> 推理耗时：0.18322372436523438 秒；
–> 准确率：0.715 ;

4.5 支持向量机

"""
    测试5：支持向量机
"""
from sklearn.svm import SVC
svc = SVC()
# 取一个时间戳
start_fit = time.time()
svc.fit(X=X_train, y=y_train)
# 取一个时间戳
start_predict = time.time()
y_pred = svc.predict(X=X_test)
# 取一个时间戳
stop_predict = time.time()
# 评估
acc = ( y_pred==y_test).mean()

# 打印结果
print(f"""SVC: 
 --> 训练耗时：{start_predict-start_fit} 秒；
 --> 推理耗时：{stop_predict-start_predict} 秒；
 --> 准确率：{acc} ;""")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

SVC:
–> 训练耗时：22.884344339370728 秒；
–> 推理耗时：10.314218997955322 秒；
–> 准确率：0.7188571428571429 ;