四、挖掘建模——分类

训练集、验证集和测试集

• 训练集：用于训练和拟合模型
• 验证集：通过训练集训练出多个模型后，使用验证集数据来寻找模型得最佳参数
• 测试集：模型泛化能力的考量（泛化指的是对未知数据的预测能力）

#划分训练集、验证集和测试集
from sklearn.model_selection import train_test_split
f_v=features.values
l_v=label.values
X_tt,X_validation,Y_tt,Y_valiation=train_test_split(f_v,l_v,test_size=0.2)#训练集，验证集
X_train,X_test,Y_train,Y_test=train_test_split(X_tt,Y_tt,test_size=0.25)#将训练集分为训练集和测试集
print(len(X_train),len(X_validation),len(X_test))

分类

1.KNN(K-Nearest Neighbors)

1)距离(欧式距离，曼哈顿距离，闵科夫斯基距离)
2)KD-Tree
主要思想：一未知的点，找其最近邻的K个点，K个点中属于标注1的点大于属于标注2的点，则未知的点属于标注1

#KNN
#1.确定参数，由指标可知参数为3时更好
from sklearn.neighbors import NearestNeighbors,KNeighborsClassifier
knn_clf=KNeighborsClassifier(n_neighbors=3)
#knn_clf_n5=KNeighborsClassifier(n_neighbors=5)
knn_clf.fit(X_train,Y_train)#拟合得到模型
#knn_clf_n5.fit(X_train,Y_train)
Y_pred=knn_clf.predict(X_validation)
#Y_pred_n5=knn_clf_n5.predict(X_validation)
#衡量指标
from sklearn.metrics import accuracy_score,recall_score,f1_score
print('ACC:',accuracy_score(Y_validation,Y_pred))
print('REC:',recall_score(Y_validation,Y_pred))
print('F-Score:',f1_score(Y_validation,Y_pred))
#print('ACC:',accuracy_score(Y_validation,Y_pred_n5))
#print('REC:',recall_score(Y_validation,Y_pred_n5))
#print('F-Score:',f1_score(Y_validation,Y_pred_n5))
2.训练集、验证集、测试集的建模结果
from sklearn.neighbors import NearestNeighbors,KNeighborsClassifier
knn_clf=KNeighborsClassifier(n_neighbors=3)
knn_clf.fit(X_train,Y_train)#拟合得到模型
#衡量指标
from sklearn.metrics import accuracy_score,recall_score,f1_score
print('Train:')
Y_pred=knn_clf.predict(X_train)
print('ACC:',accuracy_score(Y_train,Y_pred))
print('REC:',recall_score(Y_train,Y_pred))
print('F-Score:',f1_score(Y_train,Y_pred))
Y_pred=knn_clf.predict(X_validation)
print('Validation:')
print('ACC:',accuracy_score(Y_validation,Y_pred))
print('REC:',recall_score(Y_validation,Y_pred))
print('F-Score:',f1_score(Y_validation,Y_pred))
Y_pred=knn_clf.predict(X_test)
print('Test:')
print('ACC:',accuracy_score(Y_test,Y_pred))
print('REC:',recall_score(Y_test,Y_pred))
print('F-Score:',f1_score(Y_test,Y_pred))
##存储模型
from sklearn.externals import joblib
joblib.dump(knn_clf,'knn_clf')#''里面为存储模型的名字
#使用模型
knn_clf=joblib.load('knn_clf')
3.写循环保存多个模型和指标计算
from sklearn.neighbors import NearestNeighbors,KNeighborsClassifier
from sklearn.metrics import accuracy_score,recall_score,f1_score
models=[]
models.append(('KNN',KNeighborsClassifier(n_neighbors=3)))
for clf_name,clf in models:
   clf.fit(X_train,Y_train)
   xy_lst=[(X_train,Y_train),(X_validation,Y_validation),(X_test,Y_test)]
   for i in range(len(xy_lst)):
       X_part=xy_lst[i][0]
       Y_part=xy_lst[i][1]
       Y_pred=clf.predict(X_part)
       print(i)#i=0代表训练集，1代表验证集，2代表测试集
       print(clf_name,'-ACC:',accuracy_score(Y_part,Y_pred))
       print(clf_name,'-REC:',recall_score(Y_part,Y_pred))
       print(clf_name,'-F1:',f1_score(Y_part,Y_pred))

2.朴素贝叶斯

• 概率、条件概率、联合概率、全概率公式、贝叶斯公式
• 特征是离散的，效果好

from sklearn.neighbors import NearestNeighbors,KNeighborsClassifier
from sklearn.metrics import accuracy_score,recall_score,f1_score
from sklearn.naive_bayes import GaussianNB,BernoulliNB  
常用的两种朴素贝叶斯模型：高斯朴素贝叶斯，伯努利朴素贝叶斯
用到的特征必须是离散的，若离散值是0和1时，用伯努利更好，若值为连续，在伯努利算法下，会先将特征二值化
高斯朴素贝叶斯则假设特征是高斯分布的，
朴素贝叶斯算法在离散属性下表现更好
models=[]
models.append(('KNN',KNeighborsClassifier(n_neighbors=3)))
models.append(('GaussianNB',GaussianNB()))
models.append(('BernoulliNB',BernoulliNB()))
for clf_name,clf in models:
    clf.fit(X_train,Y_train)
    xy_lst=[(X_train,Y_train),(X_validation,Y_validation),(X_test,Y_test)]
    for i in range(len(xy_lst)):
        X_part=xy_lst[i][0]
        Y_part=xy_lst[i][1]
        Y_pred=clf.predict(X_part)
        print(i)#i=0代表训练集，1代表验证集，2代表测试集
        print(clf_name,'-ACC:',accuracy_score(Y_part,Y_pred))
        print(clf_name,'-REC:',recall_score(Y_part,Y_pred))
        print(clf_name,'-F1:',f1_score(Y_part,Y_pred))

生成模型：通过求输入与输出的联合概率分布，再求解类别归类的概率（如：朴素贝叶斯）对数据要求高
判别模型：不通过联合概率分布，直接可以获得输出对应最大分类的概率（如：KNN）使用范围广

3.决策树

一个问题是构造决策树时，特征的顺序？
由三个指标来判断：1）信息增益 2）信息增益率 3）Gini系数

from sklearn.metrics import accuracy_score,recall_score,f1_score
from sklearn.tree import DecisionTreeClassifier
models=[]
models.append(('DecisionTree',DecisionTreeClassifier()))#默认是基尼系数的，criterion='entropy'为信息增益的
for clf_name,clf in models:
    clf.fit(X_train,Y_train)
    xy_lst=[(X_train,Y_train),(X_validation,Y_validation),(X_test,Y_test)]
    for i in range(len(xy_lst)):
        X_part=xy_lst[i][0]
        Y_part=xy_lst[i][1]
        Y_pred=clf.predict(X_part)
        print(i)#i=0代表训练集，1代表验证集，2代表测试集
        print(clf_name,'-ACC:',accuracy_score(Y_part,Y_pred))
        print(clf_name,'-REC:',recall_score(Y_part,Y_pred))
        print(clf_name,'-F1:',f1_score(Y_part,Y_pred))
如何看决策树中的更多细节？即把决策树画出来
Graphviz (图的可视化软件)，帮助画出决策树，下载安装Graphviz,在程序中加入环境变量
import os
os.environ['PATH']+=os.pathsep+'D:/Graphviz2.38/bin/'#在程序中加入环境变量
import pydotplus
from sklearn.metrics import accuracy_score,recall_score,f1_score
from sklearn.tree import DecisionTreeClassifier,export_graphviz
from sklearn.externals.six import StringIO #可能会用到的一个包
models=[]
models.append(('DecisionTree',DecisionTreeClassifier()))
for clf_name,clf in models:
    clf.fit(X_train,Y_train)
    xy_lst=[(X_train,Y_train),(X_validation,Y_validation),(X_test,Y_test)]
    for i in range(len(xy_lst)):
        X_part=xy_lst[i][0]
        Y_part=xy_lst[i][1]
        Y_pred=clf.predict(X_part)
        print(i)#i=0代表训练集，1代表验证集，2代表测试集
        print(clf_name,'-ACC:',accuracy_score(Y_part,Y_pred))
        print(clf_name,'-REC:',recall_score(Y_part,Y_pred))
        print(clf_name,'-F1:',f1_score(Y_part,Y_pred))
        dot_data=export_graphviz(clf,out_file=None,feature_names=f_names,class_names=['NL','L'],
                                    filled=True,rounded=True,special_characters=True)
        #当out_file='None'时，dot_data可以直接输出,class_name为标注的名称
        graph=pydotplus.graph_from_dot_data(dot_data)#绘制
        graph.write_pdf('dt_tree.pdf')#输出pdf文件
        后三行可等效为
        dot_data=StringIO()
        export_graphviz(clf,out_file=dot_data,feature_names=f_names,class_names=['NL','L'],
                                    filled=True,rounded=True,special_characters=True）
        graph=pydotplus.graph_from_dot_data(dot_data.getvalue())#绘制
        graph.write_pdf('dt_tree.pdf')#输出pdf文件

4.支持向量机（Support Vector Machine ,SVM）

核函数：线性核函数，多项式核函数，高斯径向基（RBF）核函数

from sklearn.svm import SVC
from sklearn.metrics import accuracy_score,recall_score,f1_score
models=[]
models.append(('SVM Classifier',SVC()))
for clf_name,clf in models:
   clf.fit(X_train,Y_train)
   xy_lst=[(X_train,Y_train),(X_validation,Y_validation),(X_test,Y_test)]
   for i in range(len(xy_lst)):
       X_part=xy_lst[i][0]
       Y_part=xy_lst[i][1]
       Y_pred=clf.predict(X_part)
       print(i)#i=0代表训练集，1代表验证集，2代表测试集
       print(clf_name,'-ACC:',accuracy_score(Y_part,Y_pred))
       print(clf_name,'-REC:',recall_score(Y_part,Y_pred))
       print(clf_name,'-F1:',f1_score(Y_part,Y_pred))

5.集成方法

• 组合多个模型，以获得更好的效果
• 强可学习：多项式学习算法的效果较为明显。弱可学习：不明显
• 集成方法：将几个弱可学习的分类器集合成一个强可学习的分类器的过程
• 集成思想用到的具体方法：袋装法（bagging），将几个不同的分类模型进行独立袋装，然后投票表决，几个子模型是相互独立的，互不影响的。其典型应用：随机森林
              提升法（boost），几个模型加权叠加而成。其典型应用：Adaboost
  1.随机森林
  树的个数、树的特征数、树的训练集
  优点：每个决策树可以并不使用全部特征
     不需要剪枝，即可有效避免过拟合

from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score,recall_score,f1_score
models=[]
 models.append(('OriginalRandomFroest',RandomForestClassifier()))
 #n_estimators决策树的个数，max_features每棵树用到的特征,默认10棵树，
 models.append(('RandomFroest',RandomForestClassifier(n_estimators=80,max_features=None)))#调参查看结果
for clf_name,clf in models:
   clf.fit(X_train,Y_train)
   xy_lst=[(X_train,Y_train),(X_validation,Y_validation),(X_test,Y_test)]
   for i in range(len(xy_lst)):
       X_part=xy_lst[i][0]
       Y_part=xy_lst[i][1]
       Y_pred=clf.predict(X_part)
       print(i)#i=0代表训练集，1代表验证集，2代表测试集
       print(clf_name,'-ACC:',accuracy_score(Y_part,Y_pred))
       print(clf_name,'-REC:',recall_score(Y_part,Y_pred))
       print(clf_name,'-F1:',f1_score(Y_part,Y_pred))

2.Adaboost
优点：精度高，且灵活可调
   几乎不用担心过拟合问题
   简化特征工程流程

from sklearn.ensemble import AdaBoostClassifier
from sklearn.metrics import accuracy_score,recall_score,f1_score
models=[]
models.append(('Adaboost',AdaBoostClassifier()))#
models.append(('Adaboost',AdaBoostClassifier(n_estimators=100))
for clf_name,clf in models:
   clf.fit(X_train,Y_train)
   xy_lst=[(X_train,Y_train),(X_validation,Y_validation),(X_test,Y_test)]
   for i in range(len(xy_lst)):
       X_part=xy_lst[i][0]
       Y_part=xy_lst[i][1]
       Y_pred=clf.predict(X_part)
       print(i)#i=0代表训练集，1代表验证集，2代表测试集
       print(clf_name,'-ACC:',accuracy_score(Y_part,Y_pred))
       print(clf_name,'-REC:',recall_score(Y_part,Y_pred))
       print(clf_name,'-F1:',f1_score(Y_part,Y_pred))