基于几个多分类的算法实现中风预测（准确率95.5%）
基于多个分类的算法实现中风预测（准确率96.5%）项目目的代码流程1.导入必需要的库函数2.准备数据3.数据信息简单查看/属性信息3.1 数据信息简单查看图3.2 属性信息表4.删掉ID列和查看数据的整体信息5. 对于特征进行一些统计描述6.查看缺失值并补填7.数据可视化查看中风的可视化8.种类转换为数字9.编码算法（OneHotEncoder）10.导入sklearn库的几个分类算法11.利用几
基于多个分类的算法实现中风预测（准确率96.5%）
项目目的
中风是一种较为严重的脑血管疾病，中风的致残率及致死率均较高，中风发病前也有不少先兆症状。预测中风发生的可能性是存在的，引发中风的危险因素已基本查明，例如：有中风家族史、肥胖、高血压病、高血脂症、糖尿病、冠心病及有嗜好烟酒、劳逸不当的生活习惯等，尤其是当高血压病病情不稳定时，发生中风的可能性就比较大。
我们可以利用多几个分类算法（如随机森林，朴素贝叶斯，k_mean等）来实现中风预测的准确率，再确定选哪个最佳的算法。好了，不废话多了，直接上代码看看效果。
代码流程
1.导入必需要的库函数
在实践的最开始，我们首先需要导入一些基础的函数库包括：numpy （Python进行科学计算的基础软件包），pandas（pandas是一种快速，强大，灵活且易于使用的开源数据分析和处理工具），matplotlib和seaborn绘图。
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
sns.set_style('darkgrid')
import warnings
warnings.filterwarnings('ignore')
2.准备数据
我是在Kaggle官方网里下载数据文件。大家可以直接点击这地址下载：https://www.kaggle.com/fedesoriano/stroke-prediction-dataset.
3.数据信息简单查看/属性信息
进行简单的数据查看，我们可以利用 .head() 头部.tail()尾部
df=pd.read_csv("./healthcare-dataset-stroke-data (1).csv")
df.head().append(df.tail())
3.1 数据信息简单查看图
利用.info()查看数据的整体信息
df.info()
我们发现以上的整体信息里有三个类型。object,int64和float64
5. 对于特征进行一些统计描述
x.describe()
注意：统计描述只能针对int64和float64进行统计。如下
6.查看缺失值并补填
查看缺失值
#查看缺失值
df.isnull().sum()
我们发现bmi缺失值共有201个，那么我们将它补填一下
填充缺失值
#填充缺失值
df['bmi'].fillna(df['bmi'].mean,inplace=True)
df.isnull().sum()
查下已经补填充完成。
7.数据可视化
#箱型可视化
#平均血糖水平
sns.boxplot(x='avg_glucose_level',data=df,color='red')
#bmi体重指数
sns.boxplot(x='age',data=df,color='blue')
查看中风的可视化
plt.figure(figsize=(10,5))
stroke = df.loc[df['stroke']==1]
sns.countplot(data=stroke,x='ever_married', palette="Set2")
plt.title("Stroke / Ever-Married")
#看来已婚人士中风的人数明显高于单身人士！有趣的
plt.figure(figsize=(10,5))
stroke = df.loc[df['stroke']==1]
sns.countplot(data=stroke,x='work_type', palette="Set2")
plt.title("Stroke / Work Type")
看来私人营业的中风明显高于其他的
plt.figure(figsize=(10,5))
stroke = df.loc[df['stroke']==1]
sns.countplot(data=stroke,x='smoking_status', palette="Set2")
plt.title("Stroke / Smoking Status")
在过去抽烟者和现在抽烟者中间，从不抽烟的中锋明显严重，看来中不中风跟抽烟没关系
plt.figure(figsize=(10,5))
stroke = df.loc[df['stroke']==1]
sns.countplot(data=stroke,x='hypertension', palette="Set2")
plt.title("Stroke / Hypertension")
#没有高血压的中风却比有高血压的高，不科学嘛
plt.figure(figsize=(10,5))
stroke = df.loc[df['stroke']==1]
sns.countplot(data=stroke,x='hypertension', palette="Set2")
plt.title("Stroke / Hypertension")
#没有高血压的中风却比有高血压的高，不科学嘛
8.种类转换为数字
上面我们在整体信息里面提过它们共有三个类型：object,int,float对吧。接下来，我们可以把object里的几个种类转换为数字，就是说用数字来代替它们。
住宅类型共有两个种类：城市和农村，我们可以用0代表城市，1代表农村。
单身状态：0代表no,1代码yes…代码如下：
residence_mapping = {'Urban': 0, 'Rural': 1}
df['Residence_type'] = df['Residence_type'].map(residence_mapping)
marriage_mapping = {'No': 0, 'Yes': 1}
df['ever_married'] = df['ever_married'].map(marriage_mapping)
df.info()
看到吗，之前是object类型，现在是int64类型。
下面我们继续吧几个object的类型转成数字类型。
我们可以利用unique()来查看多少个种类
df['gender'].unique()
df['smoking_status'].unique()
df['work_type'].unique()
"gender” 共有三个种类：array([‘Male’, ‘Female’, ‘Other’], dtype=object)
“smoking_status”共有四个：array([‘formerly smoked’, ‘never smoked’, ‘smokes’, ‘Unknown’],
dtype=object)
“work_type”共有五个：array([‘Private’, ‘Self-employed’, ‘Govt_job’, ‘children’, ‘Never_worked’],
dtype=object)
有点麻烦，怎么办？我们用LabelEncoder,OneHotEncoder 算法实现对目标标签进行编码
9.编码算法（OneHotEncoder）
导入sklearn库
from sklearn.preprocessing import LabelEncoder,OneHotEncoder
#使用0到n_classes-1之间的值对目标标签进行编码/将分类特征编码为一键式数字数组
ohe=OneHotEncoder()
df['gender'] = pd.Categorical(df['gender'])
dfdummies_gender=pd.get_dummies(df['gender'],prefix='gender_encoded')
df['smoking_status']=pd.Categorical(df['smoking_status'])
dfmumies_smoking_status=pd.get_dummies(df['smoking_status'],prefix='smoking_status_encode')
df['work_type'] = pd.Categorical(df['work_type'])
dfDummies_work_type = pd.get_dummies(df['work_type'], prefix = 'work_type_encoded')
#删除三个列
df.drop(['gender'], axis=1, inplace=True)
df.drop(["work_type"], axis=1, inplace=True)
df.drop(["smoking_status"], axis=1, inplace=True)
df.info()
删除三个列后的情况：
然后把编码好的列加入
#新的列加入
df=pd.concat([df,dfdummies_gender],axis=1)
df=pd.concat([df,dfDummies_work_type],axis=1)
df=pd.concat([df,dfmumies_smoking_status],axis=1)
df.info()
这样，我们已经成功将object类型转换成数字类型。不错了吧。是不是简单得多
现在开始用机器学习的几个多分类算法实现吧
10.导入sklearn库的几个分类算法
#导入sklearn库
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler #通过去除均值并缩放到单位方差来标准化特征
from sklearn.linear_model import LogisticRegression #Logistic回归（又名logit，MaxEnt）分类器。
from sklearn.naive_bayes import GaussianNB
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.ensemble import RandomForestClassifier #随机森林分类器。
from sklearn.neighbors import KNeighborsClassifier #分类器执行k最近邻居投票。
from sklearn.ensemble import GradientBoostingClassifier #用于分类的梯度增强
from xgboost import XGBClassifier
from sklearn.neural_network import MLPClassifier #多层感知器分类器。
from sklearn.linear_model import SGDClassifier #具有SGD训练的线性分类器（SVM，逻辑回归等）。
from sklearn.metrics import confusion_matrix,accuracy_score #计算混淆矩阵以评估分类的准确性。
from sklearn.metrics import classification_report #建立一个显示主要分类指标的文本报告。
#准备机器学习模型
std=StandardScaler()
columns = ['avg_glucose_level','bmi','age']
scaled = std.fit_transform(df[['avg_glucose_level','bmi','age']])
scaled = pd.DataFrame(scaled,columns=columns)
#删除三个列'avg_glucose_level','bmi','age'
df=df.drop(columns=columns,axis=1)
df=df.merge(scaled, left_index=True, right_index=True, how = "left")
df
因为我们利用StandardScaler()把三个列标准化成特征最小的单位
这样大大的提高训练速度。
11.利用几个分类算法进行训练数据和预测
#将stroke作为目标
#然后把strole从表里去掉，然后划分为80%作为训练集，20%作为测试
y=df['stroke']
x=df.drop(['stroke'],axis=1)
x_train,x_test,y_train,y_test=train_test_split(x,y,test_size=0.2,random_state=100)
print(f'Total # of sample in whole dataset: {len(x)}')
print(f'Total # of sample in train dataset: {len(x_train)}')
print(f'Total # of sample in test dataset: {len(x_test)}')
Total # of sample in whole dataset: 5110
Total # of sample in train dataset: 4088
Total # of sample in test dataset: 1022
11.1 逻辑回归算法
#逻辑回归模型
model_lgr='Logistic Regression'
lr=LogisticRegression()
model_lr=lr.fit(x_train,y_train)
lr_pred=lr.predict(x_test)
#混淆阵
lr_conf_matrix=confusion_matrix(y_test,lr_pred)
#准确率：
lr_acc=accuracy_score(y_test,lr_pred)
print("confussion matrix")
print(lr_conf_matrix)
print("-------------------------------------------")
print("Accuracy of Logistic Regression:",lr_acc*100,'\n')
print("-------------------------------------------")
print(classification_report(y_test,lr_pred))
11.2 朴素贝叶斯算法
#朴素
model_nb='Naive Bayes'
nb=GaussianNB()
nb.fit(x_train,y_train)
nb_pred=nb.predict(x_test)
nb_acc=accuracy_score(y_test,nb_pred)
nb_conf_matrix=confusion_matrix(y_test,nb_pred)
print("confussion matrix")
print(nb_conf_matrix)
print("-------------------------------------------")
print("Accuracy of Naive Bayes model:",nb_acc*100,'\n')
print("-------------------------------------------")
print(classification_report(y_test,nb_pred))
11.3 随机森林算法
#随机森林分类器
model_rfc = 'Random Forest Classfier'
rf = RandomForestClassifier(n_estimators=10, random_state=120,max_depth=5)
rf.fit(x_train,y_train)
rf_predicted = rf.predict(x_test)
rf_conf_matrix = confusion_matrix(y_test, rf_predicted)
rf_acc_score = accuracy_score(y_test, rf_predicted)
print("confussion matrix")
print(rf_conf_matrix)
print("-------------------------------------------")
print("Accuracy of Random Forest:",rf_acc_score*100,'\n')
print("-------------------------------------------")
print(classification_report(y_test,rf_predicted))
11.4 EGBoost算法
model_egb = 'Extreme Gradient Boost'
xgb = XGBClassifier(learning_rate=0.01, n_estimators=15, max_depth=10,gamma=0.6, subsample=0.52,colsample_bytree=0.6,seed=27,
reg_lambda=2, booster='gbtree', colsample_bylevel=0.6, colsample_bynode=0.5)
xgb.fit(x_train, y_train)
xgb_predicted = xgb.predict(x_test)
xgb_conf_matrix = confusion_matrix(y_test, xgb_predicted)
xgb_acc_score = accuracy_score(y_test, xgb_predicted)
print("confussion matrix")
print(xgb_conf_matrix)
print("-------------------------------------------")
print("Accuracy of Extreme Gradient Boost:",xgb_acc_score*100,'\n')
print("-------------------------------------------")
print(classification_report(y_test,xgb_predicted))
11.5 Gradient Boost算法
model_gb = 'Gradient Boost'
gb = GradientBoostingClassifier(random_state=0)
gb.fit(x_train, y_train)
gb_predicted = gb.predict(x_test)
gb_conf_matrix = confusion_matrix(y_test, gb_predicted)
gb_acc_score = accuracy_score(y_test, gb_predicted)
print("confussion matrix")
print(gb_conf_matrix)
print("-------------------------------------------")
print("Accuracy of Gradient Boosting:",gb_acc_score*100,'\n')
print("-------------------------------------------")
print(classification_report(y_test,gb_predicted))
11.6 K邻近算法
model_knn = 'K-NeighborsClassifier'
knn = KNeighborsClassifier(n_neighbors=10)
knn.fit(x_train, y_train)
knn_predicted = knn.predict(x_test)
knn_conf_matrix = confusion_matrix(y_test, knn_predicted)
knn_acc_score = accuracy_score(y_test, knn_predicted)
print("confussion matrix")
print(knn_conf_matrix)
print("-------------------------------------------")
print("Accuracy of K-NeighborsClassifier:",knn_acc_score*100,'\n')
print("-------------------------------------------")
print(classification_report(y_test,knn_predicted))
11.6 决策树算法
model_dtc = 'DecisionTreeClassifier'
dt = DecisionTreeClassifier(criterion = 'entropy',random_state=0,max_depth = 5)
dt.fit(x_train, y_train)
dt_predicted = dt.predict(x_test)
dt_conf_matrix = confusion_matrix(y_test, dt_predicted)
dt_acc_score = accuracy_score(y_test, dt_predicted)
print("confussion matrix")
print(dt_conf_matrix)
print("-------------------------------------------")
print("Accuracy of DecisionTreeClassifier:",dt_acc_score*100,'\n')
print("-------------------------------------------")
print(classification_report(y_test,dt_predicted))
这将产生一个流程图。:
#### 11.7 支持向量机算法
model_svc = 'Support Vector Classifier'
svc = SVC(kernel='rbf', C=5)
svc.fit(x_train, y_train)
svc_predicted = svc.predict(x_test)
svc_conf_matrix = confusion_matrix(y_test, svc_predicted)
svc_acc_score = accuracy_score(y_test, svc_predicted)
print("confussion matrix")
print(svc_conf_matrix)
print("-------------------------------------------")
print("Accuracy of Support Vector Classifier:",svc_acc_score*100,'\n')
print("-------------------------------------------")
print(classification_report(y_test,svc_predicted))
11.8 随机梯度下降算法
model_sgd = 'Stochastic Gradient Descent'
sgdc = SGDClassifier(max_iter=5000, random_state=0)
sgdc.fit(x_train, y_train)
sgdc_predicted = sgdc.predict(x_test)
sgdc_conf_matrix = confusion_matrix(y_test, sgdc_predicted)
sgdc_acc_score = accuracy_score(y_test, sgdc_predicted)
print("confussion matrix")
print(sgdc_conf_matrix)
print("-------------------------------------------")
print("Accuracy of : Stochastic Gradient Descent",sgdc_acc_score*100,'\n')
print("-------------------------------------------")
print(classification_report(y_test,sgdc_predicted))
差不多就这样吧，还有其他的分类算法可以自己写
12.统计算法可视化并选择最佳算法
将上面的八个算法统计并列出
model_ev={"Model":[model_sgd,model_svc,model_dtc,model_knn,model_gb,model_egb,model_rfc,model_nb,model_lgr],
"Accuracy":[sgdc_acc_score,svc_acc_score,dt_acc_score,knn_acc_score,gb_acc_score,xgb_acc_score,rf_acc_score,nb_acc,
lr_acc]
}
pd.DataFrame(model_ev)
12.1 可视化
colors = ['red','green','blue','gold','silver','yellow','orange','magenta', 'cyan']
plt.figure(figsize=(12,5))
plt.title("barplot Represent Accuracy of different models")
plt.xlabel("Accuracy %")
plt.xticks(rotation=90)
plt.ylabel("Algorithms")
plt.bar(model_ev['Model'],model_ev['Accuracy'], color = colors)
plt.show()
13.结论
通过八个分类算法进行训练下能看得出来除了贝叶斯算法以外，其他的算法还算不错。准确率95.5%吧。
大家要是喜欢的话多多点赞，多多关顾哦！爱你们！
觉得不好的请高贵指教，谢谢哈
flowchart.js/
华为开发者空间，是为全球开发者打造的专属开发空间，汇聚了华为优质开发资源及工具，致力于让每一位开发者拥有一台云主机，基于华为根生态开发、创新。
更多推荐
23
2- 0
已为社区贡献1条内容
所有评论(0)