机器学习皮马印第安人糖尿病数据集预测报告

        我国的糖尿病患者初诊时约８０％已出现慢性并发症，而无并发症的患者约 ７５％以上尚未被明确诊断，未能做到早期诊断、早期治疗。资料显示 ，由于我国患者病情控制差，绝大部分病人临床诊断时已经出现并发症，因肾、眼、心脑血管、足等病变的致残率及死亡率，均明显高于国外。其中缺乏糖尿病风险预警机制是主要原因之一。

        如果开展有效的糖尿病风险预警机制，让患者及时了解自己的身体状况，及时就医，那么大部分患者可以获得早期治疗。现在的许多研究已经证实：有效的病情控制 ，可以减少或延缓并发症的发生、发展，降低致残率，提高患者的生活质量，延长患者的寿命。因此，有效的糖尿病风险预警机制，可取得巨大的社会效益。

        本研究在充分调研的前提下，利用皮马印第安人糖尿病数据集，利用Python中的随机森林、决策树、逻辑回归等多种机器学习算法，构建起糖尿病风险预警系统，用户可将自身信息输入到系统中，系统会自动分析是否具有糖尿病的风险，为用户和医生进行健康筛查提供帮助。

        在本次系统的开发过程中，首先要先获取到源数据集，根据数据集中的信息对数据进行清洗与降维处理，保证数据的完整性与一致性；在完成数据集的处理后，就可以在PyCharm中设计机器学习算法模型了，本着对患者负责的心态以及保证分析结果的准确性的目的，在系统中设计了多个算法同时进行预测，并进行多维分析验证；最后设计用户主界面，使用户可以在此界面输入个人身体信息，系统会将信息传递到后台的算法模型当中进行分析，最后给出预测结论。

项目总体设计

2.功能实现

        充分调研的前提下，利用皮马印第安人糖尿病数据集，利用Python中的随机森林、决策树、逻辑回归等多种机器学习算法，构建起糖尿病风险预警系统，用户可将自身信息输入到系统中，系统会自动分析是否具有糖尿病的风险，为用户和医生进行健康筛查提供帮助。

 代码主要在PyCharm平台上编写，依靠其中的Python的编译器环境。

PyCharm是一种Python IDE（Integrated Development Environment，集成开发环境），带有一整套可以帮助用户在使用Python语言开发时提高其效率的工具，比如调试、语法高亮、项目管理、代码跳转、智能提示、自动完成、单元测试、版本控制。此外，该IDE提供了一些高级功能，以用于支持Django框架下的专业Web开发。

• 数据获取：在本次系统设计中采用的数据集来自阿里天池数据集，数据来源：https://tianchi.aliyun.com/dataset/dataDetail?dataId=88343，这个数据集的原始数据来自国家糖尿病消化和肾病机构。数据集的目的是基于数据集中确定的诊断测量指标来预测一个患者是否患有糖尿病。在从更大的数据库中选择这些实例时受到了一些限制。特别是，所有收录于数据集的患者都是至少21周岁的皮马印第安女性。数据集包括多个医学预测变量和一个目标变量。预测变量包括患者的怀孕次数，她们的BMI指数，胰岛素水平，年龄等。
• 数据清洗：数据清洗概念就是去重，检查数据一致性，处理无效值和缺失值等，删除重复信息，纠正存在的错误。就是缺失值进行清洗、确定缺失值范围（对每个字段都计算其缺失值比例，然后按照缺失值比例和字段重要性，分别制定策略）、去除不需要的字段（清洗每做一步时都备份一下，或者在小规模数据上试验成功再处理全量数据）填充缺失内容（以业务知识或经验推测填充缺失值、以同一指标的计算结果（均值，中位数，众数等）填充缺失值）、重新取数（如果某些指标非常重要又缺失率高，需要和数据获取人员了解，是否有其他渠道取到相关数据）。

首先将目标数据集导入到程序中，查看数据的基本情况，这里采用了Pandas中的read.csv()方法将数据导入，并打印出数据所有记录。在查看的过程中发现Glucose、BloodPressure、SkinThickness、Insulin、BMI这5个维度存在缺失现象，对于数据的缺失情况，程序中采用了中值补全的方式，将数据的缺失值补全。

缺失值补全代码展示

在完成补全操作以后，程序中还引入了sklearn中的StandardScaler库对数据进行数据标准化操作，最后将文件保存到电脑上，至此完成数据清洗操作。

数据标准化代码设计

首先，根据所要根据前面选择的算法挑选第三方库，在这里先要导入numpy、pandas等基础库作为基础支撑，其次随机森林、决策树、逻辑回归、KNN、神经网络算法需要在sklearn中进行引入操作，对于xgboost算法模型则需要单独安装和引入。

• 随机森林算法实现：在随机森林算法的实现过程中首先算法所需的变量进行赋值，并划分训练集与测试集。由于数据集较小，共有768条记录，所以在这里选取了738条记录作为训练集，30条记录作为测试集。在拿到训练集后需要调用RandomForestClassifier()随机森林分类器对数据进行训练，系统在完成训练后会导入测试集对算法模型进行测试，输出随机森林算法的算法准确率以及对算法预测结构与真实结果之间的对比，给出算法评分，具体代码如图。

代码运行后可以看到随机森林算法的准确率在90%左右，具有较高的准确性，应用于糖尿病预警分析中具有良好效果。

 随机森林算法结构展示

• 决策树算法实现：决策树的代码实现于前面随机森林的设计过程类似，不同之处在于算法训练中使用了DecisionTreeClassifier()决策树分类器，其余部分大同小异本文不再过多赘述，将中心集中于算法所实现的结果展示，决策树代码如图。

决策树代码展示

对于决策树算法最终得分为0.77，从整体上来看算法准确率偏低，在糖尿病的研究中并不适用。

 决策树算法实现

• 逻辑回归算法实现：就逻辑回归算法的实现结果来看，算法准确率达到了0.93，在算法评级中属于较高的水平，在诊断预测上可以作为重要的参考依据。

逻辑回归算法实现

•  KNN算法实现：在KNN算法对数据集的预测分析中，由于无法在一开始就确定K取何值时准确率最高，所以在程序中采用了循环遍历的方式寻找K值，共遍历14次（K值取1-15），如图所示。

KNN算法程序设计

经过测试以后可以看到KNN算法在K=1时，算法准确率为0.8，为KNN算法在训练中准确率的最小值，如图所示；而当K=14时，KNN算法的准确率达到了0.9，为KNN算法在训练中的最大值，如图所示。可见KNN算法准确率受K值影响较大，需要多次进行拟合测试。

模型得分：0.80，k=1时KNN算法准确率

模型得分：0.90，k=14时KNN算法准确率

• 神经网络算法实现：从图中可知神经网络模型的准确率为0.77，与决策树算法相差不大。

神经网络算法实现

•  XGBoost算法实现：对于XGBoost算法而言，其算法准确率达到了0.93，如图所示。XGBoost算法在糖尿病预警分析系统的算法选择以及权重分配上无疑要居于首位。

XGBoost算法结果展示

主程序设计：根据系统需求分析，用户在打开系统界面时，首先要在主界面输入自己的身体信息，系统会检测输入信息，如果出现信息缺失或其他异常因素时，系统会给出提升并让用户重新输入信息。在接收到正确的信息后，系统会将用户信息传递到后台变量上，交给算法模型进行分析，最后给出用户的糖尿病风险情况。

主程序设计

系统测试：在系统开发的最后，在程序中追加了糖尿病风险预警程序，当用户输入身体信息，后台算法模型训练结束后，风险预警程序默认为当算法模型给出算法准确率大于0.8时，则认为该用户有患上糖尿病的风险。在系统测试中，选取了源数据集中的第一条数据进行系统测试。

系统测试

随机森林算法测试

2.3.3 python代码

import numpy as np
import pandas as pd
from xgboost import XGBClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.neural_network import MLPClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
 
pd.set_option('display.max_rows', 10)
pd.set_option('display.max_columns', 10)
pd.set_option('display.width', 1000)
 
#   导入csv数据
df = pd.read_csv("C:/")
 
#   x为可能导致糖尿病的因素
x = df.drop('Outcome', axis=1)
#   y为诊断结果，1为确诊，2为未确诊
y = df['Outcome']
 
 
#   训练数据(随机森林)
def random_forest():
    #   将数据标准化
    X = df.drop('Outcome', axis=1)
    # 一共768个数据738个作为训练集，30个作为测试集
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=30 / 768, random_state=0)
    # 若数值过大可以标准化，这里数值不算大，标准化后准确值较低，所以注释掉了不进行标准化
    classifier = RandomForestClassifier(criterion='entropy', n_estimators=1000, max_depth=None, min_samples_split=10,
                                        min_weight_fraction_leaf=0.02)
    classifier.fit(X_train, y_train)
    y_pred = classifier.predict(X_test)
    print('随机森林准确率')
    print(confusion_matrix(y_test, y_pred))
    print(classification_report(y_test, y_pred))
    print(accuracy_score(y_test, y_pred))
    a = format(classifier.score(X_test, y_test))
    print(a)
    if float(a) >= 0.8:
        print("有糖尿病风险")
    else:
        print("无糖尿病风险")
    y_ = np.array(y_test)
    print('随机森林预测结果：', classifier.predict(X_test))
    print('真实结果:         ', y_)
    print('-------------------------------------------')
 
 
#   训练数据（决策树）
def decision_tree():
    X = df.drop('Outcome', axis=1)
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=30 / 768)
    # 参数是经过测试得到的最高准确率的参数
    classifier = DecisionTreeClassifier(criterion='entropy', max_depth=3, min_weight_fraction_leaf=0.01)
    classifier.fit(X_train, y_train)
    y_pred = classifier.predict(X_test)
    print('决策树准确率')
    print(confusion_matrix(y_test, y_pred))
    print(classification_report(y_test, y_pred))
    print(accuracy_score(y_test, y_pred))
    b = format(classifier.score(X_test, y_test))
    print(b)
    if float(b) >= 0.8:
        print("有糖尿病风险")
    else:
        print("无糖尿病风险")
    print(format(classifier.score(X_test, y_test) < 0.8))
    y_ = np.array(y_test)
    print('决策树预测结果：', classifier.predict(X_test))
    print('真实结果:         ', y_)
    print('--------------------------------------------------------------------------------------')
 
 
#   训练数据（逻辑回归）
def logistic_regression():
    X = df.drop('Outcome', axis=1)
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=30 / 768, random_state=0)
    lr = LogisticRegression(random_state=0, max_iter=1000)
    lr.fit(X_train, y_train)
    y_pred = lr.predict(X_test)
    print('逻辑回归准确率')
    print(confusion_matrix(y_test, y_pred))
    print(classification_report(y_test, y_pred))
    print(accuracy_score(y_test, y_pred))
    c = format(lr.score(X_test, y_test))
    print(c)
    if float(c) >= 0.8:
        print("有糖尿病风险")
    else:
        print("无糖尿病风险")
    y_ = np.array(y_test)
    print('逻辑回归预测结果：', lr.predict(X_test))
    print('真实结果:         ', y_)
    print('--------------------------------------------------------------------------------------')
 
 
#   训练数据（KNN）寻找最佳的k值
def k_nn():
    X = df.drop('Outcome', axis=1)
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=30 / 768, random_state=0)
    error = []
    # 由于一开始并不清楚K取多少准确率最高，所以写了一个K为1-14的for循环，通过检查误差值来判断最合适的K值
    for k in range(1, 15):
        classifier = KNeighborsClassifier(n_neighbors=k)
        classifier.fit(X_train, y_train)
        y_prediction = classifier.predict(X_test)
        error.append(np.mean(y_prediction != y_test))
        print('当k=', k, '时的准确率')
        print(confusion_matrix(y_test, y_prediction))
        print(classification_report(y_test, y_prediction))
        d = format(classifier.score(X_test, y_test))
        print(d)
        if float(d) >= 0.8:
            print("有糖尿病风险")
        else:
            print("无糖尿病风险")
 
#   训练数据（Neural Networks）
def n_n():
    X = df.drop('Outcome', axis=1)
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=30 / 768, random_state=0)
    mlp = MLPClassifier(random_state=0, max_iter=5000)
    mlp.fit(X_train, y_train)
    y_pred = mlp.predict(X_test)
    print('Neural Network准确率')
    print(confusion_matrix(y_test, y_pred))
    print(classification_report(y_test, y_pred))
    print(accuracy_score(y_test, y_pred))
    e = format(mlp.score(X_test, y_test))
    print(e)
    if float(e) >= 0.8:
        print("有糖尿病风险")
    else:
        print("无糖尿病风险")
    y_ = np.array(y_test)
    print('Neural Network预测结果：', mlp.predict(X_test))
    print('真实结果:         ', y_)
    print('--------------------------------------------------------------------------------------')
 
 
  #训练数据（XGBoost）
def xgb():
    X = df.drop('Outcome', axis=1)
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=30 / 768, random_state=0)
    xgb = XGBClassifier(gamma=0, use_label_encoder=False, learning_rate=0.01, max_depth=10, n_estimators=10000, random_state=34, reg_lambda=6, reg_alpha=3, verbosity=0)
    xgb.fit(X_train, y_train)
    y_prediction = xgb.predict(X_test)
    print('XGBoost准确率')
    print(confusion_matrix(y_test, y_prediction))
    print(classification_report(y_test, y_prediction))
    print(accuracy_score(y_test, y_prediction))
    f = format(xgb.score(X_test, y_test))
    print(f)
    if float(f) >= 0.8:
        print("有糖尿病风险")
    else:
        print("无糖尿病风险")
    y_ = np.array(y_test)
    print('XGBoost预测结果：', xgb.predict(X_test))
    print('真实结果:         ', y_)
    print('--------------------------------------------------------------------------------------')
 
 
#   主菜单
def main_menu():
    print('-' * 11, '糖尿病诊断预测', '-' * 11)
    print('|{:20}|{:20}|'.format('1.输入指标', '2.退出系统'))
 
 
#   选择模型菜单
def option_menu():
    print('-' * 11, '训练模型选择', '-' * 11)
    print('|{:20}|{:20}|'.format('1.所有模型', '2.随机森林'))
    print('|{:20}|{:20}|'.format('3.决策树', '4.逻辑回归'))
    print('|{:23}|{:20}|'.format('5.KNN', '6.连接模型'))
    print('|{:23}|'.format('7.XGBoost'))
 
 
#   登出
def logout():
    print('感谢使用')
 
if __name__ == '__main__':
    while True:
        main_menu()
        key = input('请输入你的选择: ')
        if key == '1':
            try:
                Pregnancy = float(input('输入怀孕指数：'))
                Glu = float(input('输入葡萄糖指数：'))
                BP = float(input('输入血压：'))
                ST = float(input('输入皮肤厚度：'))
                Ins = float(input('输入胰岛素指数：'))
                BMI = float(input('输入体质指数：'))
                DBF = float(input('输入糖尿病谱系功能指数：'))
                Age = float(input('输入年龄：'))
            except:
                print("不符合输入要求，请重新输入")
                continue
			# 将输入的值放在一个列表中
            indices = [Pregnancy, Glu, BP, ST, Ins, BMI, DBF, Age]
            l = []
            for index in indices:
                l.append(index)
 
            empty_indices = {"Pregnancies": l[0], "Glucose": l[1], "BloodPressure": l[2], "SkinThickness": l[3], "Insulin": l[4], "BMI": l[5], "DiabetesPedigreeFunction": l[6], "Age": l[7]}
            data = pd.DataFrame(empty_indices, index=[0])
            data = data.set_index('Pregnancies')
            data.to_csv("new.csv")
            df_1 = pd.read_csv("new.csv")
            s = df_1.iloc[0]
            # 选择模型菜单
            option_menu()
            option = input('请选择模型：')
            #   显示所有的训练模型结果
            if option == '1':
                random_forest()
                decision_tree()
                logistic_regression()
                k_nn()
                n_n()
                xgb()
            elif option == '2':
                random_forest()
            elif option == '3':
                decision_tree()
            elif option == '4':
                logistic_regression()
            elif option == '5':
                k_nn()
            elif option == '6':
                n_n()
            elif option == '7':
                xgb()
            else:
                print('无效输入')
                continue
        elif key == '2':
            logout()
            break
        else:
            print('无效输入')
#数据清洗
import numpy as np
import pandas as pd
 
train = pd.read_csv("C:/Users/Administrator/Desktop/diabetes.csv")
print(train.head())
 
#查看缺失值较多的数据统计
NaN_col_names = ['Glucose','BloodPressure','SkinThickness','Insulin','BMI']
train[NaN_col_names] = train[NaN_col_names].replace(0, np.NaN)
print(train.isnull().sum())
 
 
#中值补充缺实值
medians = train.median()
train = train.fillna(medians)
 
print(train.isnull().sum())
 
 
#  get labels
y_train = train['Outcome']
X_train = train.drop(["Outcome"], axis=1)
 
#用于保存特征工程之后的结果
feat_names = X_train.columns
 
# 数据标准化
from sklearn.preprocessing import StandardScaler
 
# 初始化特征的标准化器
ss_X = StandardScaler()
 
# 分别对训练和测试数据的特征进行标准化处理
X_train = ss_X.fit_transform(X_train)
 
#存为csv格式
X_train = pd.DataFrame(columns = feat_names, data = X_train)
 
train = pd.concat([X_train, y_train], axis = 1)
 
train.to_csv('C:/Users/Administrator/Desktop/pima-diabetes.csv',index = False,header=True)
 
print(train.head())

 3.个人心得体会

大众对糖尿病的预防意识不足，导致他们缺乏预防糖尿病的知识，所以一旦患上糖尿病，他们无法及时进行检查和治疗。糖尿病是一种需要持续治疗的慢性疾病，为了避免和延缓糖尿病慢性并发症的发生和发展，当下社会迫切需要让糖尿病患者主动参与并采取综合和个体化的治疗措施。这意味着患者需要提高自己的自觉性，并积极配合医生的建议，以实现良好的代谢控制。我们设计了一个基于机器学习算法的系统，用户可以使用该系统自行进行糖尿病的筛查。这样一来，用户能够及早发现糖尿病的迹象，并且能够尽早进行治疗，提高患者的生命安全，提高患者的生活质量。