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. 流程

  

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

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

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

1. from sklearn.datasets import make_classification
2. from sklearn.model_selection import train_test_split
3. import numpy as np
4. import time
6. # 读取数据
7. X=[]
8. y=[]
9. file_name='./心血管疾病数据集.csv'
10. with open(file = file_name,mode='r',encoding='utf8') as f:
11.     line_first = np.array(f.readline().strip().split(','))
12.     for line in f:  
13.         if line:
14.             line = f.readline().strip().split(',')
15.             X.append(line[:-1])
16.             y.append(line[-1])
18. # 将数据转为numpy数组
19. X=np.array(X)
20. y=np.array(y)
22. # 把所有数据都转为float类型
23. X=X.astype(float)
24. y=y.astype(float)
25. # 删掉第1列id
26. X=X[:,1:]
28. # 切分数据
29. from sklearn.model_selection import train_test_split
30. X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2)
32. # 数据预处理（规范化）
33. _mean = X_train.mean(axis=0)
34. _std = X_train.std(axis=0)
35. X_train = (X_train-_mean)/(_std+1e-9)
36. X_test = (X_test-_mean)/(_std+1e-9)

复制代码

4.1 KNN

1. """
2.     测试1：KNN
3. """
4. from sklearn.neighbors import KNeighborsClassifier
5. knn = KNeighborsClassifier(n_neighbors=5)
6. # 取一个时间戳
7. start_fit = time.time()
8. knn.fit(X=X_train, y=y_train)
9. # 取一个时间戳
10. start_predict = time.time()
11. y_pred = knn.predict(X=X_test)
12. # 取一个时间戳
13. stop_predict = time.time()
14. # 评估
15. acc = ( y_pred== y_test).mean()
17. # 打印结果
18. print(f"""KNN:
19. --> 训练耗时：{start_predict-start_fit} 秒；
20. --> 推理耗时：{stop_predict-start_predict} 秒；
21. --> 准确率：{acc} ;""")

复制代码

KNN:
–> 训练耗时：0.04751253128051758 秒；
–> 推理耗时：1.3453574180603027 秒；
–> 正确率：0.6402857142857142 ;
  4.2 高斯朴素贝叶斯

1. """
2.     测试2：高斯朴素贝叶斯
3. """
4. from sklearn.naive_bayes import GaussianNB
5. gnb = GaussianNB()
6. # 取一个时间戳
7. start_fit = time.time()
8. gnb.fit(X=X_train, y=y_train)
9. # 取一个时间戳
10. start_predict = time.time()
11. y_pred = gnb.predict(X=X_test)
12. # 取一个时间戳
13. stop_predict = time.time()
14. # 评估
15. acc = ( y_pred== y_test).mean()
17. # 打印结果
18. print(f"""GNB:
19. --> 训练耗时：{start_predict-start_fit} 秒；
20. --> 推理耗时：{stop_predict-start_predict} 秒；
21. --> 准确率：{acc} ;""")

复制代码

GNB:
–> 训练耗时：0.009502649307250977 秒；
–> 推理耗时：0.0010018348693847656 秒；
–> 正确率：0.5931428571428572 ;
  4.3 决策树

1. """
2.     测试3：决策树
3. """
4. from sklearn.tree import DecisionTreeClassifier
5. dtc = DecisionTreeClassifier()
6. # 取一个时间戳
7. start_fit = time.time()
8. dtc.fit(X=X_train, y=y_train)
9. # 取一个时间戳
10. start_predict = time.time()
11. y_pred = dtc.predict(X=X_test)
12. # 取一个时间戳
13. stop_predict = time.time()
14. # 评估
15. acc = ( y_pred==y_test).mean()
17. # 打印结果
18. print(f"""DTC:
19. --> 训练耗时：{start_predict-start_fit} 秒；
20. --> 推理耗时：{stop_predict-start_predict} 秒；
21. --> 准确率：{acc} ;""")

复制代码

DTC:
–> 训练耗时：0.11947154998779297 秒；
–> 推理耗时：0.002510547637939453 秒；
–> 正确率：0.6367142857142857 ;
  4.4 随机丛林

1. """
2.     测试4：随机森林
3. """
4. from sklearn.ensemble import RandomForestClassifier
5. rfc = RandomForestClassifier()
6. # 取一个时间戳
7. start_fit = time.time()
8. rfc.fit(X=X_train, y=y_train)
9. # 取一个时间戳
10. start_predict = time.time()
11. y_pred = rfc.predict(X=X_test)
12. # 取一个时间戳
13. stop_predict = time.time()
14. # 评估
15. acc = ( y_pred==y_test).mean()
17. # 打印结果
18. print(f"""RFC:
19. --> 训练耗时：{start_predict-start_fit} 秒；
20. --> 推理耗时：{stop_predict-start_predict} 秒；
21. --> 准确率：{acc} ;""")

复制代码

RFC:
–> 训练耗时：3.7813894748687744 秒；
–> 推理耗时：0.18322372436523438 秒；
–> 正确率：0.715 ;
  4.5 支持向量机

1. """
2.     测试5：支持向量机
3. """
4. from sklearn.svm import SVC
5. svc = SVC()
6. # 取一个时间戳
7. start_fit = time.time()
8. svc.fit(X=X_train, y=y_train)
9. # 取一个时间戳
10. start_predict = time.time()
11. y_pred = svc.predict(X=X_test)
12. # 取一个时间戳
13. stop_predict = time.time()
14. # 评估
15. acc = ( y_pred==y_test).mean()
17. # 打印结果
18. print(f"""SVC:
19. --> 训练耗时：{start_predict-start_fit} 秒；
20. --> 推理耗时：{stop_predict-start_predict} 秒；
21. --> 准确率：{acc} ;""")

复制代码

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

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！ 更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。