在医疗卫生机构中,经常需要对大量的医疗数据进行分析和挖掘,例如患者信息、医疗记录、医药数据等。Python 具有简洁、高效、易学易用的特点,能够帮助医疗机构快速处理大量的医疗数据,从而发现医疗数据中的规律和规律性,并根据分析结果制定相应的治疗方案和预测未来趋势。今天我们来介绍一下Python做基础的医学统计数据分析简单步骤。
机器学习是人工智能的一个重要分支,近年来在数据分析、图像识别、自然语言处理等领域发挥的作用越来越重要。机器学习的基本概念围绕着如何让计算机利用数据来进行学习和预测。而R语言,作为一种统计分析和图形表示的强大工具,因其丰富的包和灵活的数据处理能力,在机器学习领域中占有一席之地。今天我们开始R语言机器学习的第一篇,数据准备与包的批量安装。
Python是一种广泛使用的语言,可以用于构建和应用各种机器学习模型。
以下是一些最常见的机器学习模型及其Python实现:
1.线性回归:用于回归分析,可以预测单个或多个输出。
2.逻辑回归:用于二分类问题,可以预测二进制输出。
3.决策树:用于二分类和多分类问题,可以可视化决策边界。
4.K最近邻(KNN):用于分类和回归问题,主要是基于实例的学习算法。
5.支持向量机(SVM):用于二分类和回归问题,可以找到最优分离超平面。
6.集成方法:如随机森林、Boosting等,可以提高预测精度并降低方差。
7.神经网络:用于复杂函数逼近和大规模数据集分类。
8.主成分分析(PCA)和 t-SNE:用于数据降维和可视化。
9.特征工程:包括数据清洗、特征缩放、特征选择等。
10.深度学习:用于复杂的数据分析和模式识别。
今天我们以临床医学数据中最常见的二分类因变量的logistic回归为例,开始Python机器学习系列的第一篇。
Scikit-learn(sklearn)是一个基于Python的开源机器学习库,它建立在NumPy、SciPy和Matplotlib之上,为数据建模提供了一整套工具。
Scikit-learn提供了大量的算法和工具,涵盖了数据挖掘、数据分析和机器学习领域的各种任务,包括分类、回归、聚类、降维等。
主要特点和功能
1.简单易用:Scikit-learn的设计非常简洁,易于上手,即使对于机器学习的新手也能快速掌握。
2.功能强大:它包含了从基础的线性回归、逻辑回归到复杂的支持向量机等多种机器学习算法。
3.集成性好:Scikit-learn与NumPy、Pandas、Matplotlib等Python科学计算库紧密集成,方便进行数据预处理、模型训练和结果可视化。
4.社区活跃:Scikit-learn有一个活跃的开源社区,不断更新和完善库的功能,同时提供丰富的文档和教程资源。
Lasso回归(Least Absolute Shrinkage and Selection Operator Regression)是一种线性回归模型,通过引入L1正则化(即Lasso惩罚项),对模型中的系数进行压缩,使某些系数缩减至零,从而实现特征选择和模型稀疏性。Lasso回归由Robert Tibshirani提出,主要用于处理变量过多而样本量较少的情况,能够有效防止过拟合并解决多重共线性问题。
Lasso回归的基本原理
Lasso回归通过在目标函数中添加一项L1正则化项,即变量系数的绝对值之和,来压缩模型。这使得一些系数变为零,从而实现特征选择和模型稀疏性。具体来说,Lasso回归的优化目标函数如下:
[ \min_{\beta} \left( \sum_{i=1}^n (y_i - x_i^T \beta)^2 + \alpha \sum_{j=1}^p |\beta_j| \right) ]
其中,( n ) 是样本数量,( p ) 是特征数量,( y_i ) 是实际观测值,( x_i^T \beta ) 是预测值,( \beta ) 是模型参数(系数),( \alpha ) 是L1正则化项的权重。
Lasso回归的应用场景和优缺点
应用场景:
一、特征选择:Lasso回归可以用于选择最重要的特征,通过将不重要的特征系数缩减为零,简化模型并提高模型的泛化能力。
二、多重共线性问题:在存在多重共线性的情况下,Lasso回归可以通过将相关变量的系数变为零来降低其对回归结果的影响。
三、预测建模:在医学研究中,Lasso回归可以选择最相关的指标和变量,建立高效的预测模型。
Lasso回归的优点:
1.特征选择:能够有效进行变量选择,特别是在预测变量数量远大于样本量的情况下。
2.防止过拟合:通过压缩系数,避免模型过于复杂,提高模型的泛化能力。
Lasso回归的缺点:
1.计算复杂度较高:由于L1正则化的非光滑性,优化过程较为复杂,计算成本较高。
2.稳定性问题:由于某些系数可能完全为零,模型的稳定性可能受到影响。
岭回归(Ridge Regression)是一种用于处理多重共线性的有偏估计回归方法,它通过在普通最小二乘法的基础上加入L2正则化项来解决多重共线性问题,从而提高模型的泛化能力和鲁棒性。
基本概念和原理
岭回归通过在最小二乘损失函数中加入L2范数的惩罚项,即模型参数的平方和乘以一个称为岭参数的λ值。这个惩罚项确保了模型参数不会变得过大,从而减少过拟合的风险,提高模型的稳定性和泛化能力。岭回归的损失函数包括两部分:一部分是残差平方和,另一部分是模型参数平方和乘以λ值。
应用场景
岭回归特别适用于那些特征之间高度相关(即多重共线性问题)的数据集。在这种情况下,普通的线性回归模型可能会变得不稳定,并且模型的系数可能会变得非常大。岭回归通过惩罚模型参数,使其保持较小的值,从而使得模型更加稳健。
岭回归的优点:
1.处理多重共线性:岭回归能够有效处理特征之间的强相关性,避免参数估计的不稳定。
2.减少过拟合:通过惩罚大参数,岭回归能够提高模型的泛化能力,减少过拟合的风险。
3.计算简单:岭回归的实现相对简单,不需要复杂的计算过程。
岭回归的缺点:
1.有偏估计:岭回归通过牺牲无偏性来获得更稳定的估计,可能会导致模型预测的偏差。
2.参数选择:选择合适的λ值是一个挑战,不同的λ值会影响模型的性能。
岭回归的实际应用案例
在实际应用中,岭回归常用于生物信息学、金融数据分析等领域,特别是在处理具有高度相关特征的数据时表现出色。例如,在基因表达数据分析中,基因之间的相关性可能导致普通线性回归模型不稳定,此时岭回归可以提供更稳定的参数估计。
弹性网络回归(Elastic Net Regression)是一种结合了L1和L2正则化惩罚的线性回归模型,主要用于处理高维数据和具有多重共线性的特征。它结合了Lasso回归和岭回归(Ridge Regression)的优点,能够在特征选择和模型稳定性之间取得平衡。
基本原理:
弹性网络回归通过在损失函数中同时引入L1和L2正则化项来约束模型的复杂度。L1正则化(Lasso回归)通过惩罚较大的系数来促进稀疏性,有利于特征选择;而L2正则化(岭回归)通过惩罚系数的平方来减少模型的过拟合。通过引入两个正则化参数λ和ρ,弹性网络回归可以在Lasso回归和岭回归之间灵活调节,以适应不同的数据特性。
优点和应用场景:
1.解决多重共线性问题:当特征之间存在高度相关性时,弹性网络回归通过L2正则化可以保留一组相关特征,解决Lasso回归随机选择特征的问题。
2.稳定性:在处理高维数据时,弹性网络回归表现更稳定,不容易受到特征选择的影响。
3.适用于大数据集:由于其计算复杂度较低,弹性网络回归在处理大数据集时更有效率。
弹性网络回归在多个领域有广泛应用,包括金融领域的股票价格预测、汇率变动预测,医学领域的疾病风险预测、药物反应分析,工程领域的建筑物结构稳定性预测,生态学的环境因素分析,以及社会科学的统计数据分析等。
今天我们仍以熟悉的“示例数据集”为例,演示一下Python的sklearn.linear_model库进行lasso回归、岭回归、弹性网络回归操作示例。
Scikit-learn(sklearn)是一个基于Python的开源机器学习库,它建立在NumPy、SciPy和Matplotlib之上,为数据建模提供了一整套工具。
Scikit-learn提供了大量的算法和工具,涵盖了数据挖掘、数据分析和机器学习领域的各种任务,包括分类、回归、聚类、降维等。
主要特点和功能简单易用:
1.Scikit-learn的设计非常简洁,易于上手,即使对于机器学习的新手也能快速掌握。
2.功能强大:它包含了从基础的线性回归、逻辑回归到复杂的支持向量机等多种机器学习算法。
3.集成性好:Scikit-learn与NumPy、Pandas、Matplotlib等Python科学计算库紧密集成,方便进行数据预处理、模型训练和结果可视化。
4.社区活跃:Scikit-learn有一个活跃的开源社区,不断更新和完善库的功能,同时提供丰富的文档和教程资源。
#加载程序包(openpyxl和pandas等)
#使用pandas读取示例数据xlsx文件
import openpyxl
from array import array
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
datala = pd.read_excel(r'C:\Users\L\Desktop\示例数据.xlsx')
# 查看前几行数据
print(datala.head())
# 分离特征和目标变量
X = datala[['指标1', '指标2', '指标3','指标4','指标5','指标6']]
y = datala['结局']
#加载lasso回归、岭回归、弹性网络及交叉验证所需要的库
from sklearn.linear_model import Lasso, Ridge, ElasticNet
from sklearn.datasets import make_regression
from sklearn.model_selection import cross_val_score, cross_val_predict
from sklearn.linear_model import LassoCV, ElasticNetCV
from sklearn.model_selection import KFold
# Lasso回归
alpha = 0.1 # L1惩罚系数
lasso = Lasso(alpha=alpha)
lasso.fit(X, y)
print(f"Lasso coefficient size: {lasso.coef_.size}")
print(f"Lasso coef:{lasso.coef_}")
print(f"Lasso alpha: {lasso.alpha}")
# 针对Lasso的交叉验证得分
lasso_scores = cross_val_score(lasso, X, y, scoring='neg_mean_squared_error', cv=10)
print(f"Lasso neg_mean_squared_error: {lasso_scores.mean()}")
#Lasso回归交叉验证
lassocv = LassoCV(alphas=[alpha], cv=3).fit(X, y)
y_pred_lasso = cross_val_predict(lassocv, X, y, cv=3)
#print(y_pred_lasso)
# 绘制lasso回归系数
lacoefficients =lasso.coef_
plt.figure(figsize=(10,6))
plt.bar(range(len(lacoefficients)),lacoefficients)
plt.title('Lasso coefficients')
plt.xlabel('Feature Index')
plt.ylabel('coefficient value')
plt.show()
# 绘制变量惩罚曲线
plt.figure(figsize=(10, 5))
plt.subplot(1, 1, 1)
plt.title("Lasso CV: $\ alpha=$ Best: %.2f, Mean: %.2f" % (lassocv.alpha_, np.mean(lassocv.mse_path_)))
plt.plot(lassocv.mse_path_, color='blue', marker='o', label='Lasso MSE')
plt.xlabel('Iterations')
plt.ylabel('Mean Squared Error')
plt.legend()
# 岭回归
ridge = Ridge(alpha=alpha)
ridge.fit(X, y)
print(f"Ridge coefficient size: {ridge.coef_.size}")
print(f"Ridge coef:{ridge.coef_}")
print(f"Ridge alpha: {ridge.alpha}")
# 针对岭回归的交叉验证得分
ridge_scores = cross_val_score(ridge, X, y, scoring='neg_mean_squared_error', cv=10)
print(f"Ridge neg_mean_squared_error: {ridge_scores.mean()}")
# 绘制岭回归系数
licoefficients =ridge.coef_
plt.figure(figsize=(10,6))
plt.bar(range(len(licoefficients)),licoefficients)
plt.title('Ridge coefficients')
plt.xlabel('Feature Index')
plt.ylabel('coefficient value')
plt.show()
# 弹性网络
elastic_net = ElasticNet(alpha=alpha, l1_ratio=0.5)
elastic_net.fit(X, y)
print(f"ElasticNet coefficient size: {elastic_net.coef_.size}")
print(f"ElasticNet coef:{elastic_net.coef_}")
print(f"ElasticNet alpha: {elastic_net.alpha}")
print(f"ElasticNet l1_ratio: {elastic_net.l1_ratio}")
# 针对弹性网络的交叉验证得分
elastic_net_scores = cross_val_score(elastic_net, X, y, scoring='neg_mean_squared_error', cv=10)
print(f"ElasticNet neg_mean_squared_error: {elastic_net_scores.mean()}")
#弹性网络回归交叉验证
elastic_netcv = ElasticNetCV(alphas=[alpha], cv=3).fit(X, y)
y_pred_elastic_net = cross_val_predict(elastic_netcv, X, y, cv=3)
#print(y_pred_elastic_net)
# 绘制弹性网络回归系数
encoefficients =elastic_net.coef_
plt.figure(figsize=(10,6))
plt.bar(range(len(encoefficients)),encoefficients)
plt.title('ElasticNet coefficients')
plt.xlabel('Feature Index')
plt.ylabel('coefficient value')
plt.show()
# 绘制变量惩罚曲线
plt.title("ElasticNet CV: $\ alpha=$ Best: %.2f, Mean: %.2f" % (elastic_netcv.alpha_, np.mean(elastic_netcv.mse_path_)))
plt.plot(elastic_netcv.mse_path_, color='blue', marker='o', label='ElasticNet MSE')
plt.xlabel('Iterations')
plt.ylabel('Mean Squared Error')
plt.legend()
# 绘制结果
plt.figure()
plt.scatter(range(1000), y, color='black')
plt.scatter(range(1000), y_pred_lasso, color='blue')
plt.scatter(range(1000), y_pred_elastic_net, color='red')
plt.legend(('Data', 'Lasso', 'Elastic Net'), loc='upper left')
plt.xlabel('Sample index')
plt.ylabel('Target value')
plt.show()
朴素贝叶斯模型(Naive Bayes Model, NBM)是一种基于贝叶斯定理和特征条件独立性假设的分类算法。其核心思想是通过给定特征X的条件下,预测样本属于某类别c的后验概率P(c|X),选择后验概率最大的类别作为分类结果。
基本原理
朴素贝叶斯模型的基本原理基于贝叶斯定理,公式如下:
[ P(c|X) = \frac{P(X|c)P(c)}{P(X)} ]
其中:
( P(c|X) )表示在给定样本特征X的条件下,样本属于类别c的后验概率。
( P(X|c) )表示在类别c已知的情况下,样本特征X出现的概率。
( P(c) )表示类别c本身的概率。
( P(X) )表示样本特征X出现的总概率,通常用于归一化。
特征条件独立性假设
朴素贝叶斯模型的关键假设是特征之间在给定类别的情况下是相互独立的。这一假设极大地简化了计算,使得似然( P(X|c) )可以分解为各个特征的条件概率的乘积:
[ P(X|c) = \prod_{j=1}^n P(X^{(j)}|c) ]
这一假设虽然在实际中往往不完全成立,但在许多任务中仍然表现良好。
应用场景和优缺点
朴素贝叶斯模型在许多领域有广泛的应用,如文本分类、垃圾邮件识别等。其优点包括实现简单、计算效率高、所需估计的参数少;缺点是假设特征之间完全独立,这在现实中很少见,可能导致分类效果不佳。
今天我们仍以熟悉的示例数据集为例,演示一下朴素贝叶斯(Naive Bayes)模型的操作及拟合效果的ROC曲线、混淆矩阵评价。
加载程序包(openpyxl和pandas等)
#使用pandas读取示例数据xlsx文件
import openpyxl
import pandas as pd
import matplotlib.pyplot as plt
import sklearn
from sklearn.model_selection import train_test_split
# 加载数据集
dataknn = pd.read_excel(r'C:\Users\L\Desktop\示例数据.xlsx')
# 查看前几行数据
print(dataknn.head())
# 分离特征和目标变量
X = dataknn[['指标1', '指标2', '指标3','指标4','指标5','指标6']]
y = dataknn['结局']
# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
#加载朴素贝叶斯模型所需要的库
from sklearn.naive_bayes import MultinomialNB
from sklearn.metrics import roc_curve, auc, confusion_matrix
from matplotlib import pyplot as plt
# 假设X_train和y_train已经是训练数据和目标值
# 创建Naive Bayes模型
bysmodel = MultinomialNB()
bysmodel.fit(X_train, y_train)
# 对测试集进行预测
y_pred = bysmodel.predict(X_test)
accuracy = bysmodel.score(X_test, y_test)
print(f"Accuracy: {accuracy}")
print("预估值:\n",y_pred)
acc = sum(y_pred == y_test) / y_pred.shape[0]
print("预测的准确率ACC: %.2f%%" % (acc*100))
# 计算ROC曲线和面积
fpr, tpr, thresholds = roc_curve(y_test, y_pred)
roc_auc = auc(fpr, tpr)
# 绘制ROC曲线
plt.figure()
lw = 2
plt.plot(fpr, tpr, color='darkorange',
lw=lw, label='ROC curve (area = %0.2f)' % roc_auc)
plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver Operating Characteristic example')
plt.legend(loc="lower right")
plt.show()
# 计算混淆矩阵
cm = confusion_matrix(y_test, y_pred)
# 打印模型拟合效果的评价指标
print(f"ROC AUC: {roc_auc}")
print(f"Confusion Matrix:\n{cm}")
# 使用Seaborn的heatmap绘制混淆矩阵
import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix
import seaborn as sns
sns.heatmap(sklearn.metrics.confusion_matrix(y_test, y_pred), annot=True, fmt='d')
plt.title('Confusion Matrix')
plt.xlabel('Predicted label')
plt.ylabel('True label')
plt.show()
K最近邻(KNN)模型是一种简单且有效的机器学习算法,主要用于分类和回归任务。KNN的基本思想是:一个样本的类别或数值取决于其最邻近的k个邻居的类别或数值。具体来说,KNN通过计算待分类点与训练数据集中所有点的距离,选择距离最近的k个点作为邻居,然后根据这些邻居的类别或数值来预测该点的类别或数值。
KNN模型的工作原理
KNN算法的工作流程如下:
距离度量:KNN使用距离度量(如欧几里得距离、曼哈顿距离等)来确定数据点之间的相似性。最常见的距离度量是欧几里得距离。
选择K值:K是一个超参数,表示在进行决策时考虑的最近邻居的数量。K的选择对模型的性能有很大影响,一般通过网格搜索等方法来确定最佳的K值。
决策:对于分类任务,KNN算法通过多数投票法来预测新样本的类别;对于回归任务,则计算K个最近邻居的目标值的平均值作为新样本的目标值。
KNN模型的优缺点
优点:
简单易懂:KNN算法概念简单,容易理解和实现。
无需训练阶段:KNN没有显式的训练阶段,只需存储训练数据集,因此在数据集规模和特征数量相同的条件下,建模训练速度较快。
适用于小数据集:对于小数据集,KNN通常表现良好。
缺点:
计算量大:对于大规模数据集,计算每个测试样本与训练集中所有样本的距离非常耗时。
内存消耗大:需要存储所有训练数据以进行距离计算。
对异常值敏感:近邻的选择对异常值非常敏感,可能导致模型不稳定。
应用场景和实际案例
KNN算法在实际应用中有广泛的应用,例如:
文本分类:用于将文本数据分类到不同的类别中。
图像识别:通过比较图像特征来识别图像内容。
推荐系统:根据用户的购买或浏览历史推荐相关商品或内容。
今天我们仍以熟悉的示例数据集为例,演示一下python中K最近邻(KNN)模型的基本操作以及ROC曲线、混淆矩阵评价。
#加载程序包(openpyxl和pandas等)
#使用pandas读取示例数据xlsx文件
import openpyxl
import pandas as pd
import matplotlib.pyplot as plt
import sklearn
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
# 加载数据集
dataknn = pd.read_excel(r'C:\Users\L\Desktop\示例数据.xlsx')
# 查看前几行数据
print(dataknn.head())
# 分离特征和目标变量
X = dataknn[['指标1', '指标2', '指标3','指标4','指标5','指标6']]
y = dataknn['结局']
# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# 创建并训练模型
knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X_train, y_train)
# 预测和评估模型
predictions = knn.predict(X_test)
accuracy = knn.score(X_test, y_test)
print(f"Accuracy: {accuracy}")
print("预估值:\n",predictions)
acc = sum(predictions == y_test) / predictions.shape[0]
print("预测的准确率ACC: %.2f%%" % (acc*100))
#混淆矩阵评估模型
#导入第三方模块
from sklearn import metrics
# 混淆矩阵
print("混淆矩阵四格表输出如下:")
print(metrics.confusion_matrix(y_test, predictions, labels = [0, 1]))
Accuracy = metrics._scorer.accuracy_score(y_test, predictions)
Sensitivity = metrics._scorer.recall_score(y_test, predictions)
Specificity = metrics._scorer.recall_score(y_test, predictions, pos_label=0)
print("KNN模型混淆矩阵评价结果如下:")
print('模型准确率为%.2f%%' %(Accuracy*100))
print('正例覆盖率为%.2f%%' %(Sensitivity*100))
print('负例覆盖率为%.2f%%' %(Specificity*100))
# 使用Seaborn的heatmap绘制混淆矩阵
import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix
import seaborn as sns
sns.heatmap(metrics.confusion_matrix(y_test, predictions), annot=True, fmt='d')
plt.title('Confusion Matrix')
plt.xlabel('Predicted label')
plt.ylabel('True label')
plt.show()
#进行ROC曲线绘制计算准备
# у得分为模型预测正例的概率
y_score =knn.predict_proba(X_test)[:,1]
#计算不同阈值下,fpr和tpr的组合值,其中fpr表示1-Specificity,tpr表示sensitivity
fpr,tpr,threshold =metrics.roc_curve(y_test,y_score)
# 计算AUC的值
roc_auc = metrics.auc(fpr,tpr)
print("KNN模型预测测试集数据ROC曲线的AUC:",roc_auc)
KNN模型预测测试集数据ROC曲线的AUC: 0.9356444444444444
#绘制ROC曲线
import matplotlib.pyplot as plt
import seaborn as sns
# 绘制面积图
plt.stackplot(fpr, tpr, color='steelblue', alpha = 0.5,edgecolor = 'black')
# 添加边际线
plt.plot(fpr, tpr, color='black',lw = 1)
# 添加对角线
plt.plot([0,1],[0,1],color ='red',linestyle ='--')
# 添加文本信息
plt.text(0.5,0.3,'Roc curve(area =%.2f)'% roc_auc)
# 添加轴标签
plt.xlabel('1-Specificity')
plt.ylabel('Sensitivity')
# 显示图形
plt.show()
logistic回归又称logistic回归分析,是一种广义的线性回归分析模型,常用于数据挖掘,疾病自动诊断,经济预测等领域。逻辑回归根据给定的自变量数据集来估计事件的发生概率,由于结果是一个概率,因此因变量的范围在 0 和 1 之间。
例如,探讨引发疾病的危险因素,并根据危险因素预测疾病发生的概率等。以胃癌病情分析为例,选择两组人群,一组是胃癌组,一组是非胃癌组,两组人群必定具有不同的体征与生活方式等。因此因变量就为是否胃癌,值为“是”或“否”,自变量就可以包括很多了,如年龄、性别、饮食习惯、幽门螺杆菌感染等。自变量既可以是连续的,也可以是分类的。然后通过logistic回归分析,可以得到自变量的权重,从而可以大致了解到底哪些因素是胃癌的危险因素。同时根据该权值可以根据危险因素预测一个人患癌症的可能性。
我们仍以前期R语言机器学习展示所用的示例数据为例,开始Python机器学习系列第一篇logistic回归模型的展示。
#加载程序包(openpyxl和pandas等)
# 使用pandas读取示例数据xlsx文件
import openpyxl
import pandas as pd
datalr = pd.read_excel(r'C:\Users\hyy\Desktop\示例数据.xlsx')
# 查看前几行数据
print(datalr.head())
#将数据中结局为1或0的部分提出来,组成Positive、Negative的群,通过不同标签和颜色进行图示
positive = datalr[datalr['结局'].isin([1])]
negative = datalr[datalr['结局'].isin([0])]
plt.figure(figsize=(12,8))
#头两个参数是X轴与Y轴数据,c是颜色:marker是散点图形状
plt.scatter(positive['指标1'], positive['指标6'],c='b',marker='o',label='Admitted')
plt.scatter(negative['指标1'], negative['指标6'],c='r',marker='x',label='Not Admitted')
plt.xlabel('指标1')
plt.ylabel('指标6')
plt.legend(loc=True)
plt.show()
#尝试进行卡方检验
from scipy.stats import chi2_contingency
from scipy import stats
# crosstab:交叉表,margins:显示总和
cross_table = pd.crosstab(datalr["结局"], datalr["指标8"], margins=True)
print(cross_table)
# chi2_contingency:卡方检验,chisq:卡方统计量值,expected_freq:期望频数
print('chisq = %6.4f\n p-value = %6.4f\n dof = %i\n expected_freq = %s' %stats.chi2_contingency(cross_table))
#尝试进行独立样本t检验
from scipy.stats import ttest_ind
#指标1
A=datalr[datalr["结局"]==1]["指标1"]#产生一个series
B=datalr[datalr["结局"]==0]["指标1"]#产生一个series
print("指标1在结局1与结局0两组间的独立样本t检验结果为:")
print( ttest_ind(A,B) )
#指标2
C=datalr[datalr["结局"]==1]["指标2"]#产生一个series
D=datalr[datalr["结局"]==0]["指标2"]#产生一个series
print("指标2在结局1与结局0两组间的独立样本t检验结果为:")
print( ttest_ind(C,D) )
#尝试进行logistic回归
#安装包
import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
# 分离特征和目标变量
X = datalr[['指标1', '指标2', '指标3','指标4','指标5','指标6']]
y = datalr['结局']
# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
model = LogisticRegression()
model.fit(X_train, y_train)
()
(model.intercept_,model.coef_)
y_pred = model.predict(X_test)
resulta=accuracy_score(y_test, y_pred)
accuracy = accuracy_score(y_test, y_pred)
(accuracy)
也可以
#使用statsmodels库拟合logistic回归并获取OR值
import statsmodels.api as sm
modellr = sm.Logit(y_train, X_train)
# 进行模型拟合
result = modellr.fit()
# 打印结果摘要,其中包括OR值
print(result.summary())
#根据上述拟合结果绘制森林图
import matplotlib.pyplot as plt
data = {
'name': ['X1', 'X2', 'X3', 'X4', 'X5', 'X6'], # 指标变量名
'P': [0.000, 0.000, 0.031, 0.003, 0.000, 0.000], # P值
'Effect': [1.1015, 1.1638, 0.3206, 0.4811, 0.8825, 2.5983], # 效应值
'LowerCI': [0.754, 0.806, 0.029, 0.167, 0.560, 2.135], # 下置信界限
'UpperCI': [1.449, 1.521, 0.612, 0.795, 1.205, 3.061] # 上置信界限
}
fpdata=pd.DataFrame(data)
plt.figure(figsize=(5, 4))
plt.plot([0.5, 1.5], [0.5, 0.5], color='gray', linestyle='--', linewidth=2) # 0线
# 遍历每一行,绘制误差条
for i,row in fpdata.iterrows():
plt.errorbar(row['Effect'], i,
xerr=[[row['Effect'] - row['LowerCI']], [row['UpperCI'] - row['Effect']]],
fmt='o',color='black',ecolor='black',capsize=3, markersize=6)
#绘制森林图
#添加垂直线 x=1 作为参考线
plt.axvline(x=1,color='black',linestyle='--',linewidth=1)
#设置y轴的刻度和标签,将组名结合显示
plt.yticks(range(len(fpdata)),[f"{group}" for group in zip(fpdata['name'])])
#设置x轴标签和图表标题
plt.xlabel('Estimate(95% CI)')
plt.title('Forest plot')
#反转y轴,使得顶部的条目在图中更高
plt.gca().invert_yaxis()
# 调整图表布局
plt.tight_layout()
#显示图表
plt.show()
#混淆矩阵评估模型
#导入第三方模块
from sklearn import metrics
# 混淆矩阵
print("混淆矩阵四格表输出如下:")
print(metrics.confusion_matrix(y_test, y_pred, labels = [0, 1]))
Accuracy = metrics._scorer.accuracy_score(y_test, y_pred)
Sensitivity = metrics._scorer.recall_score(y_test, y_pred)
Specificity = metrics._scorer.recall_score(y_test, y_pred, pos_label=0)
print("logistic回归模型混淆矩阵评价结果如下:")
print('模型准确率为%.2f%%' %(Accuracy*100))
print('正例覆盖率为%.2f%%' %(Sensitivity*100))
print('负例覆盖率为%.2f%%' %(Specificity*100))
# 使用Seaborn的heatmap绘制混淆矩阵
import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix
import seaborn as sns
sns.heatmap(metrics.confusion_matrix(y_test, y_pred), annot=True, fmt='d')
plt.title('Confusion Matrix')
plt.xlabel('Predicted label')
plt.ylabel('True label')
plt.show()
#进行ROC曲线绘制计算准备
# у得分为模型预测正例的概率
y_score =model.predict_proba(X_test)[:,1]
#计算不同阈值下,fpr和tpr的组合值,其中fpr表示1-Specificity,tpr表示sensitivity
fpr,tpr,threshold =metrics.roc_curve(y_test,y_score)
# 计算AUC的值
roc_auc = metrics.auc(fpr,tpr)
print("logistic回归模型预测测试集数据ROC曲线的AUC:",roc_auc)
#绘制ROC曲线
import matplotlib.pyplot as plt
import seaborn as sns
# 绘制面积图
plt.stackplot(fpr, tpr, color='steelblue', alpha = 0.5,edgecolor = 'black')
# 添加边际线
plt.plot(fpr, tpr, color='black',lw = 1)
# 添加对角线
plt.plot([0,1],[0,1],color ='red',linestyle ='--')
# 添加文本信息
plt.text(0.5,0.3,'Roc curve(area =%.2f)'% roc_auc)
# 添加轴标签
plt.xlabel('1-Specificity')
plt.ylabel('Sensitivity')
# 显示图形
plt.show()
决策树模型是一种简单易用的非参数分类器,它不需要对数据有任何的先验假设,计算速度较快,结果容易解释,且稳健性强。决策树模型基于贝叶斯定理建立,通过概率和选项赋值来推导货币价值,广泛应用于公司商业决策中,帮助决策者选择最佳行动方针。
决策树模型通过构建一个树形结构来展示决策过程。每个内部节点代表一个属性上的测试,每个分支代表测试的输出,每个叶节点代表一个类别或结果。在机器学习中,决策树是一种预测模型,代表对象属性与对象值之间的映射关系。它常用于分类问题,通过训练数据和测试数据的划分来构建和验证模型。
临床数据的决策树模型是一种在临床决策分析中广泛使用的数学模型,主要用于展示临床重要事件的可能发展过程及结局,帮助医务人员比较各种备选方案的预期结果,从而进行择优决策。决策树模型通过树形图展示决策过程,每个节点代表一个决策点或机会点,分支代表不同的决策或结果。
今天我们仍以示例数据为例,探讨一下Python做决策树模型及可视化和拟合效果评价的步骤和方法。
#加载读取示例数据所需程序包(openpyxl和pandas等)
# 使用pandas读取示例数据xlsx文件
import openpyxl
import pandas as pd
import plot
#导入示例数据
datadt = pd.read_excel(r'C:\Users\hyy\Desktop\示例数据.xlsx')
# 查看前几行数据
print(datadt.head())
#加载决策树模型所需的包并进行数据准备
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
# 分离特征和目标变量
X = datadt[['指标1', '指标2', '指标3','指标4','指标5','指标6']]
y = datadt[['结局']]
# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# 数据标准化
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
#构建决策树分类器
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import classification_report, accuracy_score
# 初始化决策树分类器
dt_model = DecisionTreeClassifier(criterion='gini',
max_depth=6,
random_state=12)
# 训练模型
dt_model.fit(X_train, y_train)
#预测
dt_pred = dt_model.predict(X_test)
print("对测试集300个数据的预测值为:")
print(dt_pred)
#决策树模型可视化
import matplotlib.pyplot as plt
from sklearn import tree
# 使用 export_graphviz 函数
with open("tree.dot", 'w') as f:
f = tree.export_graphviz(dt_model, out_file=f)
# 使用 graphviz 将 .dot 文件转换为图片
import os
os.system('dot -Tpng tree.dot -o tree.png')
# 显示图形
plt.show()
# 使用export_graphviz函数进行模型可视化,并应用剪枝
with open("tree.dot", 'w') as f:
f = tree.export_graphviz(dt_model,
out_file=f,
filled=True,
rounded=True,
special_characters=True
)
os.system('dot -Tpng tree.dot -o tree_tree2.png')
# 评估模型
print("Accuracy:",accuracy_score(y_test,dt_pred))
print("Classification Report:\n ", classification_report(y_test,dt_pred))
#混淆矩阵评估模型
#导入第三方模块
from sklearn import metrics
# 混淆矩阵
print("混淆矩阵四格表输出如下:")
print(metrics.confusion_matrix(y_test, dt_pred, labels = [0, 1]))
Accuracy = metrics._scorer.accuracy_score(y_test, dt_pred)
Sensitivity = metrics._scorer.recall_score(y_test, dt_pred)
Specificity = metrics._scorer.recall_score(y_test, dt_pred, pos_label=0)
print("决策树模型混淆矩阵评价结果如下:")
print('模型准确率为%.2f%%' %(Accuracy*100))
print('正例覆盖率为%.2f%%' %(Sensitivity*100))
print('负例覆盖率为%.2f%%' %(Specificity*100))
# 使用Seaborn的heatmap绘制混淆矩阵
import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix
import seaborn as sns
sns.heatmap(metrics.confusion_matrix(y_test, dt_pred), annot=True, fmt='d')
plt.title('Confusion Matrix')
plt.xlabel('Predicted label')
plt.ylabel('True label')
plt.show()
#进行ROC曲线绘制计算准备
# у得分为模型预测正例的概率
y_score =dt_model.predict_proba(X_test)[:,1]
#计算不同阈值下,fpr和tpr的组合值,其中fpr表示1-Specificity,tpr表示sensitivity
fpr,tpr,threshold =metrics.roc_curve(y_test,y_score)
# 计算AUC的值
roc_auc = metrics.auc(fpr,tpr)
print("决策树模型预测测试集数据ROC曲线的AUC:",roc_auc)
决策树模型预测测试集数据ROC曲线的AUC: 0.8910666666666667
#绘制ROC曲线
import matplotlib.pyplot as plt
import seaborn as sns
# 绘制面积图
plt.stackplot(fpr, tpr, color='steelblue', alpha = 0.5,edgecolor = 'black')
# 添加边际线
plt.plot(fpr, tpr, color='black',lw = 1)
# 添加对角线
plt.plot([0,1],[0,1],color ='red',linestyle ='--')
# 添加文本信息
plt.text(0.5,0.3,'Roc curve(area =%.2f)'% roc_auc)
# 添加轴标签
plt.xlabel('1-Specificity')
plt.ylabel('Sensitivity')
# 显示图形
plt.show()
决策树模型广泛应用于各种领域,包括但不限于:
商业决策:帮助公司在面对不确定性时选择最佳行动方针。
机器学习:用于分类和预测,如判断一个人是否会患癌症。
序列决策:通过树状图解方式求解在不同条件下的效益值,帮助决策者做出决策。
严格来说,CART、ID3、C4.5、C5.0、CHAID、Random Forest、Gradient Boosting Decision Trees(GBDT)、XGBoost、LightGBM都属于决策树的衍生算法,或者说思想基于决策树的思想,这些算法在不同的应用场景下都有其优势和适用性。
构建决策树模型时,通常需要将数据分为训练数据和测试数据。训练数据用于建立模型,测试数据用于验证模型的优劣。模型的构建过程中需要注意防止过拟合,即训练数据表现良好但测试数据表现糟糕的情况。参数设置越复杂,可能会导致训练数据表现优秀但测试效果不佳。
通过以上介绍,可以看出决策树模型不仅在理论上有坚实的基础,而且在实践中也有广泛的应用和优化方法。
随机森林模型是一种集成学习方法,主要用于分类和回归任务。它通过构建多个决策树并将它们的结果进行投票或平均,以得到最终的预测结果。随机森林模型由Leo Breiman和Adele Cutler发展,并由Tin Kam Ho在1995年提出。
随机森林模型通过以下步骤构建:
样本随机:从原始数据集中通过有放回抽样形成多个子数据集。
特征随机:在每个节点上随机选择一部分特征进行决策树的构建。
决策树构建:对每个子数据集构建一个决策树,每棵树都会完整成长而不会剪枝。
集成预测:最终预测是所有决策树的平均值(回归任务)或多数投票(分类任务)。
随机森林模型的优点:
防止过拟合:通过集成多个决策树,随机森林能够有效地处理过拟合问题,提高模型的泛化能力。
处理非线性问题:随机森林能够处理非线性问题,并且擅长处理大量样本和特征。
降低方差:通过减少单个决策树的方差,随机森林提高了对新数据的预测能力。
可解释性:尽管当前深度学习非常流行,随机森林因其简单、有效、高效以及可解释性等优点,仍然成为许多数据分析师工作中的首选算法。
实际应用:
随机森林模型可以应用于多种任务,包括分类、回归和异常检测。由于其强大的泛化能力和对高维数据的处理能力,随机森林在金融、医疗、生物信息学等领域有广泛的应用。
今天我们仍以示例数据为例,探讨一下随机森林模型可视化及预测效果的ROC曲线、混淆矩阵评价。
#加载程序包(openpyxl和pandas等)
# 使用pandas读取示例数据xlsx文件
import openpyxl
import pandas as pd
import simpleNomo
import matplotlib.pyplot as plt
datarf = pd.read_excel(r'C:\Users\hyy\Desktop\示例数据.xlsx')
# 查看前几行数据
print(datarf.head())
#随机森林主要使用到的第三方库有以下几种:
#numpy:常见的科学计算库
#matplotlib:进行绘图使用
#sklearn.datasets:导入训练需要的数据集
#train_test_split:划分训练集和测试集
#DecisionTreeClassifier:定义随机森林中的决策树分类器
#随机森林(Random Forest)的构建步骤如下:准备训练数据集;重复步骤(随机选择特征子集;随机采样训练数据集;构建决策树;);对新样本进行预测;模型评估;特征重要性评估
#步骤概览:
# 模型训练
#def fit(self, X, y):
"""
训练随机森林模型
:param X: 训练集特征
:param y: 训练集标签
"""
# 模型预测
#def predict(self, X):
"""
使用训练好的模型进行预测
:param X: 测试集特征
:return: 预测结果
"""
# 精度
#def score(self, y_pred, y):
"""
计算分类的准确率
:param y_pred: 预测值
:param y: 真实值
:return: 准确率
"""
#示例数据模型实战
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
# 设置随机种子
seed_value = 1234
np.random.seed(seed_value)
# 对导入的实例数据分离特征和目标变量
X = datarf[['指标1', '指标2', '指标3','指标4','指标5','指标6']]
y = datarf[['结局']]
# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# 数据标准化
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.fit_transform(X_test)
# 训练随机森林
from sklearn.ensemble import RandomForestClassifier
rfmodel = RandomForestClassifier(
n_estimators=100,
max_depth=5,
min_samples_split=2,
random_state=seed_value)
rfmodel.fit(X_train, y_train)
#预测测试集数据
y_train_pred = rfmodel.predict(X_train)
print(预测训练集结果如下:\n",y_train_pred)
y_test_pred = rfmodel.predict(X_test)
print("预测测试集数据结果如下:\n",y_test_pred)
#随机森林模型可视化
import matplotlib.pyplot as plt
from sklearn.tree import plot_tree
# 可视化所有提取的决策树
fig, axes = plt.subplots(nrows=5, ncols=4, figsize=(40, 50), dpi=200)
for i in range(20):
ax = axes[i // 4, i % 4]
plot_tree( rfmodel.estimators_[i],
feature_names=datarf.columns[3:9], # 使用 df 的列名作为特征名称
filled=True, ax=ax
)
ax.set_title(f'Tree {i+1}')
plt.savefig('随机森林.png')
plt.tight_layout()
plt.show()
# Accuracy结果
from sklearn.metrics import classification_report, accuracy_score
score_train = accuracy_score(y_train,y_train_pred)
print("训练集Classification Report:\n ", classification_report(y_train,y_train_pred))
score_test = accuracy_score(y_test,y_test_pred)
print("测试集Classification Report:\n ", classification_report(y_test,y_test_pred))
print('训练集Accuracy: ', score_train)
print('测试集Accuracy: ', score_test)
#混淆矩阵评估模型
#导入第三方模块
from sklearn import metrics
# 混淆矩阵
print("混淆矩阵四格表输出如下:")
print(metrics.confusion_matrix(y_test, y_test_pred, labels = [0, 1]))
Accuracy = metrics._scorer.accuracy_score(y_test, y_test_pred)
Sensitivity = metrics._scorer.recall_score(y_test, y_test_pred)
Specificity = metrics._scorer.recall_score(y_test, y_test_pred, pos_label=0)
print("决策树模型混淆矩阵评价结果如下:")
print('模型准确率为%.2f%%' %(Accuracy*100))
print('正例覆盖率为%.2f%%' %(Sensitivity*100))
print('负例覆盖率为%.2f%%' %(Specificity*100))
# 使用Seaborn的heatmap绘制混淆矩阵
import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix
import seaborn as sns
sns.heatmap(metrics.confusion_matrix(y_test, y_test_pred), annot=True, fmt='d')
plt.title('Confusion Matrix')
plt.xlabel('Predicted label')
plt.ylabel('True label')
plt.show()
#进行ROC曲线绘制计算准备
# у得分为模型预测正例的概率
y_score =rfmodel.predict_proba(X_test)[:,1]
#计算不同阈值下,fpr和tpr的组合值,其中fpr表示1-Specificity,tpr表示sensitivity
fpr,tpr,threshold =metrics.roc_curve(y_test,y_score)
# 计算AUC的值
roc_auc = metrics.auc(fpr,tpr)
print("随机森林模型预测测试集数据ROC曲线的AUC:",roc_auc)
随机森林模型预测测试集数据ROC曲线的AUC: 0.9709333333333334
#绘制ROC曲线
import matplotlib.pyplot as plt
import seaborn as sns
# 绘制面积图
plt.stackplot(fpr, tpr, color='steelblue', alpha = 0.5,edgecolor = 'black')
# 添加边际线
plt.plot(fpr, tpr, color='black',lw = 1)
# 添加对角线
plt.plot([0,1],[0,1],color ='red',linestyle ='--')
# 添加文本信息
plt.text(0.5,0.3,'Roc curve(area =%.2f)'% roc_auc)
# 添加轴标签
plt.xlabel('1-Specificity')
plt.ylabel('Sensitivity')
# 显示图形
plt.show()
SVM(支持向量机)是一种监督学习算法,主要用于二分类问题,但也可以用于多分类问题和回归问题。 SVM通过找到一个超平面来分离不同类别的数据点,目标是使得这个超平面到最近的数据点的间隔最大化,从而提高分类的鲁棒性和泛化能力。
SVM的基本原理是通过找到一个最佳的超平面来分离不同类别的数据点。这个超平面能够将不同类别的数据点分开,并且使得超平面到最近的数据点的间隔最大化。这个间隔最大化是通过求解一个凸优化问题来实现的,最终得到的超平面称为最优超平面。
我们仍以二分类因变量的示例数据为例,探讨一下支持向量机(SVM)模型可视化及预测效果的ROC曲线、混淆矩阵评价。
#加载程序包(openpyxl和pandas等)
# 使用pandas读取示例数据xlsx文件
import openpyxl
import pandas as pd
import simpleNomo
import matplotlib.pyplot as plt
datasvm = pd.read_excel(r'C:\Users\L\Desktop\示例数据.xlsx')
# 查看前几行数据
print(datasvm .head())
datasvm.columns = ['序号','结局','指标1', '指标2', '指标3','指标4','指标5','指标6','指标7','时间','指标8']
#导入库
import numpy as np
import winreg
#划分数据集与测试集
from sklearn.model_selection import train_test_split
from sklearn import svm#导入算法模块
#导入评分模块
from sklearn.metrics import accuracy_score
# 对导入的实例数据分离特征和目标变量
X = datasvm[['指标1', '指标2', '指标3','指标4','指标5','指标6']]
y = datasvm[['结局']]
#划分训练集和测试集
# Splitting the data into training and testing sets
X_train,X_test,y_train,y_test=
train_test_split(X,y,test_size=0.30,
random_state=77, stratify=y)
feature=list(X.columns)
#引入SVM算法,并将算法中的参数依次设立好,
#进行建模后,
#对测试集进行精度评分
svmmodel=svm.SVC(
C=10,kernel="linear",decision_function_shape="ovr")
svmmodel.fit(X_train,y_train)
print("SVM训练模型评分:"
+str(accuracy_score(y_train,svmmodel.predict(X_train))))
print("SVM待测模型评分:"
+str(accuracy_score(y_test,svmmodel.predict(X_test))))
SVM训练模型评分:0.9328571428571428
SVM待测模型评分:0.8666666666666667
#分类边界函数:核函数Linear核与RBF核的区别
import numpy as np
from sklearn.datasets import make_moons
import matplotlib.pyplot as plt
import seaborn as sns
plt.style.use("fivethirtyeight")
np.random.seed(0)
X, y = make_moons(200, noise=0.20)
plt.scatter(X[:,0], X[:,1], s=40, c=y, cmap=plt.cm.Spectral)
plt.show()# 手动生成一个随机的平面点分布,并画出来
def plot_decision_boundary(pred_func):
x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5
y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5
h = 0.01
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
np.arange(y_min, y_max, h))
Z = pred_func(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral)
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Spectral)
'''
手动设定一个随机的平面分布点
'''
from sklearn import svm
clf = svm.SVC(C=1,kernel="linear",
decision_function_shape="ovo")
clf.fit(X, y)
plot_decision_boundary(lambda x: clf.predict(x))
plt.title("SVM-Linearly")
plt.show()
#rbf核进行非线性分类:
clf = svm.SVC(C=1,kernel="rbf",
decision_function_shape="ovo")
clf.fit(X, y)
plot_decision_boundary(lambda x: clf.predict(x))
plt.title("SVM-Nonlinearity")
plt.show()
#预测测试集数据
y_train_pred = svmmodel.predict(X_train)
print("SVM模型预测训练集300例数据结果如下:\n",y_train_pred)
y_test_pred = svmmodel.predict(X_test)
print("SVM模型预测测试集300例数据结果如下:\n",y_test_pred)
# Accuracy结果
from sklearn.metrics import classification_report, accuracy_score
score_train = accuracy_score(y_train,y_train_pred)
print("训练集Classification Report:\n ",
classification_report(y_train,y_train_pred))
score_test = accuracy_score(y_test,y_test_pred)
print("测试集Classification Report:\n ",
classification_report(y_test,y_test_pred))
print('训练集Accuracy: ', score_train)
print('测试集Accuracy: ', score_test)
#混淆矩阵评估模型
#导入第三方模块
from sklearn import metrics
# 混淆矩阵
print("混淆矩阵四格表输出如下:")
print(metrics.confusion_matrix(y_test, y_test_pred, labels = [0, 1]))
Accuracy = metrics._scorer.accuracy_score(y_test, y_test_pred)
Sensitivity = metrics._scorer.recall_score(y_test, y_test_pred)
Specificity = metrics._scorer.recall_score(y_test, y_test_pred, pos_label=0)
print("SVM模型混淆矩阵评价结果如下:")
print('模型准确率为%.2f%%' %(Accuracy*100))
print('正例覆盖率为%.2f%%' %(Sensitivity*100))
print('负例覆盖率为%.2f%%' %(Specificity*100))
# 使用Seaborn的heatmap绘制混淆矩阵
import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix
import seaborn as sns
sns.heatmap(metrics.confusion_matrix(y_test, y_test_pred), annot=True, fmt='d')
plt.title('Confusion Matrix')
plt.xlabel('Predicted label')
plt.ylabel('True label')
plt.show()
#进行ROC曲线绘制计算准备
# у得分为模型预测正例的概率
y_score =svmmodel.predict(X_test)
#计算不同阈值下,fpr和tpr的组合值,
#其中fpr表示1-Specificity,tpr表示sensitivity
fpr,tpr,threshold =metrics.roc_curve(y_test,y_score)
# 计算AUC的值
roc_auc = metrics.auc(fpr,tpr)
print("SVM模型预测测试集数据ROC曲线的AUC:",roc_auc)
SVM模型预测测试集数据ROC曲线的AUC: 0.8666666666666666
#绘制ROC曲线
import matplotlib.pyplot as plt
import seaborn as sns
# 绘制面积图
plt.stackplot(fpr, tpr, color='steelblue', alpha = 0.5,edgecolor = 'black')
# 添加边际线
plt.plot(fpr, tpr, color='black',lw = 1)
# 添加对角线
plt.plot([0,1],[0,1],color ='red',linestyle ='--')
# 添加文本信息
plt.text(0.5,0.3,'Roc curve(area =%.2f)'% roc_auc)
# 添加轴标签
plt.xlabel('1-Specificity')
plt.ylabel('Sensitivity')
# 显示图形
plt.show()
SVM通过求解对偶拉格朗日问题来进行优化。具体来说,SVM的决策函数可以表示为:
[ y^ = \text{sign}\left( \sum_{i=1}^m \sum_{j=1}^m \alpha_i \alpha_j y_i y_j K(x_i, x_j) + b \right) ]
其中,( \alpha_i )是每一个样本约束的拉格朗日乘子,( K(x_i, x_j) )是核函数。
SVM在各种实际问题中都表现非常优秀,尤其是在手写识别数字和人脸识别中应用广泛。它也可以用于文本和超文本的分类、图像的分类和分割系统,以及生物科学中的数据分析。
在处理非线性可分数据时,SVM通过核技巧将数据映射到更高维的空间,以便在新的空间中找到一个更好的超平面来分类数据。常用的核函数包括多项式核、径向基函数核等。
神经网络模型是一种基于人工神经元的数学模型,用于模拟人脑的神经网络结构和功能。它由大量的简单处理单元(称为神经元)广泛地互相连接而形成的复杂网络系统,反映了人脑功能的许多基本特征,是一个高度复杂的非线性动力学习系统。
神经网络模型的基本原理是模拟人脑神经元的工作方式。人脑由大约860亿个神经元组成,每个神经元通过突触与其他神经元相互连接。神经元接收来自其他神经元的信号,当信号强度超过一定阈值时,神经元会产生输出信号,并通过突触传递给其他神经元。神经网络模型正是基于这种神经元连接和信号传递的机制构建的。
神经网络模型在许多领域都有广泛的应用,包括:
图像识别:如面部识别、物体检测等。
语音识别:如语音转文字、语音命令识别等。
自然语言处理:如机器翻译、情感分析等。
推荐系统:如商品推荐、内容推荐等。
预测分析:如时间序列预测、金融预测等。
总之,神经网络模型通过模拟人脑的神经元连接和信号传递机制,实现了对复杂数据的处理和学习,广泛应用于各个领域。
今天我们仍以二分类因变量的示例数据为例,探讨一下神经网络(Neural Network)模型可视化及预测效果的ROC曲线、混淆矩阵评价的Python实现。
#加载程序包(openpyxl和pandas等)
# 使用pandas读取示例数据xlsx文件
import ann_visualizer
import openpyxl
import numpy as np
import pandas as pd
import simpleNomo
import matplotlib.pyplot as plt
from ann_visualizer.visualize import ann_viz
nndata = pd.read_excel(r'C:\Users\L\Desktop\示例数据.xlsx')
# 查看前几行数据
print(nndata .head())
nndata.columns = ['序号','结局','指标1', '指标2', '指标3','指标4','指标5','指标6','指标7','时间','指标8']
import pandas as pd
pd.set_option('display.max_columns', None)
pd.set_option('display.max_rows',None)
# 对导入的实例数据分离特征和目标变量
X = nndata[['指标1', '指标2', '指标3','指标4','指标5','指标6']]
y = nndata[['结局']]
#划分训练集和测试集
from sklearn.model_selection import train_test_split
# Splitting the data into training and testing sets
X_train,X_test,y_train,y_test=train_test_split(
X,y,test_size=0.30, random_state=77, stratify=y)
feature=list(X.columns)
#搭建神经网络模型,并训练数据
from sklearn.neural_network import MLPClassifier
from sklearn.metrics import accuracy_score
nnmodel =MLPClassifier()
nnmodel.fit(X_train, y_train)
y_train= nnmodel.predict(X_train)
print("训练集预测值:\n",y_train)
#预测test新数据
y_pred = nnmodel.predict(X_test)
print("测试集预测值:\n",y_pred)
print("神经网络训练模型评分:\n",
accuracy_score(nnmodel.predict(X_train),y_train))
print("神经网络测试模型评分:\n",
accuracy_score(nnmodel.predict(X_test),y_test))
#数据标准化
from sklearn.preprocessing import StandardScaler
from sklearn.inspection import permutation_importance
scaler = StandardScaler()
scaler.fit(X_train)
X_train_s = scaler.transform(X_train)
X_test_s = scaler.transform(X_test)
print("训练集:\n",X_train_s)
print("测试集:\n",X_test_s)
# 评估模型
from sklearn.metrics import classification_report, accuracy_score
print("Accuracy:",accuracy_score(y_test,y_pred))
print("Classification Report:\n ", classification_report(y_test,y_pred))
#神经网络模型分析特征权重可视化
import matplotlib.pyplot as plt
plt.figure(figsize=(20,3))
plt.imshow(nnmodel.coefs_[0],interpolation='none', cmap='viridis')
plt.yticks(range(6),feature)
plt.xlabel('Columns in weight matrix')
plt.ylabel('Input feature')
plt.colorbar()
plt.show()
#可以通过调整图表大小,选择合适的显示方式
# 使用Matplotlib绘制MLP结构图
fig, ax = plt.subplots() # 创建一个图和坐标系
plt.subplots(nnmodel)
# 显示图形
plt.show()
#混淆矩阵评估模型
#导入第三方模块
from sklearn import metrics
# 混淆矩阵
print("混淆矩阵四格表输出如下:")
print(metrics.confusion_matrix(y_test, y_pred, labels = [0, 1]))
Accuracy = metrics._scorer.accuracy_score(y_test, y_pred)
Sensitivity = metrics._scorer.recall_score(y_test, y_pred)
Specificity = metrics._scorer.recall_score(y_test, y_pred, pos_label=0)
print("神经网络模型混淆矩阵评价结果如下:")
print('模型准确率为%.2f%%' %(Accuracy*100))
print('正例覆盖率为%.2f%%' %(Sensitivity*100))
print('负例覆盖率为%.2f%%' %(Specificity*100))
# 使用Seaborn的heatmap绘制混淆矩阵
import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix
import seaborn as sns
sns.heatmap(metrics.confusion_matrix(y_test, y_pred), annot=True, fmt='d')
plt.title('Confusion Matrix')
plt.xlabel('Predicted label')
plt.ylabel('True label')
plt.show()
#进行ROC曲线绘制计算准备
# у得分为模型预测正例的概率
y_score =nnmodel.predict_proba(X_test)[:,1]
#计算不同阈值下,fpr和tpr的组合值,其中fpr表示1-Specificity,tpr表示sensitivity
fpr,tpr,threshold =metrics.roc_curve(y_test,y_score)
# 计算AUC的值
roc_auc = metrics.auc(fpr,tpr)
print("神经网络模型预测测试集数据ROC曲线的AUC:",roc_auc)
神经网络模型预测测试集数据ROC曲线的AUC: 0.9423111111111111
#绘制ROC曲线
import matplotlib.pyplot as plt
import seaborn as sns
# 绘制面积图
plt.stackplot(fpr, tpr, color='steelblue', alpha = 0.5,edgecolor = 'black')
# 添加边际线
plt.plot(fpr, tpr, color='black',lw = 1)
# 添加对角线
plt.plot([0,1],[0,1],color ='red',linestyle ='--')
# 添加文本信息
plt.text(0.5,0.3,'Roc curve(area =%.2f)'% roc_auc)
# 添加轴标签
plt.xlabel('1-Specificity')
plt.ylabel('Sensitivity')
# 显示图形
plt.show()
神经网络模型通常由多个层次组成,包括输入层、隐藏层和输出层。输入层接收外部输入信号,隐藏层负责处理和转换输入信号,输出层生成最终的输出结果。每个神经元都有一定的权重和偏置,权重决定了神经元之间的连接强度,偏置则决定了神经元的激活阈值。通过调整这些权重和偏置,神经网络可以学习输入数据的特征和规律。
包括:
前馈神经网络:信号只能从前向后传递,常用于分类和回归问题。
循环神经网络:神经元之间存在反馈连接,常用于处理时间序列数据。
卷积神经网络:具有卷积层和池化层,适用于图像识别和视频分析。
自编码器:用于数据降维、特征提取和去噪。
生成对抗网络:用于生成新的数据样本。
激活函数和反向传播算法
在神经网络中,激活函数用于引入非线性,使得神经网络能够处理复杂的模式。常见的激活函数包括Sigmoid、ReLU等。反向传播算法用于在训练过程中调整权重和偏置,通过计算损失函数的梯度来更新参数,以最小化损失函数。
XGBoost(eXtreme Gradient Boosting)是一种优化的梯度提升决策树(GBDT)算法,旨在通过集成多个弱学习器(通常是决策树)来构建一个强大的集成模型。XGBoost在GBDT的基础上进行了多项改进,包括损失函数的二阶泰勒展开、正则项的加入、并行计算和缺失值处理等,从而提高了训练速度和模型泛化能力。
XGBoost的核心原理主要包括以下几个方面:
损失函数优化:XGBoost使用泰勒展开式对损失函数进行近似,不仅考虑了一阶导数(梯度),还考虑了二阶导数(海森矩阵),这使得优化更加精确。
正则化项:为了防止过拟合,XGBoost引入了正则化项,包括树模型的复杂度,这有助于在训练过程中平衡模型的复杂度和偏差。
目标函数:XGBoost的目标函数是损失函数和正则化项的加权和,通过优化这个目标函数来逐步构建树模型。
模型更新:采用贪婪算法逐步构建树模型,每一步迭代都会学习一个新的树模型,以减小目标函数。
XGBoost具有以下显著特点:
高效的并行化处理:能够有效地利用多核处理器进行并行计算,加速模型训练过程。
灵活性和便携性:XGBoost是一个优化的分布式梯度增强库,旨在实现高效、灵活和便携的机器学习算法。
广泛的适用性:适用于各种机器学习任务,包括分类、回归、排序等。
实际应用案例
XGBoost在许多领域都有广泛的应用,例如:
金融领域:用于信用评分、欺诈检测等。
电商领域:用于用户行为预测、商品推荐等。
医疗健康:用于疾病诊断、药物效果预测等。
其他领域:如广告推荐、自然语言处理等。
综上所述,XGBoost通过其高效的优化算法和强大的并行计算能力,在多个领域中展现了卓越的性能,成为许多数据科学任务的首选模型。
今天我们仍以二分类因变量的示例数据为例,探讨一下XGBboost模型可视化及预测效果的ROC曲线、混淆矩阵评价的方法。
#加载程序包(openpyxl和pandas等)
# 使用pandas读取示例数据xlsx文件
import openpyxl
import pandas as pd
import simpleNomo
import matplotlib.pyplot as plt
xgbdata = pd.read_excel(r'C:\Users\L\Desktop\示例数据.xlsx')
# 查看前几行数据
print(xgbdata.head())
#加载XGBoost模型所用的包
import xgboost as xgb
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_breast_cancer
from sklearn.metrics import accuracy_score
# 分离特征和目标变量
X = xgbdata[['指标1', '指标2', '指标3','指标4','指标5','指标6']]
y = xgbdata['结局']
# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# 转换数据类型为32位浮点数
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
# 使用XGBoost建模并训练
xgb_model = xgb.XGBClassifier()
xgb_model.fit(X_train, y_train)
# 对测试集数据进行预测
y_train_pred = xgb_model.predict(X_train)
y_pred = xgb_model.predict(X_test)
print("训练集预测结果为:\n",y_train_pred)
print("测试集预测结果为:\n",y_pred)
# 评估模型
accuracy_train = accuracy_score(y_train, y_train_pred)
accuracy = accuracy_score(y_test, y_pred)
print(f'Model Accuracy(训练集): {accuracy_train}')
print(f'Model Accuracy(测试集): {accuracy}')
Model Accuracy(训练集): 1.0
Model Accuracy(测试集): 0.9266666666666666
#XGB模型可视化
#模型变量重要性评分
xgb.plot_importance(xgb_model)
plt.show()
#tree绘图
import matplotlib.pyplot as plt
xgb.plot_tree(xgb_model, num_trees=2)
plt.show()
#混淆矩阵评估模型
#导入第三方模块
from sklearn import metrics
# 混淆矩阵
print("混淆矩阵四格表输出如下:")
print(metrics.confusion_matrix(y_test, y_pred, labels = [0, 1]))
Accuracy = metrics._scorer.accuracy_score(y_test, y_pred)
Sensitivity = metrics._scorer.recall_score(y_test, y_pred)
Specificity = metrics._scorer.recall_score(y_test, y_pred, pos_label=0)
print("XGB模型混淆矩阵评价结果如下:")
print('模型准确率为%.2f%%' %(Accuracy*100))
print('正例覆盖率为%.2f%%' %(Sensitivity*100))
print('负例覆盖率为%.2f%%' %(Specificity*100))
# 使用Seaborn的heatmap绘制混淆矩阵
import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix
import seaborn as sns
sns.heatmap(metrics.confusion_matrix(y_test, y_pred), annot=True, fmt='d')
plt.title('Confusion Matrix')
plt.xlabel('Predicted label')
plt.ylabel('True label')
plt.show()
#进行ROC曲线绘制计算准备
# у得分为模型预测正例的概率
y_score =xgb_model.predict_proba(X_test)[:,1]
#计算不同阈值下,fpr和tpr的组合值,其中fpr表示1-Specificity,tpr表示sensitivity
fpr,tpr,threshold =metrics.roc_curve(y_test,y_score)
# 计算AUC的值
roc_auc = metrics.auc(fpr,tpr)
print("XGB模型预测测试集数据ROC曲线的AUC:",roc_auc)
XGB模型预测测试集数据ROC曲线的AUC: 0.9737777777777777
#绘制ROC曲线
import matplotlib.pyplot as plt
import seaborn as sns
# 绘制面积图
plt.stackplot(fpr, tpr, color='steelblue', alpha = 0.5,edgecolor = 'black')
# 添加边际线
plt.plot(fpr, tpr, color='black',lw = 1)
# 添加对角线
plt.plot([0,1],[0,1],color ='red',linestyle ='--')
# 添加文本信息
plt.text(0.5,0.3,'Roc curve(area =%.2f)'% roc_auc)
# 添加轴标签
plt.xlabel('1-Specificity')
plt.ylabel('Sensitivity')
# 显示图形
plt.show()
LightGBM(Light Gradient Boosting Machine)是一个基于梯度提升决策树(Gradient Boosting Decision Tree, GBDT)的机器学习模型,由微软研究院开发。它是对GBDT算法的优化和高效实现,旨在解决大数据量级下的训练问题,特别适用于工业实践。
更快的训练速度:LightGBM使用直方图算法(histogram algorithm),这种算法占用的内存更低,数据分割的复杂度更低,从而显著提高了训练速度。
更低的内存消耗:与XGBoost相比,LightGBM的内存占用率更低,大约是XGBoost的1/612。
更高的准确率:在保持或提升准确率的同时,LightGBM在许多实验中表现出色,甚至在某些情况下比XGBoost更优。
支持并行化和分布式处理:LightGBM支持高效的并行训练和分布式处理,能够快速处理大规模数据。
支持类别特征:LightGBM可以直接使用类别特征,无需事先进行转换,简化了数据处理流程。
LightGBM模型在医疗大数据中的应用主要体现在疾病预测和个性化治疗方面,特别是在肺癌分类和糖尿病确诊预测中表现出色。
LightGBM模型在医疗大数据中的应用场景
疾病预测:LightGBM模型可以用于疾病风险评估、疾病诊断和疾病预后预测。通过分析大规模的医疗数据,LightGBM能够识别出患病风险较高的个体,辅助医生进行早期干预和预防,提高诊断准确性,并预测疾病的进展和患者的预后。
个性化治疗:在肺癌分类中,LightGBM模型通过处理大规模数据集和高维稀疏数据,能够提供准确的分类结果,帮助制定有效的治疗和预后评估。此外,LightGBM还提供了特征重要性评估功能,帮助理解疾病的潜在机制,指导临床决策。
LightGBM模型在医疗大数据中的优势
高效性能:LightGBM采用基于直方图的决策树分割算法,能够处理大规模数据集和高维稀疏数据,加速模型训练和预测过程。
特征重要性评估:LightGBM提供特征重要性评估功能,帮助识别对疾病预测最具影响力的特征,这对于理解疾病的潜在机制和指导临床决策至关重要1。
超参数优化:LightGBM允许用户根据特定数据集和预测任务进行模型定制,有助于提高模型的性能并避免过度拟合。
今天我们仍以二分类因变量的示例数据为例,探讨一下ligntGBM模型可视化及预测效果的ROC曲线评价的Python操作。
# 使用pandas读取示例数据xlsx文件
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
gbmdata = pd.read_excel(r'C:\Users\L\Desktop\示例数据.xlsx')
# 查看前几行数据
print(gbmdata .head())
gbmdata.columns = ['序号','结局','指标1', '指标2', '指标3','指标4','指标5','指标6','指标7','时间','指标8']
# 对导入的实例数据分离特征和目标变量
X = gbmdata[['指标1', '指标2', '指标3','指标4','指标5','指标6']]
y = gbmdata[['结局']]
#划分训练集和测试集
from sklearn.model_selection import train_test_split #划分数据集与测试集
# Splitting the data into training and testing sets
X_train,X_test,y_train,y_test=train_test_split
(X,y,test_size=0.30, random_state=77, stratify=y)
#建模预测
import lightgbm as lgb
from sklearn.metrics import mean_squared_error
# 转换数据类型
lgb_train = lgb.Dataset(X_train, y_train)
lgb_eval = lgb.Dataset(X_test, y_test, reference=lgb_train)
# 设置参数
params = {
'task': 'train',
'boosting_type': 'gbdt',
'objective': 'regression',
'metric': {'l2', 'auc'},
'num_leaves': 31,
'learning_rate': 0.05,
'feature_fraction': 0.9,
'bagging_fraction': 0.8,
'bagging_freq': 5,
'verbose': 0
}
# 训练模型
gbmmodel = lgb.train(params,lgb_train,num_boost_round=100)
# 进行预测
y_train_pred = gbmmodel.predict(X_train)
y_pred = gbmmodel.predict(X_test, num_iteration=gbmmodel.best_iteration)
print("训练集预测值:\n",y_train_pred)
print("测试集预测值:\n",y_pred)
# 评估模型
#图示训练集预测值与真实值对比
plt.plot(list(range(0,len(X_train))),y_train,marker='o')
plt.plot(list(range(0,len(X_train))),y_train_pred,marker='*')
plt.show()
#图示测试集预测值与真实值对比
plt.plot(list(range(0,len(X_test))),y_test,marker='o')
plt.plot(list(range(0,len(X_test))),y_pred,marker='*')
plt.show()
# 使用Graphviz可视化模型
import graphviz
from IPython.display import Image
dot_data = lgb.create_tree_digraph(gbmmodel)
dot_data.render('tree_0', view=True)#保存为PDF格式
# 在PyCharm的plots区域显示图像
with open("tree_0", "rb") as f:
image = Image(data=f.read())
plt.show()
#进行ROC曲线绘制计算准备
from sklearn import metrics
# у得分为模型预测正例的概率
#计算不同阈值下,fpr和tpr的组合值,其中fpr表示1-Specificity,tpr表示sensitivity
fpr,tpr,threshold =metrics.roc_curve(y_test,y_pred)
# 计算AUC的值
roc_auc = metrics.auc(fpr,tpr)
print("lightBGM模型预测测试集数据ROC曲线的AUC:",roc_auc)
lightBGM模型预测测试集数据ROC曲线的AUC: 0.9567555555555556
#绘制ROC曲线
import matplotlib.pyplot as plt
import seaborn as sns
# 绘制面积图
plt.stackplot(fpr, tpr, color='steelblue', alpha = 0.5,edgecolor = 'black')
# 添加边际线
plt.plot(fpr, tpr, color='black',lw = 1)
# 添加对角线
plt.plot([0,1],[0,1],color ='red',linestyle ='--')
# 添加文本信息
plt.text(0.5,0.3,'Roc curve(area =%.2f)'% roc_auc)
# 添加轴标签
plt.xlabel('1-Specificity')
plt.ylabel('Sensitivity')
# 显示图形
plt.show()
LightGBM广泛应用于各种机器学习任务,特别是在工业界,常用于多分类、点击率预测、搜索排序等任务。由于其高效性和准确性,LightGBM在Kaggle等数据挖掘竞赛中也有出色的表现,许多冠军方案都是基于LightGBM实现的。
综上所述,LightGBM凭借其快速训练、低内存消耗、高准确率和高效并行处理等优势,成为处理大规模数据时的一个优选模型。
医学统计数据分析分享交流SPSS、R语言、Python、ArcGis、Geoda、GraphPad、数据分析图表制作等心得。承接数据分析,论文修回,医学统计,空间分析,问卷分析业务。若有投稿和数据分析代做需求,可以直接联系我,谢谢!