[人工智能]动手学数据分析（三）：数据建模及评估

数据建模

导入数据

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt  #绘图库
import seaborn as sns   #图形可视化
from IPython.display import Image

data = pd.read_csv('clear_data.csv')# 清洗后的数据
train = pd.read_csv('train.csv')# 原始数据

选择模型

1 判断数据集类型

2 选择模型
根据数据样本量、特征的稀疏性决定模型。
尝试多个模型，以一个基本模型作为基础，和其他模型做对比，选择泛化能力或性能比较好的模型。

3 数据拟合
数据拟合：根据已知数据得到一个和数据稳合的曲线，可以根据曲线方程对其他未知数进行预测，要避免过于拟合，会拟合很多非共性的数据。

4 划分数据集
为了评估模型的性能和泛化能力，划分训练集和测试集。
切分数据集的方法：

留出法：将数据集划分为两个互斥的集合，一个训练集，一个测试集
交叉验证法：将数据分为k份，k-1份为训练集，剩余一份为测试集
自助法：有放回重复采样

# sklearn中切割数据集的方法
from sklearn.model_selection import train_test_split
#该函数将数据随机分解为训练集和测试集
train_test_split(arrays,#要分割的数据，被分割的数据因变量和自变量的数量是相同的
				test_size=0.25,  #测试集的大小,(0，1)之间是测试集占的比例，整数表示测试集的样本数
				train_size=0.75,##训练集的大小,(0，1)之间是训练集占的比例，整数表示训练集的样本数
				random_state=2,# 随机种子若为整数表示每次结果相同，可重复实验；若为0或不填表示随机分割，不可复现
				shuffle =False,#是否打乱数据，默认打乱
				stratify=y)# 按某一列进行分层采样

示例
X_train, X_test, y_train, y_test = train_test_split(
   X, y,stratify = y, random_state=42) #随机种子为整数
X_train.head()

模型搭建

基于线性模型的分类模型（逻辑回归）
基于树的分类模型（决策树、随机森林）

1 逻辑回归模型

#逻辑回归模型库
from sklearn.linear_model import LogisticRegression
def LogisticRegression(
	penalty ='l2'#惩罚项，分为l1、l2两种，对参数进行约束，用来解决过拟合的。
	dual=False#只适合用于l2的惩罚项上，样本数量大于特征数时，dual=False
	tol=1e-4#迭代停止的条件，默认0.0001
	C=1.0#默认1.0，正则化系数，越小表示越强的正则化，越能限制模型的复杂度
	fit_intercept=True# 默认True,表示存在截距值
	intercept_scaling=1
	class_weight=None:#类别权重，默认不调整权重。当类别平衡的时候使用,class_weight='balance'表示自动调整权重
	random_state=None, #随机种子可以是int类型和None，默认是None。当"solver"参数为"sag"和"liblinear"的时候生效
	solver='warn', 
	max_iter=100, #最大迭代次数
	multi_class='warn', 
	verbose=0, #默认不输出详细过程
	warm_start=False,#默认false,若设置为True，则以上一次fit的结果作为此次的初始化，
	n_jobs=None,
	l1_ratio=None
	)

逻辑回归方法

fit(X,y,sample_weight = None)：根据给定的训练数据拟合模型，X训练样本，y对应的已知标签，sample_weight样本权重函数
predict(X)：预测样本分类标签的方法，返回每个样本的分类结果
predict_proba(X)：用来做概率估计，返回的是样本为某个标签的概率
score(X,y,sample_weight = None)：根据给定测试数据的X Y，返回平均准确度；即把predict预测的结果和已知的标签进行对比

示例：

Int[1] : lr = LogisticRegression().fit(X_train,y_train)#创建逻辑回归模型，并用训练集的X y并对模型进行	训练
Int[2] : lr
Out[3] : LogisticRegression()
#示例1
Int[4] :print('训练集的得分:{:.3f}'.format(lr.score(X_train,y_train)))
Out[5] : 训练集的得分:0.799
#示例2
Int[6] :lr = LogisticRegression(C=0.01).fit(X_train,y_train)
Int[7] : print('训练集的得分:{:.3f}'.format(lr.score(X_train,y_train)))
Out[8] : 训练集的得分:0.756

2 随机森林
随机森林是由多棵决策树组成的，不同的决策树之间是没有联系的。
进行分类任务时，随机森林中的每一棵决策树都分别对自己的样本进行判断和分类，每一棵决策树得到自己的分类结果。用多个决策树拟合数据集的各个子样本，使用平均值提高精度和控制过拟合。

随机森林模型

from sklearn.ensemble import RandomForestClassifier

def RandomForestClassifier(
	n_estimateors ,#决策树的个数，数量太少欠拟合，数量太多性能欠佳
	criterion,#节点的划分标准
	max_depth,#决策树的最大深度
	min_sample_split,#内部节点可分的最小样本数，默认为2
	min_sample_leaf,#叶结点的末端含有的最少样本
	min_weight_fraction_leaf,
	max_features,#构建最优模型考虑的最大特征数，{’auto','sqrt','log2'}可选，默认auto
	max_leaf_nodes,#最大叶子节点数
	min_impurity_decrease,
	min_impurity_split,
	bootstrap=True,#是否对数据集放回抽样来构建决策树,默认放回
	oob_score=False,#是否使用袋子外的评估模型的好坏，袋子外的样本是指在某次的样本中没有选中的数据，只有使用bootstrap=True，才有袋子外的数据
	n_jobs,
	random_state,
	verbose=0,
	warm_start=False,
)

随机森林方法同逻辑回归方法

Int[1]:rf = RandomForestClassifier().fit(X_train,y_train)
Int[2]:print('训练集的得分:{:.3f}'.format(rf.score(X_train,y_train))
Out[3]:训练集的得分:1.000

#决策树的最大深度
Int[1]:rf2 = RandomForestClassifier(max_depth=5).fit(X_train,y_train)
Int[2]:print('训练集的得分:{:.3f}'.format(rf2.score(X_train,y_train)))
Out[3]:训练集的得分:0.871

模型预测结果

#输出模型预测结果
Int[1]:lr.predict(X_train)#训练集样本的预测标签
Out[2]:array([1, 0, 0, 1, 1, 0,0,
 			 0, 1, 0, 0, 0, 0,
 			 0, 0,0, 0, 1, 0,
 			 ...,
 			 0, 0, 1, 0, 0, 0], dtype=int64)
       
Int[3]:lr.predict_proba(X_train)
Out[4]:array([[0.08221263, 0.91778737],#第一个乘客预测为死亡的0.08，预测存活的为0.91
       [0.78688647, 0.21311353],
       [0.79563833, 0.20436167],
       ...,
       [0.54987567, 0.45012433],
       [0.69985055, 0.30014945],
       [0.87427156, 0.12572844]])

模型评估

1 交叉验证方法

交叉验证是一种评估泛化性能的统计学方法，它比单次划分训练集和测试集的方法更加稳定、全面。因为在交叉验证中，数据会被多次划分，并且需要训练多个模型。k_折交叉验证是最常用的交叉验证，k是由用户指定的数字。

data = pd.read_csv('clear_data.csv')#读取清洗数据
train = pd.read_csv('train.csv')    #读取原始数据
X = data
y =train['Survived']
X_train,X_test,y_train,y_test = train_test_split(X,y,stratify = y,random_state = 42)
#默认数据的75%为训练集，25%为测试集，划分了一次，数据的划分存在偶然性，万一测试集的25%更适合训练呢
# 为了避免这种偶然性，使用交叉验证

#交叉验证模块
from sklearn.model_selection import cross_val_score

cross_val_score(estimator,#用来训练数据的模型（逻辑回归、随机森林等）
				X,#用来训练的数据
				y,#数据的标签，默认不填（监督学习除外）
				groups=None,
				scoring=None,#指定评分标准
				cv=None,   #交叉验证方法
				n_jobs=None,
				verbose=0,
				fit_params=None,#传递给估计器的拟合方法的参数
				pre_dispatch='2*n_jobs',#控制并行执行期间调度的作业数量
				error_score=nan,#发生错误要分配的值
				)

示例

Int[1]:lr = LogisticRegression()#逻辑回归模型
Int[2]:score = cross_val_score(lr,X_train,y_train,cv=10)
Int[3]:score.mean()#平均值
Out[4]:0.794911804613297

2 混淆矩阵

混淆矩阵：计算二分类问题的（把多元分类的混淆矩阵二分化），评估分类问题的准确性的

from sklearn.metrics import confusion_matrix#混淆矩阵模块

confusion_matrix(y_true,#正确标签
				y_pred,#分类器的预测结果
				labels,#调整标签的顺序或者选择子集，默认数字标签升序排列，英文标签按首字母顺序排列
				sample_weight,#样本权重
				normalize#标准化，{‘true','pred','all'}可选
				)

示例1

Int[1]:y_true = ['cat','ant','cat','cat','ant','bird']
Int[1]:y_pred = ['ant','ant','cat','cat','ant','cat']
Int[1]:confusion_matrix(y_true,y_pred,labels=['ant','bird','cat'])
Out[2]:array([[2,0,0],#每一行：实际的类别；每一列：预测的类别
			[0,0,1],#第一行蚂蚁实际的数量，第一列预测蚂蚁的数量
			[1,0,2]])

示例2

Int[1]:lr = LogisticRegression().fit(X_train,y_train)
Int[1]:y_pred = lr.predict(X_train)
Int[1]:confusion_matrix(y_train,y_pred,labels=[0,1])
Out[2]:array([[357,55],#逻辑回归模型成功预测了357死亡人数，55人被错误预测为幸村乘客
			[79,177]])# 幸存乘客中177人被正确预测为幸村乘客，79人被错误预测

3 精确率、召回率

准确率：度量的是被预测为正例的样本中有多少是真正的正类
$$Accuracy=\frac{TP+TN}{TP+TN+FP+FN}=\frac{正确预测}{总样本}$$
精确率：
$$Precision=\frac{TP}{TP+FP}=\frac{真的}{预测为真的}$$
召回率：度量的是正类样本中有多少被预测为正类
$$Recall=\frac{TP}{TP+FN}=\frac{真的}{实际为真的}$$
F1-score : 精确率和召回率的调和平均数(两者发生冲突时)
$$F1?score=2\frac{Precision?Recall}{Precision+Recall}$$

from sklearn.metrics import classification_report#精确率等所在模块

classification_report(y_true,#实际标签
					y_pred,#预测标签
					labels,
					target_names,#报告中显示想要的标签的替代名
					sample_weight,
					digits，
					output_dict，
					zero_division		
)

示例：

Int[1]:lr = LogisticRegression().fit(X_train,y_train)
Int[1]:y_pred = lr.predict(X_train)
Int[1]:print(classification_report(y_train,y_pred))
Out[2]:              precision    recall  f1-score   support

           0       0.82      0.87      0.84       412
           1       0.77      0.69      0.73       256

    accuracy                           0.80       668
   macro avg       0.79      0.78      0.79       668
weighted avg       0.80      0.80      0.80       668

4 ROC曲线

ROC曲线是由一次次的预测结果组成的，每个点代表一个分类器的结果。曲线越凸越好，曲线越偏向对角线，预测效果越不好。
如果训练多次会得到多个混淆矩阵，得到多个预测结果，ROC曲线方便显示对比。

#参数
from sklearn.metrics import roc_curve

roc_curve(y_true,#实际标签，默认{-1，1}或{0，1}，如果不是用pos_label标签定义
				y_score,#每个样本的预测分类，分数代表正数的概率估计或者置信度或某些分类器的decision_function的方法得到的非边界值度量
				pos_label,#指定正类标签
				sample_weight,
				drop_intermediate,
				)

#参数
from sklearn.metrics import plot_roc_curve  #相比roc_curve,该函数不用人工计算
plot_roc_curve(estimator,#分类器的名字
				X,
				y,
				sample_weight,
				drop_intermediate,
				response_method,#从{’predict_proba',decision_function','auto'}中得到每个样本的预测分数，默认default='auto',即predict_proba
				name,#给roc曲线取名
				ax,#多个roc曲线用ax参数叠加
				pos_label
				)

示例：

from sklearn.metrics import plot_roc_curve
lr = LogisticRegression().fit(X_train,y_train)
lr1 = LogisticRegression(C=1000).fit(X_train,y_train)
lr2 = LogisticRegression(class_weight = 'balanced').fit(X_train,y_train)
lr_display = plot_roc_curve(lr,X_test,y_test,name='LR',response_method = 'decision_function')
plot_roc_curve(lr1,X_test,y_test,name='LR1',response_method = 'decision_function',ax=lr_display.ax_)
plot_roc_curve(lr2,X_test,y_test,name='LR2',response_method = 'decision_function',ax=lr_display.ax_)

sklearn

Sklearn是基于python的机器学习工具。再sklearn里面由溜达任务模块：分类、回归、聚类、降维、模型选择、预处理。

分类

from sklearn import SomeClassifier	#估计器，实际问题名称具体化
from sklearn.linear_model import SomeClassifier	
from sklearn.ensemble import SomeClassifier

回归

from sklearn import SomeRegressor	
from sklearn.linear_model import SomeRegressor	
from sklearn.ensemble import SomeRegressor

聚类

from sklearn.cluster import SomeModel

降维

from sklearn.decomposition import SomeModel

模型选择

from sklearn.model_selection import SomeModel

预处理

from sklearn.preprocessing import SomeModel