一元线性回归

如果需要查找两个变量之间是否存在线性关系1.散点图散点图只能反映出两个变量之间是否存在线性关系并不能直接断定两个变量没有关系(还可能存在非线性关系)2.公式计算利用线性计算公式推导两个变量之间的关系大于0.8说明两个变量存在明显的线性关系大于0.5小于0.8说明两个变量存在线性关系大于0.3小于0.5说明两个变量可能存在线性关系小于0.3说明两个变量之间不存在线性关系(没有关系、非线性)# 数学概念因变量:受自变量的影响而改变自变量:由实验者操纵、掌握的变量自变量是原因，因变量是结果ex:x称为⾃变量，y称为因变量a为模型的截距项，b为模型的斜率项，ε为模型的误差项；误差项ε的存在主要是为了平衡等号两边的值，通常被称为模型无法解释的部分

一元线性回归代码

import pandas as pd
import statsmodels.api as sm
import matplotlib.pyplot as pltdf1 = pd.read_csv(r'Salary_Data.csv')# 先画出工作年限和薪资待遇的散点图
# 绘制散点图
plt.scatter(x = df1.YearsExperience, # 指定散点图的x轴数据y = df1.Salary, # 指定散点图的y轴数据color = 'steelblue' # 指定散点图中点的颜色)
# 添加x轴和y轴标签
plt.xlabel('YearsExperience')
plt.ylabel('Salary')
# 添加标题
plt.title('Salary&YearsExperience')
# 显示图形
plt.show()# 使用线性回归公式计算方程
fit = sm.formula.ols('Salary~YearsExperience',data=df1).fit()
fit.paramsIntercept          25792.200199       截距项
YearsExperience     9449.962321     斜率项
公式:Salary = 25792.200199 + 9449.962321YearsExperience

多元线性回归模型

1.对于一元线性回归模型来说，其反映的是单个自变量对因变量的影响，
然而实际情况中，影响因变量的自变量往往**不止一个**，
从而需要将一元线性回归模型扩展到多元线性回归模型2.训练集主要就是用来模拟出数学模型测试集主要就是用来测试模拟的数学模型是否准确通常将数据集的80%作为训练集，20%作为训练集我们在研究因变量与自变量关系的时候，如果自变量不止一个，那么我们需要确保多个自变量之间互相没有干扰(不能有关系)通常采取的策略是先转换成数值型变量，之后随即删除一个用来解决自变量之间强烈相关性问题3.离散型变量非数值类型的数据连续型变量数字类型的数据4.多个自变量之间一定不能存在强烈的关系

多元线性回归代码

from sklearn import model_selectiondf2 = pd.read_excel(r'Predict to Profit.xlsx') #读取数据
df2.head()# 将数据拆分成训练集(80%)和测试集(20%)
train,test = model_selection.train_test_split(df2,test_size=0.2,random_state=1234)
# 依据训练集创建模型(State不是数值型变量 带入模型需要加C)
model = sm.formula.ols('Profit~RD_Spend+Administration+Marketing_Spend+C(State)',data=train).fit()# 离散型变量转换用 C(数据字段)  非数字都可以# .fit()  拟合
print('模型的偏回归系数分别为：\n', model.params)模型的偏回归系数分别为：Intercept               58581.516503
C(State)[T.Florida]       927.394424
C(State)[T.New York]     -513.468310
RD_Spend                    0.803487
Administration             -0.057792
Marketing_Spend             0.013779
dtype: float64
排除干扰随机删除一项，只保留new york和florida# 利用模型验证
# 先删除实际因变量利润 用模型产生预测利润
test_X = test.drop(labels='Profit',axis=1)
# 模型预测
pred = model.predict(exog = test_X)
print('对比预测值和实际值的差异：\n',pd.DataFrame({'Prediction':pred,'Real':test.Profit}))对比预测值和实际值的差异：Prediction       Real
8   150621.345801  152211.77
48   55513.218079   35673.41
14  150369.022458  132602.65
42   74057.015562   71498.49
29  103413.378282  101004.64
44   67844.850378   65200.33
4   173454.059691  166187.94
31   99580.888894   97483.56
13  128147.138396  134307.35
18  130693.433835  124266.90
预测与实际结果比较相当接近

---

自定义哑变量

又称虚设变量、名义变量或哑变量，用以反映质的属性的一个人工变量，是量化了的自变量，通常取值为0或1。引入哑变量可使线形回归模型变得更复杂，但对问题描述更简明，一个方程能达到两个方程的作用，而且接近现实。模型中引入虚拟变量的**作用**
1、分离异常因素的影响，例如分析我国GDP的时间序列，必须考虑“**”因素对国民经济的破坏性影响，剔除不可比的“**”因素。
2、检验不同属性类型对因变量的作用，例如工资模型中的文化程度、季节对销售额的影响。
3、提高模型的精度，相当于将不同属性的样本合并，扩大了样本容量（增加了误差自由度，从而降低了误差方差）-{
生成有state变量衍生的哑变量
dummies = pd.get_dummies(变量名.State)
将哑变量与原始数据集水平合并
Profit_New = pd.concat([变量名,dummies], axis = 1)
删除不需要的值
Profit_New.drop(labels = ['State','*****'], axis = 1, inplace = True)
}

# 生成由State变量衍生的哑变量
dummies = pd.get_dummies(df2.State)# 将哑变量与原始数据集水平合并
Profit_New = pd.concat([df2,dummies], axis = 1)
Profit_New.head()
# 删除不需要的值 手动剔除new york
Profit_New.drop(labels = ['State','New York'], axis = 1, inplace = True)# 拆分数据集Profit_New
train, test = model_selection.train_test_split(Profit_New, test_size = 0.2, random_state=1234)
# 建模
model2 = sm.formula.ols('Profit~RD_Spend+Administration+Marketing_Spend+Florida+California', data = train).fit()
print('模型的偏回归系数分别为：\n', model2.params)
# model2测出各种系数模型的偏回归系数分别为：Intercept          58068.048193
RD_Spend               0.803487
Administration        -0.057792
Marketing_Spend        0.013779
Florida             1440.862734
California           513.468310
dtype: float64
这里就删除了new york进行建模预测# 利用模型验证
# 先删除实际因变量利润 用模型产生预测利润
test_X = test.drop(labels='Profit',axis=1)
# 模型预测
pred = model2.predict(exog = test_X)
print('对比预测值和实际值的差异：\n',pd.DataFrame({'Prediction':pred,'Real':test.Profit}))对比预测值和实际值的差异：Prediction       Real
8   150621.345802  152211.77
48   55513.218079   35673.41
14  150369.022458  132602.65
42   74057.015562   71498.49
29  103413.378282  101004.64
44   67844.850378   65200.33
4   173454.059692  166187.94
31   99580.888895   97483.56
13  128147.138397  134307.35
18  130693.433835  124266.90
和未引入哑变量（手动删除一项、）的预测结果相差不大

模型检验之F检验

F检验（F-test），最常用的别名叫做**联合假设检验**，此外也称方差比率检验、方差齐性检验。
它是一种在零假设之下，统计值服从F-分布的检验。
其通常是用来分析用了超过一个参数的统计模型，以判断该模型中的全部或一部分参数是否适合用来估计母体。*检验模型的合理性*计算得到的F值，再与对应F分布表查询，若大于表中的值，则接受原假设（两样本的方差相同），否则拒绝原假设。

#导入第三方模块
import numpy as np#计算建模数据中因变量的均值
ybar = train.Profit.mean()
#统计变量个数和观测个数
p = model2.df_model
n = train.shape[0]#计算回归离差平方和
RSS = np.sum(model2.fittedvalues-ybar)**2)#计算误差平方和
ESS = np.sum(model2.resid**2)
#计算F统计量的值
F = （RSS/p)/(ESS/(n-p-1))
print('F统计量的值:',F)out:
F的统计量的值：174.6372
可以看出计算出来的F统计量值174.64远远大于理论值2.50，
所以应当拒绝原假设，即多元线性回归模型是显著的，也就是说回归模型的偏回归系数都不全为0。
————————————————原代码：https://blog.csdn.net/weixin_49855757/article/details/109231165

结论

模型检验之T检验

*检验系数的合理性*

# 查看T检验
model2.summary()

P>|t| 系数越小，影响利润的程度越大、高首先是              RD_Spend    0.000    # 研发成本
其次是       Administration    0.265    # 管理成本
才是           Marketing_Spend    0.359    # 销售额
最后才是是地区                         # 跟地区关系不大

线性回归模型的短板

1.自变量的个数多于样本量
2.多个自变量之间存在多重共线性

岭回归模型

目的是优化线性回归

为解决多元线性回归模型中可能存在的不可逆问题，统计学家提出了岭回归模型
该模型的思路是在线性回归模型的目标函数之上添加一个 l2 正则项(惩罚项)用于平衡模型方差和偏差l2其实本质就是平方项

线性回归模型的目标函数

为了保证回归系数β \betaβ可求，岭回归模型在目标函数上加了一个L2范数的惩罚项

其中λ为非负数，λ 越大，则为了使J ( β ) 最小，回归系数 β 就越小。
————————————————
详细可看：https://blog.csdn.net/weixin_43374551/article/details/83688913

import pandas as pd
import numpy as np
from sklearn import model_selection
from sklearn.linear_model import Ridge
import matplotlib.pyplot as plt
data=pd.read_excel(r'diabetes.xlsx')
#拆分为训练集和测试集
predictors=data.columns[:-1]
x_train,x_test,y_train,y_test=model_selection.train_test_split(data[predictors],data.Y,test_size=0.2,random_state=1234)
#构造不同的lambda值
Lambdas=np.logspace(-5,2,200)
#存放偏回归系数
ridge_cofficients=[]
for Lambda in Lambdas:ridge=Ridge(alpha=Lambda,normalize=True)ridge.fit(x_train,y_train)ridge_cofficients.append(ridge.coef_)#绘制岭迹曲线
plt.rcParams['font.sans-serif']=['Microsoft YaHei']
plt.rcParams['axes.unicode_minus']=False
plt.style.use('ggplot')
plt.plot(Lambdas,ridge_cofficients)
#x轴做对数处理
plt.xscale('log')
plt.xlabel('Log(Lambda)')
plt.ylabel('Cofficients')
plt.show()'''曲线不容易看出最小值'''

交叉验证

将数据先进行分组，之后取一组作为测试集，其他组作为训练集
依次往复，知道所有的分组都参与了模型的训练和测试为止，最后选出最佳模型

• 交叉验证公式

RidgeCV(alphas=(0.1,1.0,10.0),fit_intercept=True,normalize=False,scoring=None,cv=None)alphas:用于指定多个lambda值的元组或数组对象，默认该参数包含0.1、1和10三种值
fit_intercept:bool类型参数，是否需要拟合截距项，默认为True
normalize:bool类型参数，建模时是否需要对数据集做标准化处理，默认为False
scoring:指定用于评估模型的度量方法
cv:指定交叉验证的重数--------------------

• 代码

import pandas as pd
import numpy as np
from sklearn import model_selection
from sklearn.linear_model import RidgeCVdata=pd.read_excel(r'diabetes.xlsx')
#拆分为训练集和测试集
predictors=data.columns[:-1]
x_train,x_test,y_train,y_test=model_selection.train_test_split(data[predictors],data.Y,test_size=0.2,random_state=1234)
#构造不同的lambda值
Lambdas=np.logspace(-5,2,200)
#设置交叉验证的参数，使用均方误差评估
ridge_cv=RidgeCV(alphas=Lambdas,normalize=True,scoring='neg_mean_squared_error',cv=10)
ridge_cv.fit(x_train,y_train)
print(ridge_cv.alpha_)'''
0.013509935211980266
'''

import pandas as pd
import numpy as np
from sklearn import model_selection
from sklearn.linear_model import Ridge,RidgeCV
from sklearn.metrics import mean_squared_errordata=pd.read_excel(r'diabetes.xlsx')
data=data.drop(['AGE','SEX'],axis=1)
#拆分为训练集和测试集
predictors=data.columns[:-1]
x_train,x_test,y_train,y_test=model_selection.train_test_split(data[predictors],data.Y,test_size=0.2,random_state=1234)
#构造不同的lambda值
Lambdas=np.logspace(-5,2,200)
#设置交叉验证的参数，使用均方误差评估
ridge_cv=RidgeCV(alphas=Lambdas,normalize=True,scoring='neg_mean_squared_error',cv=10)
ridge_cv.fit(x_train,y_train)# 基于最佳lambda值建模
ridge=Ridge(alpha=ridge_cv.alpha_,normalize=True)
ridge.fit(x_train,y_train)
#返回岭回归系数
print(pd.Series(index=['Intercept']+x_train.columns.tolist(),data=[ridge.intercept_]+ridge.coef_.tolist()))# 预测
ridge_pred=ridge.predict(x_test)
# 预测效果验证
RMSE=mean_squared_error(y_test,ridge_pred)
print(RMSE)

RMSE越大越精确
系数越大越不精确

---

Lasso回归

可以降低模型的复杂度，通过添加l1正则项(惩罚项)l1其实本质就是绝对值

• Lasso公式

  LassoCV(eps=0.001, n_alphas=100, alphas=None, fit_intercept=True, normalize=False, precompute=‘auto’, max_iter=1000, tol=0.0001, copy_X=True, cv=None, verbose=False, n_jobs=1, positive=False, random_state=None, selection=‘cyclic’)• eps：指代λ \lambdaλ最小值与最大值的商，默认为0.001。
• n_alphas：指定λ \lambdaλ的个数，默认为100个。
• alphas：指定具体的λ \lambdaλ列表用于模型的运算。
• fit_intercept：bool类型，是否需要拟合截距项，默认为True。
• normalize：bool类型，建模时是否对数据集做标准化处理，默认为False。
• precompute：bool类型，是否在建模前计算Gram矩阵提升运算速度，默认为False。
• max_iter：指定模型的最大迭代次数。
• tol：指定模型收敛的阈值，默认为0.0001。
• copy_X：bool类型，是否复制自变量X的数值，默认为True。
• cv：指定交叉验证的重数。
• verbose：bool类型，是否返回模型运行的详细信息，默认为False。
• n_jobs：指定使用的CPU数量，默认为1，如果为-1表示所有CPU用于交叉验证的运算。
• positive：bool类型，是否将回归系数强制为正数，默认为False。
• random_state：指定随机生成器的种子。
• selection：指定每次迭代选择的回归系数，如果为’random’，表示每次迭代中将随机更新回归系数；如果为’cyclic’，则每次迭代时回归系数的更新都基于上一次运算

# 导入第三方模块
import pandas as pd
import numpy as np
from sklearn import model_selection
from sklearn.linear_model import Lasso,LassoCV
from sklearn.metrics import mean_squared_error# 读取文件
data=pd.read_excel(r'diabetes.xlsx')
data=data.drop(['AGE','SEX'],axis=1)
#拆分为训练集和测试集
predictors=data.columns[:-1]
x_train,x_test,y_train,y_test=model_selection.train_test_split(data[predictors],data.Y,test_size=0.2,random_state=1234)
#构造不同的lambda值
Lambdas=np.logspace(-5,2,200)
#设置交叉验证的参数，使用均方误差评估
lasso_cv=LassoCV(alphas=Lambdas,normalize=True,cv=10,max_iter=10000)
lasso_cv.fit(x_train,y_train)
lasso_cv.alpha_
''' 0.06294988990221888 '''

相对于岭回归而言，可以看到LASSO回归剔除了两个变量，降低了模型的复杂度，同时减少了均方误差，提高了模型的拟合效果。* Lasso回归 > 岭回归 > 线性回归 *

---

Logistich回归模型

我们前面学习的线性回归是用来做预测相关分析eg:发病率
而Logistich回归不是用来做预测而是用来做分类相关分析eg:高低学历Logistich回归本质上还是回归模型但是属于"广义回归"
之前的线性回归属于"狭义回归"

• logistich公式

sklearn.linear_model.LogisticRegression(penalty=‘l2’, dual=False, *tol=0.0001, C=1.0, *fit_intercept=True,   intercept_scaling=1, *class_weight=None, random_state=None, solver=‘liblinear’, *max_iter=100,                    multi_class=‘ovr’, verbose=0, warm_start=False, n_jobs=None, l1_ratio=None)penalty：字符串，可选参数。指定正则化惩罚项使用的范数。
dual：布尔值，可选参数，默认为False。选择原始函数还是对偶函数。对偶函数仅在penalty为’l2’、solver为’liblinear’时才可使用，如果样本数大于特征数则推荐使用原始函数。
* tol：浮点数，可选参数，默认值为0.0001。模型迭代收敛的阈值。
C：浮点数，可选参数，默认值为1.0。正则化强度的倒数。值越小，正则化越强，该值必须为正数。
* fit_intercept：布尔值，可选参数，默认为True。是否添加截距项。相当于在X数据集上人为添加常数列1，用于计算截距项。
intercept_scaling：浮点数，可选参数，默认为1。
* class_weight：可选参数，指定因变量各类别的权重。如果为字典，则通过字典的形式传递每个类别的权重如果为字符串‘balanced’,则每个分类的权重与实际样本中的比例成反比当各分类存在严重不平衡时，设置balanced会比较好，如果为None,则表示每个分类的权重相等。
random_state：可选参数，设定随机种子，solver为’sag’或’liblinear’时可用。
solver：字符串，可选参数，默认值为’liblinear’。
* max_iter：指定模型求解过程中的最大迭代次数，默认为100
multi_class：字符串，可选参数，默认值为’ovr’。
verbose：整数，可选参数，默认值为0。日志冗长度，对于solver为‘liblinear’和‘lbfgs’将设置为任何正数以表示详细程度。
warm_start：布尔值，可选参数，默认值为False。如果设置为True，则会使用上一次的结果作为初始值，否则会清除上一次结果。
n_jobs：整数或None，可选参数，默认值为None。如果multi_class为’ovr’时指定CPU核心使用数量。
l1_ratio：浮点数或None，可选参数，默认值为None。

import pandas as pd
from sklearn import linear_model
from sklearn import model_selection
from sklearn import metrics
import matplotlib.pyplot as plt
import seaborn as snsdata=pd.read_csv(r'Run or Walk.csv')
predictors=data.columns[4:]
#构建自变量矩阵
X=data[predictors]
#因变量y
y=data.activity
#拆分训练集和测试集
X_train,X_test,y_train,y_test=model_selection.train_test_split(X,y,test_size=0.25,random_state=1234)
#建模
logistic_model=linear_model.LogisticRegression()
logistic_model.fit(X_train,y_train)
#返回参数
print('Intercept:',logistic_model.intercept_)
print('Coef:',logistic_model.coef_)#模型预测
pred=logistic_model.predict(X_test)
print(pd.Series(pred).value_counts())#模型评估
#混淆矩阵
cm=metrics.confusion_matrix(y_test,pred,labels=[0,1])
print('混淆矩阵:\n',cm)
Accuracy=metrics.scorer.accuracy_score(y_test,pred)
Sensitivity=metrics.scorer.recall_score(y_test,pred)
Specificity=metrics.scorer.recall_score(y_test,pred,pos_label=0)
print('准确率：%.2f%%' % (Accuracy*100))
print('正例覆盖率：%.2f%%' % (Sensitivity*100))
print('负例覆盖率：%.2f%%' % (Specificity*100))
#绘制混淆矩阵的热力图
sns.heatmap(cm,annot=True,fmt='.2e',cmap='GnBu')
plt.show()#ROC曲线
#y_score为模型预测正例的概率
y_score=logistic_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)
#绘制面积图
plt.stackplot(fpr,tpr,color='steelblue',alpha=0.5,edgecolor='black')
#添加ROC曲线的轮廓
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=%0.2f)' % roc_auc)
plt.xlabel('1-Specificity')
plt.ylabel('Sensitivity')
plt.show()

模型评估—混淆矩阵

A：表示正确预测负例的样本个数，⽤TN表示。
B：表示预测为负例但实际为正例的个数，⽤FN表示。
C：表示预测为正例但实际为负例的个数，⽤FP表示。
D：表示正确预测正例的样本个数，⽤TP表示。准确率：表示正确预测的正负例样本数与所有样本数量的⽐值，即(A+D)/(A+B+C+D)。
正例覆盖率：表示正确预测的正例数在实际正例数中的⽐例，即D/(B+D)。
负例覆盖率：表示正确预测的负例数在实际负例数中的⽐例，即A/(A+C)。
正例命中率：表示正确预测的正例数在预测正例数中的⽐例，即D/(C+D)，

#混淆矩阵
cm=metrics.confusion_matrix(y_test,pred,labels=[0,1])
print('混淆矩阵:\n',cm)
Accuracy=metrics.scorer.accuracy_score(y_test,pred)
Sensitivity=metrics.scorer.recall_score(y_test,pred)
Specificity=metrics.scorer.recall_score(y_test,pred,pos_label=0)
print('准确率：%.2f%%' % (Accuracy*100))
print('正例覆盖率：%.2f%%' % (Sensitivity*100))
print('负例覆盖率：%.2f%%' % (Specificity*100))
#绘制混淆矩阵的热力图
sns.heatmap(cm,annot=True,fmt='.2e',cmap='GnBu')
plt.show()

模型评估—ROC曲线

计算折线下的⾯积，即图中的阴影部分，这个⾯积称为AUC。
在做模型评估时，希望AUC的值越⼤越好，通常情况下，当AUC在0.8以上时，模型就基本可以接受了。

#ROC曲线
#y_score为模型预测正例的概率
y_score=logistic_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)
#绘制面积图
plt.stackplot(fpr,tpr,color='steelblue',alpha=0.5,edgecolor='black')
#添加ROC曲线的轮廓
plt.plot(fpr,tpr,color='black',lw=1)

模型评估—KS曲线

两条折线
KS的计算公式为：
KS= Sensitivity-(1- Specificity)= Sensitivity+
Specificity-1。对于KS值⽽⾔，也是希望越⼤越好，通常情况下，当KS值⼤于0.4时，模型基本可以接受

# 自定义绘制ks曲线的函数
def plot_ks(y_test, y_score, positive_flag):# 对y_test重新设置索引y_test.index = np.arange(len(y_test))# 构建目标数据集target_data = pd.DataFrame({'y_test':y_test, 'y_score':y_score})# 按y_score降序排列target_data.sort_values(by = 'y_score', ascending = False, inplace = True)# 自定义分位点cuts = np.arange(0.1,1,0.1)# 计算各分位点对应的Score值index = len(target_data.y_score)*cutsscores = np.array(target_data.y_score)[index.astype('int')]# 根据不同的Score值，计算Sensitivity和SpecificitySensitivity = []Specificity = []for score in scores:# 正例覆盖样本数量与实际正例样本量positive_recall = target_data.loc[(target_data.y_test == positive_flag) & (target_data.y_score>score),:].shape[0]positive = sum(target_data.y_test == positive_flag)# 负例覆盖样本数量与实际负例样本量negative_recall = target_data.loc[(target_data.y_test != positive_flag) & (target_data.y_score<=score),:].shape[0]negative = sum(target_data.y_test != positive_flag)Sensitivity.append(positive_recall/positive)Specificity.append(negative_recall/negative)# 构建绘图数据plot_data = pd.DataFrame({'cuts':cuts,'y1':1-np.array(Specificity),'y2':np.array(Sensitivity), 'ks':np.array(Sensitivity)-(1-np.array(Specificity))})# 寻找Sensitivity和1-Specificity之差的最大值索引max_ks_index = np.argmax(plot_data.ks)plt.plot([0]+cuts.tolist()+[1], [0]+plot_data.y1.tolist()+[1], label = '1-Specificity')plt.plot([0]+cuts.tolist()+[1], [0]+plot_data.y2.tolist()+[1], label = 'Sensitivity')# 添加参考线plt.vlines(plot_data.cuts[max_ks_index], ymin = plot_data.y1[max_ks_index], ymax = plot_data.y2[max_ks_index], linestyles = '--')# 添加文本信息plt.text(x = plot_data.cuts[max_ks_index]+0.01,y = plot_data.y1[max_ks_index]+plot_data.ks[max_ks_index]/2,s = 'KS= %.2f' %plot_data.ks[max_ks_index])# 显示图例plt.legend()# 显示图形plt.show()----------------------------------------------------------------------------------------------------------------------plt.plot([0,1],[0,1],color='red',linestyle='--')
plt.text(0.5,0.3,'ROC curve (area=%0.2f)' % roc_auc)
plt.xlabel('1-Specificity')
plt.ylabel('Sensitivity')
plt.show()

logistic回归模型
参考:https://www.jianshu.com/p/1e18cb531ede?utm_campaign=maleskine&utm_content=note&utm_medium=seo_notes&utm_source=recommendation

决策树

决策树根节点条件枝节点条件叶子节点实际数据信息熵即信息量熵越⼤，分类越不“纯净”，从而导致无法精准预测分类熵越小，分类越“纯净”，从而导致能够更加精准预测分类信息增益越大，意味着用属性a来进行划分获得的"纯度提升"越大。ID3决策树学习算法以信息增益为准则来选择划分属性。信息熵公式参考：https://blog.csdn.net/weixin_43374551/article/details/98632847条件熵依据不同的条件计算对应下的信息熵eg:根据用户的学历将用户分成低学历 中学历 高学历分别计算每个学历下的信息熵最终求和得到条件熵# 条件熵越小，该条件影响越大信息增益主要就是用来挑选节点字段的某个条件计算出来的信息增益越大说明该条件对结果影响也越大我们应该将该字段作为节点字段# 信息增益在样本量较少的时候可能会出现偏差称为属性a的"固有值"(intrinsic value)，属性a的取值越多，则IV(a)值通常越大。C4.5算法采用信息增益率来选择划分属性，先从候选划分属性中找出信息增益高于平均水平的属性，再从中选择增益率最高的。信息增益率决策树中的ID3算法使⽤信息增益指标实现根节点或中间节点的字段选择，但是该指标存在⼀个⾮常明显的缺点，即信息增益会偏向于取值较多的字段。为了克服信息增益指标的缺点，提出了信息增益率的概念，它的思想很简单，就是在信息增益的基础上进⾏相应的惩罚。信息增益率的公式可以表示为

sklearn.tree.DecisionTreeClassifier(criterion=‘gini’, splitter=‘best’, max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features=None, random_state=None, max_leaf_nodes=None, min_impurity_decrease=0.0, min_impurity_split=0.0000001, class_weight=None, presort=False)1.参数解释：
criterion：字符串，可选参数。指定选择划分属性的方法。可选方法有
(1) ‘gini’(默认)：使用基尼指数。
(2) ‘entropy’：使用信息增益。
splitter：字符串，可选参数。指定划分点的策略。
(1) ‘best’(默认)：在特征的所有划分点中找出最优的划分点。适合样本量小的情况。
(2) ‘random’：随机的在部分划分点中找出局部最优的划分点。适合样本量大的情况。
max_depth：整数或None，可选参数，默认值为None。指定决策树的最大深度。如果为None，则决策树会完全生长至每个叶结点完全纯净(只包含同类样本)或者所有叶结点的样本数均小于参数min_samples_split。本参数旨在避免过拟合，在样本量大，特征数多的情况下可以使用。
min_samples_split：整数或浮点数，可选参数，默认值为2。对内部结点进行划分时，指定内部结点所包含的最小样本数。
(1) 整数：表示最小的样本数量
(2) 浮点数：表示一个比例，且 向上取整(比例*样本数) 表示最小的样本数量
min_samples_leaf：整数或浮点数，可选参数，默认值为1。叶结点包含的最小样本数量。该参数表示如果一个结点划分后其左右分支包含的样本数不小于min_sample_leaf时，才考虑对其进行划分。
(1) 整数：表示最小的样本数量
(2) 浮点数：表示一个比例，且 向上取整(比例*样本数) 表示最小的样本数量
min_weight_fraction_leaf：浮点数，可选参数，默认为0.。指定叶子结点所有样本权重和的最小值，小于该值则其被剪枝，即其父结点不进行划分，默认值为0表示不考虑权重问题。当样本缺失值较多或样本类别分布偏差很大时，会引入样本权重，此时需要考虑本参数值。
max_features：整数、浮点数、字符串或None，可选参数。指定寻找最优划分属性时允许考虑的最大特征数量。
(1) 整数：max_features表示考虑的最大特征数量
(2) 浮点数：表示一个比例，向下取整(比例*特征数) 为考虑的最大特征数量
(3) ‘auto’：max_features = sqrt(特征数)
(4) ‘sqrt’：max_features = sqrt(特征数)
(5) ‘log2’：max_features = log2(特征数)
(6) None(默认)：max_features = 特征数注意，在至少有一个有效划分结点样本找到之前，对最优划分属性的搜寻不会停止，即使设置了本参数，仍然会超过限制特征数量去搜寻。
random_state：可选参数。设定随机种子。
(1) 整数：random_state是随机数生成器使用的种子
(2) RandomState实例：random_state是随机数生成器
(3) None(默认)：随机数生成器是np.random使用的RandomState实例
max_leaf_nodes：整数或None，可选参数，默认值为None。指定最大叶结点数量，旨在限制复杂度避免过拟合。None表示不限制叶结点数量。
min_impurity_decrease：浮点数，可选参数，默认值为0.。当一个结点划分后的纯度增长大于等于该参数值时，才将该结点进行划分。表示划分后的右分支的样本数量（如果权重参数传入了，则所有数量均加权）。
min_impurity_split：浮点数，默认值为1e-7。纯度阈值，如果一个结点的纯度大于该值则划分，否则该结点即为叶结点。
class_weight：指定各类别的权重。
(1) 字典：形如{class_label: weight}
(2) 字典列表：对于多结果分类问题，需要为每个类别单独设置权重，比如4分类问题，权重应设置为[{0: 1, 1: 1}, {0: 1, 1: 5}, {0: 1, 1: 1}, {0: 1, 1: 1}]而不是[{1:1}, {2:5}, {3:1}, {4:1}]
(3) ‘balanced’：每个类别的权重与实际样本中的比例成反比，权重计算公式为n_samples ( n_classes * np.bincount(y)) np.bincount表示每个类别计数 \dfrac{\text{n\_samples}}{ (\text{n\_classes * np.bincount(y))}} \qquad \text{np.bincount表示每个类别计数}
(n_classes * np.bincount(y))
n_samplesnp.bincount表示每个类别计数
(4) None(默认)：每个类别的权重都一样
如果fit方法中sample_weight指定了，则类别权重会跟样本权重(sample_weight)相乘。
presort：布尔值，可选参数，默认值为False。指定是否预先对数据进行排序。数据集较大时，预先排序可能会降低训练速度；数据集较小或者限制了数的深度时，则会提升训练速度。
注意：由于在划分的时候特征是随机排列的，因此尽管数据集相同，每次得到的最优划分属性也不一定相同，为了避免这种情况，random_state必须固定。由于在划分的时候特征是随机排列的，因此尽管数据集相同，每次得到的最优划分属性也不一定相同，为了避免这种情况，random_state必须固定。公式参考：https://blog.csdn.net/weixin_43374551/article/details/98632847

基尼指数

ID3算法信息增益会偏向于取值较多的变量，极端例子如果一个变量的取值正好是N个，则其条件熵会等于0，在该变量下因变量的信息增益一定是最大的，
为了克服这种缺点，决策树中的C4.5算法使⽤信息增益率指标实现根节点或中间节点的字段选择，但该算法与ID3算法⼀致，都只能针对离散型因变量进⾏分类，对于连续型的因变量就显得束⼿⽆策了。为了能够让决策树预测连续型的因变量，Breiman等⼈在1984年提出了CART算法，该算法也称为分类回归树，它所使⽤的字段选择指标是基尼指数。
ID3和C4.5只能对离散型因变量进行分类，而CART可以处理连续型因变量。CART算法以基尼指数对根节点或中间节点进行选择。
Python的sklearn模块使用的便是CART算法。决策树不单单可以解决分类问题，其实还可以解决预测问题但是信息增益率只能用于分类问题如果想预测，需要使用基尼指数(既可以做分类也做预测)条件基尼指数(类似于条件熵)基尼指数增益：与信息增益类似，即因变量的基尼指数下降速度的快慢，下降的越快，自变量对因变量的影响越强。公式参考 https://blog.csdn.net/weixin_43374551/article/details/83410070

二叉树

每个节点只能分成两个，如何解决多个条件的情况eg:针对学历先分成低学历非低学历针对年龄先成未成年成年

随机森林

其实就是由单个单个的决策树组织在一起形成的
随机森林是通过单个单个决策树的选择(投票比例)来决定最终的结果如果预剪枝不够理想，还可以使用集成的随机森林算法，可以很好的避免单棵决策树过拟合的问题。
如果训练集有N个样本，P个自变量，1个因变量：利用Bootstrap抽样法，从原始数据中生成k个数据集(样本个数N，变量个数P)
针对这k个数据集中的每一个数据集，构造一棵决策树(变量个数p，从总变量个数P中随机选择)，并且每一棵决策树都不剪枝。
针对这k棵决策树形成的随机森林，对分类问题利用投票法，得票最高的类别作为最终的判断结果；对回归问题利用均值法，所有结果的平均值作为最终的预测结果。
在形成随机森林的过程中，由于每棵树的训练样本是随机的，构成树节点的变量也是随机选择的，所以使得随机森林不容易产生过拟合。

函数说明

RandomForestClassifier(n_estimators=10, criterion='gini', max_depth=None, min_samples_split=2, min_samples_leaf=1,
max_leaf_nodes=None,  bootstrap=True, class_weight=None )

分类

import pandas as pd
import numpy as np
from sklearn import model_selection,tree,metrics,ensemble
from sklearn.model_selection import GridSearchCV
import matplotlib.pyplot as pltdata=pd.read_csv(r'data.csv')
#拆分训练集和测试集
predictors=data.columns[1:]
x_train,x_test,y_train,y_test=model_selection.train_test_split(data[predictors],data.Survived,test_size=0.25,random_state=1234)#使用网格搜索法，尝试不同组合（最大深度、分支最小样本量、叶节点最小样本量）
#根据经验，数据量较小时树的最大深度可设置10以内，较大时则需设置比较大的树深度，如20左右
max_depth=[2,3,4,5,6]
min_samples_split=[2,4,6,8]
min_samples_leaf=[2,4,8,10,12]
parameters={'max_depth':max_depth,'min_samples_split':min_samples_split,'min_samples_leaf':min_samples_leaf}
#网格搜索法，测试不同的参数值
grid_dtcateg=GridSearchCV(estimator=tree.DecisionTreeClassifier(),param_grid=parameters,cv=10)
#模型拟合
grid_dtcateg.fit(x_train,y_train)
#返回最佳参数组合
print(grid_dtcateg.best_params_)#构建分类决策树
CART_Class=tree.DecisionTreeClassifier(max_depth=grid_dtcateg.best_params_['max_depth'],min_samples_leaf=grid_dtcateg.best_params_['min_samples_leaf'],min_samples_split=grid_dtcateg.best_params_['min_samples_split'])
decision_tree=CART_Class.fit(x_train,y_train)
pred=CART_Class.predict(x_test)
print('测试集的预测准确率：',metrics.accuracy_score(y_test,pred))
print('训练集的预测准确率：',metrics.accuracy_score(y_train,CART_Class.predict(x_train)))#绘制ROC曲线
y_score=CART_Class.predict_proba(x_test)[:,1] #预测值为第2种的概率
fpr,tpr,threshold=metrics.roc_curve(y_test,y_score)
#计算AUC的值
roc_auc=metrics.auc(fpr,tpr)
#绘制面积图
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.4,0.4,'DecisionTree ROC curve (area = %0.2f)' % roc_auc)
#添加x轴和y轴标签
plt.xlabel('l-Specificity')
plt.ylabel('Sensitivity')
plt.show()#构建随机森林
RF_class=ensemble.RandomForestClassifier(n_estimators=200,random_state=1234)
RF_class.fit(x_train,y_train)
RFclass_pred=RF_class.predict(x_test)
print('随机森林模型在测试集的预测准确率：',metrics.accuracy_score(y_test,RFclass_pred))#绘制ROC曲线
y_score=RF_class.predict_proba(x_test)[:,1]
fpr,tpr,threshold=metrics.roc_curve(y_test,y_score)
#计算AUC的值
roc_auc=metrics.auc(fpr,tpr)
#绘制面积图
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.4,0.3,'RandomForest ROC curve (area = %0.2f)' % roc_auc)
#添加x轴和y轴标签
plt.xlabel('l-Specificity')
plt.ylabel('Sensitivity')
plt.show()#变量重要程度绘图
importance=RF_class.feature_importances_
Impt_Series=pd.Series(importance,index=x_train.columns)
Impt_Series.sort_values(ascending=True).plot('barh')
plt.show()

预测

import pandas as pd
from sklearn import model_selection,tree,metrics,ensemble
from sklearn.model_selection import GridSearchCVdata=pd.read_excel(r'C:\Users\sc\Desktop\NHANES.xlsx')
#拆分训练集和测试集
predictors=data.columns[:-1]
x_train,x_test,y_train,y_test=model_selection.train_test_split(data[predictors],data.CKD_epi_eGFR,test_size=0.25,random_state=1234)
#预设各参数
max_depth=[18,19,20,21,22]
min_samples_split=[2,4,6,8]
min_samples_leaf=[2,4,8,10,12]
parameters={'max_depth':max_depth,'min_samples_split':min_samples_split,'min_samples_leaf':min_samples_leaf}
#网格搜索法，测试不同的参数值
grid_dtcateg=GridSearchCV(estimator=tree.DecisionTreeRegressor(),param_grid=parameters,cv=10)
grid_dtcateg.fit(x_train,y_train)
#返回最佳参数组合
print(grid_dtcateg.best_params_)#构建回归的决策树
CART_Reg=tree.DecisionTreeRegressor(max_depth=grid_dtcateg.best_params_['max_depth'],min_samples_leaf=grid_dtcateg.best_params_['min_samples_leaf'],min_samples_split=grid_dtcateg.best_params_['min_samples_split'])
CART_Reg.fit(x_train,y_train)
pred=CART_Reg.predict(x_test)
print('决策树均方误差MSE：',metrics.mean_squared_error(y_test,pred))#构建用于回归的随机森林
RF=ensemble.RandomForestRegressor(n_estimators=200,random_state=1234)
RF.fit(x_train,y_train)
RF_pred=RF.predict(x_test)
print('随机森林均方误差：',metrics.mean_squared_error(y_test,RF_pred))

K近邻模型

K-近邻算法(k-Nearest Neighbor，KNN)是机器学习算法中最简单最容易理解的算法。
该算法的思路是：给定一个训练数据集，对新的输入实例，在训练数据集中找到与该实例最邻近的K个实例， 这K个实例的多数属于某个类，就把该输入实例分类到这个类中优点：精度高、对异常值不敏感、无数据输入假定
缺点：计算复杂度高、空间复杂度高
适用数据范围：数值型和标称型既可以预测分类问题也可以预测预测问题1.针对离散型变量的预测采用的是频率法(由已知样本频率高低采取频率高的作为判断结果)2.针对连续型变量的预测采用的是均值法***k值的选择是非常重要的权重距离度量1.欧式距离2.曼哈顿距离3.余弦相似度关键字1.过拟合    过拟合（overfitting）与欠拟合（underfitting）是统计学中的一组现象。过拟合是在统计模型中，由于使用的参数过多而导致模型对观测数据（训练数据）过度拟合，以至于用该模型来预测其他测试样本输出的时候与实际输出或者期望值相差很大的现象。2.欠拟合欠拟合则刚好相反，是由于统计模型使用的参数过少，以至于得到的模型难以拟合观测数据（训练数据）的现象。

分类

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn import model_selection
from sklearn import neighbors
from sklearn import metricsdata=pd.read_excel(r'data.xlsx')
#拆分为训练集和测试集
predictors=['pre1','pre2','pre3','pre4','pre5']
classification=['class']
x_train,x_test,y_train,y_test=model_selection.train_test_split(data[predictors], data[classification],test_size=0.25,random_state=1234)
#设置k值集合
K=np.arange(1,int(np.ceil(np.log2(data.shape[0]))))
#存储不同k值的平均准确率
accuracy=[]
for k in K:#使用10折交叉验证的方法，比对每一k值下KNN模型的预测准确率cv_result=model_selection.cross_val_score(neighbors.KNeighborsClassifier(n_neighbors=k,
weights='distance'),x_train,y_train,cv=10,scoring='accuracy')accuracy.append(cv_result.mean())#查询最大平均准确率的下标
arg_max=np.array(accuracy).argmax()
#绘制折线图
plt.rcParams['font.sans-serif']=['Microsoft YaHei'] #中文和负号正常显示
plt.rcParams['axes.unicode_minus']=False
plt.plot(K,accuracy) #折线图
plt.scatter(K,accuracy) #散点图
plt.text(K[arg_max],accuracy[arg_max],'最佳k值为%s' % int(K[arg_max]))
plt.show() #显示图形#以最佳K值构建模型
knn_class=neighbors.KNeighborsClassifier(n_neighbors=int(K[arg_max]),weights='distance')
knn_class.fit(x_train,y_train)
predict=knn_class.predict(x_test)#模型评估
print('Confusion Matrix:\n',pd.crosstab(y_test,predict)) #构建混淆矩阵
print('Overall Accuracy:',metrics.scorer.accuracy_score(y_test,predict)) #整体准确率
print('Assessment Report:\n',metrics.classification_report(y_test,predict)) #模型评估报告

预测

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn import model_selection
from sklearn import neighbors
from sklearn import metrics
from sklearn.preprocessing import minmax_scaledata=pd.read_excel(r'data.xlsx')
#数据归一化，消除量纲影响
predictors=data.columns[:-1]
X=minmax_scale(data[predictors])
#拆分为训练集和测试集
x_train,x_test,y_train,y_test=model_selection.train_test_split(X, data.classify,test_size=0.25,random_state=1234)#设置k值集合
K=np.arange(1,int(np.ceil(np.log2(data.shape[0]))))
#存储不同k值的平均MSE
mse=[]
for k in K:#使用10折交叉验证的方法，比对每一k值下KNN模型的MSEcv_result=model_selection.cross_val_score(neighbors.KNeighborsRegressor(n_neighbors=k,
weights='distance'),x_train,y_train,cv=10,scoring='neg_mean_squared_error')mse.append((-1*cv_result).mean()) #将负数转换为正数
#查询最小均方误差的下标
arg_min=np.array(mse).argmin()#绘制折线图
plt.rcParams['font.sans-serif']=['Microsoft YaHei'] #中文和负号正常显示
plt.rcParams['axes.unicode_minus']=False
plt.plot(K,mse) #折线图
plt.scatter(K,mse) #散点图
plt.text(K[arg_min],mse[arg_min],'最佳k值为%s' % int(K[arg_min]))
plt.show() #显示图形#以最佳K值构建模型
knn_reg=neighbors.KNeighborsRegressor(n_neighbors=int(K[arg_min]),weights='distance')
knn_reg.fit(x_train,y_train)
predict=knn_reg.predict(x_test)#模型评估
print('MSE:',metrics.mean_squared_error(y_test,predict)) #均方误差越小越好
#参考：https://blog.csdn.net/weixin_43374551/article/details/83275229

朴素贝叶斯模型

条件概率
全概率公式针对连续型问题高斯贝叶斯分类器
针对离散型问题多项式贝叶斯分类器
针对自变量只有0-1二元值伯努利贝叶斯分类器公式参考：https://blog.csdn.net/weixin_43374551/article/details/83449416

高斯贝叶斯分类器

# 导入第三方包
import pandas as pd
# 读入数据
skin = pd.read_excel(r'Skin_Segment.xlsx')
# 设置正例和负例
skin.y = skin.y.map({2:0,1:1})  # 设置一个映射关系，将2映射成0  # 也可以不映射
skin.y.value_counts()'''245057 rows × 4 columns'''

# 导入第三方模块
from sklearn import model_selection
# 样本拆分
X_train,X_test,y_train,y_test = model_selection.train_test_split(skin.iloc[:,:3], skin.y, test_size = 0.25, random_state=1234)

# 导入第三方模块
from sklearn import naive_bayes
# 调用高斯朴素贝叶斯分类器的“类”
gnb = naive_bayes.GaussianNB()
# 模型拟合
gnb.fit(X_train, y_train)
# 模型在测试数据集上的预测
gnb_pred = gnb.predict(X_test)
# 各类别的预测数量
pd.Series(gnb_pred).value_counts()

# 导入第三方包
from sklearn import metrics
import matplotlib.pyplot as plt
import seaborn as sns
# 构建混淆矩阵
cm = pd.crosstab(gnb_pred,y_test)
# 绘制混淆矩阵图
sns.heatmap(cm, annot = True, cmap = 'GnBu', fmt = 'd')
# 去除x轴和y轴标签
plt.xlabel('Real')
plt.ylabel('Predict')
# 显示图形
plt.show()print('模型的准确率为：\n',metrics.accuracy_score(y_test, gnb_pred))
print('模型的评估报告：\n',metrics.classification_report(y_test, gnb_pred))

# 计算正例的预测概率，用于生成ROC曲线的数据
y_score = gnb.predict_proba(X_test)[:,1]
fpr,tpr,threshold = metrics.roc_curve(y_test, y_score)
# 计算AUC的值
roc_auc = metrics.auc(fpr,tpr)# 绘制面积图
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 = %0.2f)' % roc_auc)
# 添加x轴与y轴标签
plt.xlabel('1-Specificity')
plt.ylabel('Sensitivity')
# 显示图形
plt.show()''' ROC曲线达0.94 '''

多项式贝叶斯分类器

离散变量

# 导入第三方包
import pandas as pd
# 读取数据
mushrooms = pd.read_csv(r'mushrooms.csv')
# 数据的前5行
mushrooms.head()''' 5 rows × 22 columns '''

# 将字符型数据作因子化处理，将其转换为整数型数据
columns = mushrooms.columns[1:]
for column in columns:mushrooms[column] = pd.factorize(mushrooms[column])[0]
mushrooms.head()

from sklearn import model_selection
# 将数据集拆分为训练集合测试集
Predictors = mushrooms.columns[1:]
X_train,X_test,y_train,y_test = model_selection.train_test_split(mushrooms[Predictors], mushrooms['type'], test_size = 0.25, random_state = 10)

from sklearn import naive_bayes
from sklearn import metrics
import seaborn as sns
import matplotlib.pyplot as plt
# 构建多项式贝叶斯分类器的“类”
mnb = naive_bayes.MultinomialNB()
# 基于训练数据集的拟合
mnb.fit(X_train, y_train)
# 基于测试数据集的预测
mnb_pred = mnb.predict(X_test)
# 构建混淆矩阵
cm = pd.crosstab(mnb_pred,y_test)
# 绘制混淆矩阵图
sns.heatmap(cm, annot = True, cmap = 'GnBu', fmt = 'd')
# 去除x轴和y轴标签
plt.xlabel('Real')
plt.ylabel('Predict')
# 显示图形
plt.show()# 模型的预测准确率
print('模型的准确率为：\n',metrics.accuracy_score(y_test, mnb_pred))
print('模型的评估报告：\n',metrics.classification_report(y_test, mnb_pred))

from sklearn import metrics
# 计算正例的预测概率，用于生成ROC曲线的数据
y_score = mnb.predict_proba(X_test)[:,1]
fpr,tpr,threshold = metrics.roc_curve(y_test.map({'edible':0,'poisonous':1}), y_score)# 计算AUC的值
roc_auc = metrics.auc(fpr,tpr)# 绘制面积图
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 = %0.2f)' % roc_auc)
# 添加x轴与y轴标签
plt.xlabel('1-Specificity')
plt.ylabel('Sensitivity')
# 显示图形
plt.show()''' AUC面积达0.94 '''

伯努利贝叶斯分类器

     对产品评价做预测

import pandas as pd
# 读入评论数据
evaluation = pd.read_excel(r'Contents.xlsx',sheet_name=0)
# 查看数据前10行
evaluation.head(10)'''  '''

# 运用正则表达式，将评论中的数字和英文去除
evaluation.Content = evaluation.Content.str.replace('[0-9a-zA-Z]','')
evaluation.head()

# !pip3 install jieba
!pip install jieba
# 导入第三方包
import jieba# 加载自定义词库
jieba.load_userdict(r'all_words.txt')# 读入停止词
with open(r'mystopwords.txt', encoding='UTF-8') as words:stop_words = [i.strip() for i in words.readlines()]# 构造切词的自定义函数，并在切词过程中删除停止词
def cut_word(sentence):words = [i for i in jieba.lcut(sentence) if i not in stop_words]# 切完的词用空格隔开result = ' '.join(words)return(result)
# 对评论内容进行批量切词
words = evaluation.Content.apply(cut_word)
# 前5行内容的切词效果
words[:5]

切词后再做处理

# 导入第三方包
from sklearn.feature_extraction.text import CountVectorizer
# 计算每个词在各评论内容中的次数，并将稀疏度为99%以上的词删除
counts = CountVectorizer(min_df = 0.01)
# 文档词条矩阵
dtm_counts = counts.fit_transform(words).toarray()
# 矩阵的列名称
columns = counts.get_feature_names()
# 将矩阵转换为数据框--即X变量
X = pd.DataFrame(dtm_counts, columns=columns)
# 情感标签变量
y = evaluation.Type
X.head()''' 5 rows × 99 columns '''

from sklearn import model_selection
from sklearn import naive_bayes
from sklearn import metrics
import matplotlib.pyplot as plt
import seaborn as sns
# 将数据集拆分为训练集和测试集
X_train,X_test,y_train,y_test = model_selection.train_test_split(X,y,test_size = 0.25, random_state=1)
# 构建伯努利贝叶斯分类器
bnb = naive_bayes.BernoulliNB()
# 模型在训练数据集上的拟合
bnb.fit(X_train,y_train)
# 模型在测试数据集上的预测
bnb_pred = bnb.predict(X_test)
# 构建混淆矩阵
cm = pd.crosstab(bnb_pred,y_test)
# 绘制混淆矩阵图
sns.heatmap(cm, annot = True, cmap = 'GnBu', fmt = 'd')
# 去除x轴和y轴标签
plt.xlabel('Real')
plt.ylabel('Predict')
# 显示图形
plt.show()# 模型的预测准确率
print('模型的准确率为：\n',metrics.accuracy_score(y_test, bnb_pred))
print('模型的评估报告：\n',metrics.classification_report(y_test, bnb_pred))

# 计算正例Positive所对应的概率，用于生成ROC曲线的数据
y_score = bnb.predict_proba(X_test)[:,1]
fpr,tpr,threshold = metrics.roc_curve(y_test.map({'Negative':0,'Positive':1}), y_score)
# 计算AUC的值
roc_auc = metrics.auc(fpr,tpr)# 绘制面积图
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 = %0.2f)' % roc_auc)
# 添加x轴与y轴标签
plt.xlabel('1-Specificity')
plt.ylabel('Sensitivity')
# 显示图形
plt.show()''' AUC面积达0.92 '''

上篇完

转载说明出处

数据分析中的常用数学模型实战教程笔记（上）相关推荐

1. 数据分析中的常用数学模型实战教程笔记（下）

   文章目录 SVM模型 代码操作 手写体字母识别 用最佳参数做预测 使用默认参数做预测 森林火灾可能性预测 Kmeans-K均值聚类模型 随机一个三组二元正态分布随机数 拐点法 轮廓系数法 函数代码 花 ...

2. OpenCV4经典案例实战教程 笔记

   OpenCV4经典案例实战教程 笔记 这几天在看OpenCV4经典的案例实战教程,这里记录一下学习的过程. 案例一 刀片1的缺陷检测 这里的目的是检测出有缺陷的刀片,如下图. 先总结一下思路,这里首先 ...

3. 不容错过，数据分析中最常用的10大Python库

   学习数据分析绝非易事,有无数种工具和资源可供使用.因此,有时会让我们很难弄清楚该学习什么技能,该使用哪种工具. 在本文中,我们就来给大家介绍一下数据分析中最常用的10个Python库.看看这些库你都用 ...

4. 尚硅谷Docker实战教程-笔记02【安装docker、镜像加速器配置】

   尚硅谷大数据技术-教程-学习路线-笔记汇总表[课程资料下载] 视频地址:尚硅谷Docker实战教程(docker教程天花板)_哔哩哔哩_bilibili 尚硅谷Docker实战教程-笔记01[理念简介 ...

5. 视频教程-SharePoint Online 建站实战教程（上）-Office/WPS

   SharePoint Online 建站实战教程(上) 大家好,我是霖雨,从2010年开始致力于SharePoint相关的技术研究,精通SharePoint环境搭建.实施.开发.运维.排错等相关技术, ...

6. html5常用英文单词,英语中最常用的50个单词(上)

   英语中最常用的50个单词(上) 了解英语常用单词不仅能帮助英语学习者提高词汇技能,还能提升日常交流的自信心.但我们需要注意的是,不要指望掌握这些词汇就能说出流利的英语,而应让它们作为一种资源,帮助我们 ...

7. python中pandas格式_Python学习笔记之数据分析中Pandas常用知识

   前言 Pandas基于两种数据类型:series与dataframe. 一个series是一个一维的数据类型,其中每一个元素都有一个标签.series类似于Numpy中元素带标签的数组.其中,标签可以 ...

8. 第6章第21节：图文相搭技巧：将文字嵌入到图像中 [PowerPoint精美幻灯片实战教程]

   本节讲解图文混排时的常用技巧,对于文字较少的图文混排,可以将文字嵌入到图像中.首先对图片进行一些处理. 使用键盘上的快捷键,拷贝所选的内容. 然后降低这张图片的亮度. 点击插入选项卡,显示插入功能面板 ...

9. 【数据分析中的常用模型】篇1：人货场模型：如何开好一家便利店

   今天给大家分享一个简单实用的分析模型:人货场模型 这是一个来源于传统零售行业经典的数据模型,随着新零售这一模式的遍地开花个品牌,积累了大量的经营数据. 如何更好的利用这些数据,来帮助我们提高营业收入是 ...

10. Kubernetes（k8s）入门到实战教程笔记总结

    一.k8s概念和架构 2.1 k8s概述 k8s 是 2014 年 Google 开源的一款容器化集群管理系统,使用 golang 实现 可使用 k8s 进行容器化应用部署,使部署更加方便 使用 k8 ...

最新文章

1. Spring Security 实战干货：OAuth2授权回调的核心认证流程
2. 大数据和python哪个好_大数据语言之争：Java和python哪个好？
3. Jurassic.ScriptEngine 简易示例
4. MySQL中cast()与convert()的用法
5. 电脑太慢了最简单的办法怎么弄_修电脑不求人—最实用办公室电脑故障及解决办法，办公室人都说好...
6. 3.1 scrapy框架 -- 安装与基本使用
7. 文件比较，忽略目录引起编译出错
8. linux彻底卸载 mysql
9. webex java插件_Linux安装Java和Webex
10. 【力扣面试】面试题 04.02. 最小高度树（就是创建二叉平衡树）
11. 程序员：职业很抓狂！前途很迷茫？送你破解困境秘籍！
12. 程序员是如何买房的？
13. 异常来自nbsp;HRESULT:0x80040215
14. NC 一些常用方法总结
15. 基于epoll，socket与protobuf的简单帧同步游戏服务器
16. Illegal base64 character 20
17. 【计算机毕业设计】295演唱会购票系统的设计与实现
18. edg击败we视频_2019德杯淘汰赛：EDG让二追三击败WE
19. 华科2020计算机专业录取线,华中科技大学2020录取分数线是多少
20. Python使用opencv打开笔记本摄像头时遇到的问题及解决办法

热门文章

1. 提前体验让人回归Windows怀抱的Windows Terminal
2. 在ps中用3d来做阴影
3. unity资源管理器error refreshing assets
4. PPT太大如何压缩到最小？
5. 微软Win11与万物互联时代新系统需求更加迫切
6. 《大般涅槃经》略释 净慧法师
7. epcs1s是epcs1系列的么_fpga的EPCS 配置的2种方法 FPGA下载程序的方法（EPCS）
8. NIOS II 烧写epcs中遇到的问题
9. 电脑时间服务器选哪个文件夹,时间同步服务器 - 卡饭网
10. python3读取pdf文档；pdfminer3k