机器学习项目---预测心脏病（二）
发布时间
阅读量：
阅读量
数据管理和信息提取可参考前期内容
from sklearn.model_selection import train_test_split
X = dataset.drop('target', axis=1)
y = dataset.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)构建机器学习模型
已将数据划分为训练集与测试集，并已做好相应准备。
在训练集中对其进行训练（识别规律）。
随后，在测试集中进行评估（验证规律）。
我们计划考察六种不同类型的机器学习算法：
逻辑回归模型（Logistic regression model）、最近邻分类算法（Nearest neighbor classification algorithm）、支持向量机方法（Support vector machine method）、决策树分类系统（Decision tree classification system）、随机森林分类策略（Random forest classification strategy）、XGBoost增强学习算法（XGBoost boosting learning algorithm）
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
def print_score(clf, X_train, y_train, X_test, y_test, train=True):
if train:
pred = clf.predict(X_train)
clf_report = pd.DataFrame(classification_report(y_train, pred, output_dict=True))
print("Train Result:\n================================================")
print(f"Accuracy Score: {accuracy_score(y_train, pred) * 100:.2f}%")
print("_______________________________________________")
print(f"CLASSIFICATION REPORT:\n{clf_report}")
print("_______________________________________________")
print(f"Confusion Matrix: \n {confusion_matrix(y_train, pred)}\n")
elif train==False:
pred = clf.predict(X_test)
clf_report = pd.DataFrame(classification_report(y_test, pred, output_dict=True))
print("Test Result:\n================================================")
print(f"Accuracy Score: {accuracy_score(y_test, pred) * 100:.2f}%")
print("_______________________________________________")
print(f"CLASSIFICATION REPORT:\n{clf_report}")
print("_______________________________________________")
print(f"Confusion Matrix: \n {confusion_matrix(y_test, pred)}\n") 分类报告：sklearn.metrics.classification_report(y_true, y_pred, labels=None, target_names=None,sample_weight=None, digits=2)，显示主要的分类指标，返回每个类标签的精确、召回率及F1值
精度(precision) = 正确预测的个数(TP)/被预测正确的个数(TP+FP)
召回率(recall)=正确预测的个数(TP)/预测个数(TP+FN)
F1 = 2精度召回率/(精度+召回率)Logistic Regression（逻辑回归算法）
from sklearn.linear_model import LogisticRegression
lr_clf = LogisticRegression(solver='liblinear')
lr_clf.fit(X_train, y_train)
print_score(lr_clf, X_train, y_train, X_test, y_test, train=True)
print_score(lr_clf, X_train, y_train, X_test, y_test, train=False)
直观明了地掌握逻辑回归的基本原理。通过图形界面观察该算法模型主要采用LogisticRegression类进行建模。代码块中的参数设置包括求解器设置为'solver=liblinear'以及正则化项参数'penalty'和惩罚系数'C'的值等技术细节未被展示完整
API的介绍：
solver:*{‘liblinear’, ‘sag’, ‘saga’,‘newton-cg’, ‘lbfgs’}，默认: ‘liblinear’；用于优化问题的算法。（对于小数据集来说，“liblinear”是个不错的选择，而“sag”和’saga’对于大型数据集会更快。对于多类问题，只有’newton-cg’， ‘sag’， 'saga’和’lbfgs’可以处理多项损失;“liblinear”仅限于“one-versus-rest”分类。）
penalty：在调参时如果我们主要的目的只是为了解决过拟合，一般penalty选择L2正则化就够了。但是如果选择L2正则化发现还是 过拟合，即预测效果差的时候，就可以考虑L1正则化。（如果是L2正则化，那么4种可选的算法{‘newton-cg’, ‘lbfgs’, ‘liblinear’, ‘sag’}都可以选择。但是如果penalty是L1正则化的话，就只能选择‘liblinear’了。）
C：一个浮点数，它指定了惩罚系数的倒数。如果它的值越小，则正则化越大。
训练数据模型
sklearn.linear_model.LogisticRegression（）.fit(X_train, y_train)K-nearest neighbors（K-邻值算法）
在sklearn库中，KNeighborsClassifier是实现K近邻算法的一个类，一般都使用欧式距离进行测量 from sklearn.neighbors import KNeighborsClassifier
knn_clf = KNeighborsClassifier()
knn_clf.fit(X_train, y_train)
print_score(knn_clf, X_train, y_train, X_test, y_test, train=True)
print_score(knn_clf, X_train, y_train, X_test, y_test, train=False)
在这里插入图片描述
直观易懂地掌握k近邻算法的核心原理：
选择5个邻居进行分类处理，
采用默认设置构建模型，
并可调整其他参数优化性能。
API详解如下：
n_neighbors参数：决定使用的近邻数量，默认为5个，
用于定义分类时参考多少个邻居的信息；
weights参数：定义投票机制中使用的权重类型，默认为均匀权重，
影响最终分类结果的准确性。
uniform’：同一的权重，即每个邻域中的所有点都是平均加权的。
‘distance’ ：这种情况下，距离越近权重越大，反之，距离越远其权重越小。
algorithm ：用于计算最近邻居的算法,。有{‘auto’, ‘ball_tree’, ‘kd_tree’, ‘brute’}
‘auto’ ：根据样本数据自动刷选合适的算法。
‘ball_tree’：构建“球树”算法模型。
‘kd_tree’ ：‘’kd树‘’算法。
max_iter ：最大迭代次数。-1为无限制,默认300。
sklearn.neighbors.fit(X_train, y_train)SVC(支持向量机)
from sklearn.svm import SVC
svm_clf = SVC(kernel='rbf', gamma=0.1, C=1.0)
svm_clf.fit(X_train, y_train)
print_score(svm_clf, X_train, y_train, X_test, y_test, train=True)
print_score(svm_clf, X_train, y_train, X_test, y_test, train=False)
简单粗暴的理解SVC算法：
几个常见的API介绍：
kernel ：核函数，默认是rbf，可以是‘linear’, ‘poly’, ‘rbf’, ‘sigmoid’, ‘precomputed’
– 线性：u’v
– 多项式：(gamma*u’v + coef0)^degree
– RBF函数：exp(-gamma|u-v|^2)
–sigmoid：tanh(gammau’*v + coef0)
degree ：多项式poly函数的维度，默认是3，选择其他核函数时会被忽略。
gamma ： ‘rbf’,‘poly’ 和‘sigmoid’的核函数参数。默认是’auto’，则会选择1/n_features
- gamma越大，高斯图形越窄，模型复杂度越高，容易导致过拟合
- gamma越小，高斯图形越宽，模型复杂度越低，容易导致欠拟合
C：C-SVC的惩罚参数C?默认值是1.0
max_iter ：最大迭代次数。-1为无限制。决策树
from sklearn.tree import DecisionTreeClassifier
tree_clf = DecisionTreeClassifier(random_state=42)
tree_clf.fit(X_train, y_train)
print_score(tree_clf, X_train, y_train, X_test, y_test, train=True)
print_score(tree_clf, X_train, y_train, X_test, y_test, train=False)
一种直接且高效的理解决策树算法设计思路：
max_features: 支持整数、浮点数、字符串或None类型（默认值为None）
max_depth: 支持整数或None类型（默认值为"None"）
min_samples_split: 支持整数值与浮点数值（默认值为2）
min_samples_leaf: 支持整数与浮点数值（默认值为1）
min_weight_fraction_leaf: 浮点数值（默认值为0）
官网地址：https://scikitlearn.org/dev/modules/generated/sklearn.tree.DecisionTreeClassifier.html#sklearn.tree.DecisionTreeClassifier
Random Forest（随机森林）
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import RandomizedSearchCV
rf_clf = RandomForestClassifier(n_estimators=1000, random_state=42)
rf_clf.fit(X_train, y_train)
print_score(rf_clf, X_train, y_train, X_test, y_test, train=True)
print_score(rf_clf, X_train, y_train, X_test, y_test, train=False)
简单粗暴的理解随机森林算法：
随机森林就是集成学习思想下的产物，将许多棵决策树整合成森林，并合起来用来预测最终结果。
在这里插入图片描述
此图可以帮助更好的理解（图来至博客）侵删，可以简单的理解就是决策树就是构建分类的模型，每个节点代表着一个属性，根据这个属性的划分，进入这个节点的儿子节点，直至叶子节点，每个叶子节点都表征着一定的类别，从而达到分类的目的。而随机森林实际上是一种特殊的袋算法方法，它将决策树用作袋算法中的模型。粗暴理解就是整合
RandomForestClassifier（n_estimators=10, criterion=‘gini’, max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features=’auto’, max_leaf_nodes=None, min_impurity_decrease=0.0, min_impurity_split=None, bootstrap=True, oob_score=False, n_jobs=1, random_state=None, verbose=0, warm_start=False, class_weight=None)）的API的介绍：
n_estimators : integer, optional (default=10) 整数，可选择(默认值为10)。指森林中树的个数
criterion : string, optional (default=”gini”) 字符串，可选择(默认值为“gini”)。用于衡量分类的质量。支持的规则有gini和entropy。其中gini用gini不纯度来衡量，基尼不纯度（Gini impurity），度量一个集合中每种类型的比例。entropy用信息增益来度量。
max_features : int, float, string or None, optional (default=”auto”) 整数，浮点数，字符串或者无值，可选的（默认值为"auto"）
max_depth : integer or None, optional (default=None) 整数或者无值，可选的（默认为None）指树的最大深度
min_samples_split : int, float, optional (default=2) 整数，浮点数，可选的（默认值为2）分裂一个内部节点所需的最少样本数。
min_samples_leaf : int, float, optional (default=1) 整数，浮点数，可选的（默认值为1）在新创建的树叶中最少的样本数。
min_weight_fraction_leaf : float, optional (default=0.) 浮点数，可选的（默认值是0.0）在叶子节点中需要输入数据的最少加权分数。
max_leaf_nodes : int or None, optional (default=None) 整数或者无值,可选的（默认值为None）树增长过程中的最大叶子节点数。…
XGBoost Classifer(XGBoost分类器)
from xgboost import XGBClassifier
xgb_clf = XGBClassifier()
xgb_clf.fit(X_train, y_train)
print_score(xgb_clf, X_train, y_train, X_test, y_test, train=True)
print_score(xgb_clf, X_train, y_train, X_test, y_test, train=False)
、
gboost常被视为集成学习领域的巅峰之作。就目前而言，在众多集成方法中它表现尤为出色, 因此掌握这一算法对于深入理解机器学习至关重要. 需要补充的是, 目前scikit-learn中尚未实现xgboost算法, 但可以通过安装相应的库包来实现. 它是基于提升技术构建的一种加法模型, 其训练机制采用分步优化策略, 在每一步迭代中逐步逼近最优解. 值得一提的是, xgbost在实现过程中融入了多项创新性改进: 首先, 默认情况下已实现了对缺失值的有效处理机制; 其次, 增加了梯度二阶估计、L2正则化和随机特征采样, 并支持多线程加速等.
XGBClassifier()分类器的参数
booster
gbtree 树模型做为基分类器（默认）
gbliner 线性模型做为基分类器 silent
silent=0时，输出中间过程（默认）
silent=1时，不输出中间过程 nthread
nthread=-1时，使用全部CPU进行并行运算（默认）
nthread=1时，使用1个CPU进行运算。 scale_pos_weight
正样本的权重，在二分类任务中，当正负样本比例失衡时，设置正样本的权重，模型效果更好。例如，当正负样本比例为1:10时，scale_pos_weight=10。
n_estimatores
含义：总共迭代的次数，即决策树的个数
调参： early_stopping_rounds
含义：在验证集上，当连续n次迭代，分数没有提高后，提前终止训练。
调参：防止overfitting。 max_depth
含义：树的深度，默认值为6，典型值3-10。
调参：值越大，越容易过拟合；值越小，越容易欠拟合。 min_child_weight
含义：默认值为1,。
调参：值越大，越容易欠拟合；值越小，越容易过拟合（值较大时，避免模型学习到局部的特殊样本）。 subsample
含义：训练每棵树时，使用的数据占全部训练集的比例。默认值为1，典型值为0.5-1。
调参：防止overfitting。 colsample_bytree
含义：训练每棵树时，使用的特征占全部特征的比例。默认值为1，典型值为0.5-1。
调参：防止overfitting。
learning_rate
含义：学习率，控制每次迭代更新权重时的步长，默认0.3。
调参：值越小，训练越慢。
典型值为0.01-0.2。 objective 目标函数
回归任务
reg:linear (默认)
reg:logistic
二分类
binary:logistic 概率
binary：logitraw 类别
多分类
multi：softmax num_class=n 返回类别
multi：softprob num_class=n 返回概率
rank:pairwise eval_metric
回归任务(默认rmse)
rmse–均方根误差
mae–平均绝对误差
分类任务(默认error)
auc–roc曲线下面积
error–错误率（二分类）
merror–错误率（多分类）
logloss–负对数似然函数（二分类）
mlogloss–负对数似然函数（多分类） gamma
惩罚项系数，指定节点分裂所需的最小损失函数下降值。
调参： alpha
L1正则化系数，默认为1 lambda
L2正则化系数，默认为1在调参数的情况下训练六个模型
Logistic回归超参数调整
from sklearn.model_selection import GridSearchCV
params = {"C": np.logspace(-4, 4, 20),
"solver": ["liblinear"]}
lr_clf = LogisticRegression()
lr_cv = GridSearchCV(lr_clf, params, scoring="accuracy", n_jobs=-1, verbose=1, cv=5, iid=True)
lr_cv.fit(X_train, y_train)
best_params = lr_cv.best_params_
print(f"Best parameters: {best_params}")
lr_clf = LogisticRegression(**best_params)
lr_clf.fit(X_train, y_train)
print_score(lr_clf, X_train, y_train, X_test, y_test, train=True)
print_score(lr_clf, X_train, y_train, X_test, y_test, train=False)
```![在这里插入图片描述]()
### K最近邻居超参数调整
```python
train_score = []
test_score = []
neighbors = range(1, 30)
for k in neighbors:
model = KNeighborsClassifier(n_neighbors=k)
model.fit(X_train, y_train)
train_score.append(accuracy_score(y_train, model.predict(X_train)))
#test_score.append(accuracy_score(y_test, model.predict(X_test)))
plt.figure(figsize=(12, 8))
plt.plot(neighbors, train_score, label="Train score")
# plt.plot(neighbors, test_score, label="Test score")
plt.xticks(np.arange(1, 21, 1))
plt.xlabel("Number of neighbors")
plt.ylabel("Model score")
plt.legend()
print(f"Maximum KNN score on the test data: {max(train_score)*100:.2f}%")
knn_clf = KNeighborsClassifier(n_neighbors=27)
knn_clf.fit(X_train, y_train)
print_score(knn_clf, X_train, y_train, X_test, y_test, train=True)
print_score(knn_clf, X_train, y_train, X_test, y_test, train=False)
支持向量机超参数调整
svm_clf = SVC(kernel='rbf', gamma=0.1, C=1.0)
params = {"C":(0.1, 0.5, 1, 2, 5, 10, 20),
"gamma":(0.001, 0.01, 0.1, 0.25, 0.5, 0.75, 1),
"kernel":('linear', 'poly', 'rbf')}
svm_cv = GridSearchCV(svm_clf, params, n_jobs=-1, cv=5, verbose=1, scoring="accuracy")
svm_cv.fit(X_train, y_train)
best_params = svm_cv.best_params_
print(f"Best params: {best_params}")
svm_clf = SVC(**best_params)
svm_clf.fit(X_train, y_train)
print_score(svm_clf, X_train, y_train, X_test, y_test, train=True)
print_score(svm_clf, X_train, y_train, X_test, y_test, train=False)
决策树分类器超参数调整
params = {"criterion":("gini", "entropy"),
"splitter":("best", "random"),
"max_depth":(list(range(1, 20))),
"min_samples_split":[2, 3, 4],
"min_samples_leaf":list(range(1, 20))
}
tree_clf = DecisionTreeClassifier(random_state=42)
tree_cv = GridSearchCV(tree_clf, params, scoring="accuracy", n_jobs=-1, verbose=1, cv=3, iid=True)
tree_cv.fit(X_train, y_train)
best_params = tree_cv.best_params_
print(f'Best_params: {best_params}')
tree_clf = DecisionTreeClassifier(**best_params)
tree_clf.fit(X_train, y_train)
print_score(tree_clf, X_train, y_train, X_test, y_test, train=True)
print_score(tree_clf, X_train, y_train, X_test, y_test, train=False)
随机森林分类器超参数调整
n_estimators = [int(x) for x in np.linspace(start=200, stop=2000, num=10)]
max_features = ['auto', 'sqrt']
max_depth = [int(x) for x in np.linspace(10, 110, num=11)]
max_depth.append(None)
min_samples_split = [2, 5, 10]
min_samples_leaf = [1, 2, 4]
bootstrap = [True, False]
params_grid = {'n_estimators': n_estimators, 'max_features': max_features,
'max_depth': max_depth, 'min_samples_split': min_samples_split,
'min_samples_leaf': min_samples_leaf, 'bootstrap': bootstrap}
rf_clf = RandomForestClassifier(random_state=42)
rf_cv = GridSearchCV(rf_clf, params_grid, scoring="accuracy", cv=3, verbose=2, n_jobs=-1)
rf_cv.fit(X_train, y_train)
best_params = rf_cv.best_params_
print(f"Best parameters: {best_params}")
rf_clf = RandomForestClassifier(**best_params)
rf_clf.fit(X_train, y_train)
print_score(rf_clf, X_train, y_train, X_test, y_test, train=True)
print_score(rf_clf, X_train, y_train, X_test, y_test, train=False)
XGBoost分类器超参数调整
n_estimators = [100, 500, 900, 1100, 1500]
max_depth = [2, 3, 5, 10, 15]
booster = ['gbtree', 'gblinear']
base_score = [0.25, 0.5, 0.75, 0.99]
learning_rate = [0.05, 0.1, 0.15, 0.20]
min_child_weight = [1, 2, 3, 4]
params_grid = {
'n_estimators': n_estimators, 'max_depth': max_depth,
'learning_rate' : learning_rate, 'min_child_weight' : min_child_weight,
'booster' : booster, 'base_score' : base_score
}
xgb_clf = XGBClassifier()
xgb_cv = GridSearchCV(xgb_clf, params_grid, cv=3, scoring = 'accuracy',n_jobs =-1, verbose=1)
xgb_cv.fit(X_train, y_train)
best_params = xgb_cv.best_params_
print(f"Best paramters: {best_params}")
xgb_clf = XGBClassifier(**best_params)
xgb_clf.fit(X_train, y_train)
print_score(xgb_clf, X_train, y_train, X_test, y_test, train=True)
print_score(xgb_clf, X_train, y_train, X_test, y_test, train=False)
没有调参的情况下：
调了参数的情况下
实际上经过参数调整优化后效果提升有限其根本原因是训练数据样本数量过少导致模型学习能力受限
删除了代码来源（一位大佬的笔记本）
全部评论 (0)
还没有任何评论哟~