第2章 数据获取

数据获取手段：

• 数据仓库
• 监测与抓取
• 填写、埋点、日志
• 计算

数据仓库

将所有业务数据经汇总处理，构成数据仓库（DW）

• 全部事实的记录
• 部分维度与数据的整理（数据集市-DM）

数据库 VS 仓库

• 数据库面向业务存储，仓库面向主题存储
  （主题：较高层次上对分析对象数据的一个完整并且一致的描述）
• 数据库针对应用（OLTP），仓库针对分析（OLAP）
• 数据库组织规范，仓库可能冗余，相对变化大，数据量大

监测与抓取

常用工具：
urllib、requests、scrapy
PhantomJS、beautifulSoup、Xpath

填写、埋点、日志

• 用户填写信息
• APP或网页埋点（特点流程的信息记录点）
• 操作日志

计算

通过已有数据计算生成衍生数据

数据学习网站

• 数据竞赛网站（Kaggle&天池）
• 数据集网站（ImageNet/Open Images）
• 统计数据（统计局、政府机关、公司财报等）

第3章 探索性数据分析（单因子&对比）与可视化

理论铺垫

• 集中趋势：均值、中位数与分位数、众数
• 离中趋势：标准差、方差
• 数据分布：偏态与峰态、正态分布与三大分布
  偏态系数：数据平均值偏离状态的衡量
  峰态系数：数据分布集中强度的衡量
• 抽样定理：抽样误差、抽样精度

数据分类

• 定类（类别）：根据事物离散、无差别属性进行的分类，如：名族
• 定序（顺序）：可以界定数据的大小，但不能测定差值：如：收入的低、中、高
• 定距（间隔）：可以界定数据大小的同时，可测定差值，但无绝对零点，如：温度
• 定比（比率）：可以界定数据大小，可测定差值，有绝对零点

单属性分析

• 异常值分析：离散异常值，连续异常值，常识异常值
• 对比分析：绝对数与相对数，时间、空间、维度比较
• 结构分析：各组成部分的分布与规律
• 分布分析：数据分布频率的显式分析

例：对HR.csv进行分析

#satisfaction_level 的分析
import numpy as np
import pandas as pd

df = pd.read_csv("./data/HR.csv")
#先提取出该列数据
sl_s = df["satisfaction_level"]
# 先看看有没有异常值NaN
print(sl_s[sl_s.isnull()])
#看一下改行所有数据
print(df[df['satisfaction_level'].isnull()])
#丢弃异常值
sl_s = sl_s.dropna()

sl_s.mean()     #均值
sl_s.std()      #标准差
sl_s.quantile(q=0.25)    #下四分位数
sl_s.skew()     #偏度
sl_s.kurt()     #峰度

#获取离散化分布
print(np.histogram(sl_s.values,bins=np.arange(0.0,1.1,0.1)))
#输出：(array([ 195, 1214,  532,  974, 1668, 2146, 1973, 2074, 2220, 2004]), array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ]))

#number_project 的分析
#静态结构分析
import pandas as pd

df = pd.read_csv("./data/HR.csv")
#先提取出该列数据
np_s = df["number_project"]
print(np_s.describe())
print("偏度\t",np_s.skew(),"峰度\t",np_s.kurt())

#计算样本出现次数
print(np_s.value_counts())
#获得构成、比例
print(np_s.value_counts(normalize=True))
#排序
print(np_s.value_counts(normalize=True).sort_index())

#简单对比分析操作
import pandas as pd

df = pd.read_csv("./data/HR.csv")
#先剔除异常值
#剔除空值 axis=0表示行，1表示列， how=any表示任意为空
df = df.dropna(axis=0,how="any")
df = df[df["last_evaluation"]<=1][df["salary"]!="nme"][df["department"]!="sale"]

#以部门为单位进行简单对比分析
print(df.groupby("department").mean())
#单独拉出某一列来分析
print(df.loc[:,["last_evaluation","department"]].groupby("department").mean())
#自己定义函数进行对比, 计算极差
print(df.loc[:,["average_monthly_hours","department"]].groupby("department")["average_monthly_hours"].apply(lambda x:x.max()-x.min()))

可视化分析

可视化工具：matplotlib、seaborn、plotly

#基本图形绘制
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt

df = pd.read_csv("./data/HR.csv")
print(df["salary"].value_counts())
#用seaborn改变样式
sns.set_style(style="darkgrid")
sns.set_palette("summer")
#直接用seaborn绘制，用hue还可以进行多层绘制
sns.countplot(x="salary",hue="department",data=df)

#柱状直方图
plt.title("SALARY")
plt.xlabel("salary")
plt.ylabel("Number")
plt.xticks(np.arange(len(df["salary"].value_counts())),df["salary"].value_counts().index)
plt.axis([-0.5,4,0,8000]) #设置显示范围
plt.bar(np.arange(len(df["salary"].value_counts())),df["salary"].value_counts(),width=0.5)
#标注值
for x,y in zip(np.arange(len(df["salary"].value_counts())),df["salary"].value_counts()):
    plt.text(x,y,y,ha="center",va="bottom")
plt.show()

#直方图
f = plt.figure()
f.add_subplot(1,3,1)
sns.distplot(df["satisfaction_level"],bins=10)
f.add_subplot(1,3,2)
sns.distplot(df["last_evaluation"],bins=10)
f.add_subplot(1,3,3)
sns.distplot(df["average_monthly_hours"],bins=10)
plt.show()

#折线图
# sub_df = df.groupby("time_spend_company").mean()
# sns.pointplot(sub_df.index,sub_df["left"])
sns.pointplot(x="time_spend_company",y="left",data=df)

#饼图
lbs = df["department"].value_counts().index
explodes = [0.1 if i == "sales" else 0 for i in lbs]
plt.pie(df["department"].value_counts(normalize=True),labels=lbs,explode=explodes)
plt.show()

第4章 探索性数据分析（多因子与复合分析）

理论铺垫

• 假设检验与方差检验
• 相关系数：皮尔逊、斯皮尔曼
• 回归：线性回归
• 主成分分析（PCA）与奇异值分解（SVD）

主成分分析（PCA）步骤

• 求特征协方差矩阵
• 求协方差的特征值和特征向量
• 将特征值从大到小排序，选择其中最大的k个
• 将样本店投影到选取的特征向量上

编码实现

import numpy as np
import scipy.stats as ss

#生成标准正态分布
norm_dist = ss.norm.rvs(size=20)
print(norm_dist)
#检测正态分布
print(ss.normaltest(norm_dist))

#Python实现卡方检验, 结果依次为（检验统计量，P值，自由度，理论分布）
print(ss.chi2_contingency([[15,95],[85,5]]))

#独立t分布检验,结果依次为（检验统计量，P值）
print(ss.ttest_ind(ss.norm.rvs(size=10),ss.norm.rvs(size=20)))

#方差检验
print(ss.f_oneway([49,50,39,40,43],[28,32,30,26,34],[38,40,45,42,48]))

#使用qq图对比观察一个分布是否符合一个已知的分布，如：横轴为正态分布分位数，纵轴为观察分布的值，得到的散点图，如果和xy周的角平分线重合则符合分布
from statsmodels.graphics.api import qqplot
from matplotlib import pyplot as plt
plt.show(qqplot(ss.norm.rvs(size=100))) #默认检验是否为正态分布

#相关系数
import pandas as pd
s1 = pd.Series([0.1,0.2,1.1,2.4,1.3,0.3,0.5])
s2 = pd.Series([0.5,0.4,1.2,2.5,1.1,0.7,0.1])
#直接求相关系数
print(s1.corr(s2))
#也可以指定方法
print(s1.corr(s2,method="spearman"))
#使用dataframe直接进相关系数的计算，因为dataframe是针对于列计算，所以需要转换
df = pd.DataFrame(np.array([s1,s2]).T)
print(df.corr())
print(df.corr(method="spearman"))

#回归
x = np.arange(10).astype(np.float).reshape([10,1])
y = x*3 + 4 +np.random.random((10,1))
from sklearn.linear_model import LinearRegression
reg = LinearRegression() #构建线性回归
res = reg.fit(x,y) #拟合
y_pred = reg.predict(x)
print("预测测结果：\n",y_pred,"\n参数：",res.coef_,"截距：",res.intercept_)

#主成分分析（PCA）
data = np.array([np.array([2.5,0.5,2.2,1.9,3.1,2.3,2,1,1.5,1.1]),np.array([2.4,0.7,2.9,2.2,3,2.7,1.6,1.1,1.6,0.9])]).T
print(data)
#注：sklearn里用PCA的是奇异值分解
from sklearn.decomposition import PCA
lower_dim = PCA(n_components=1)
lower_dim.fit(data)
print("降维后信息量：",lower_dim.explained_variance_ratio_,"\n转换后： ",lower_dim.fit_transform(data))

复合分析

• 交叉分析
• 因子分析
• 分组与钻取
• 聚类、相关、回归（暂略）

交叉分析：除了纵向分析横向分析外，可以使用 交叉分析 分析数据属性和属性的关系

#实例：查看各个部门离职率之间是否有明显差异
#使用独立t检验方法，两两间求t检验统计量并求出p值,得到各个部门离职分布

import pandas as pd
import numpy as np
import scipy.stats as ss
import matplotlib.pyplot as plt
import seaborn as sns

df = pd.read_csv("./data/HR.csv")
dp_indices = df.groupby(by="department").indices    #按部门分组，用indices得到索引
sales_values = df["left"].iloc[dp_indices["sales"]].values
technical_values = df["left"].iloc[dp_indices["technical"]].values
print(ss.ttest_ind(sales_values,technical_values))  #打印p统计量

#两两求p值,热力图
dp_keys = list(dp_indices.keys()) #取出indices的keys
dp_t_mat = np.zeros([len(dp_keys),len(dp_keys)])    #初始化矩阵
for i in range(len(dp_keys)):
   for j in range(len(dp_keys)):
       p_value = ss.ttest_ind(df["left"].iloc[dp_indices[dp_keys[i]]].values,\
                              df["left"].iloc[dp_indices[dp_keys[j]]].values)[1]
       if p_value<0.05:
           dp_t_mat[i][j]=-1
       else:
           dp_t_mat[i][j] = p_value
print(dp_t_mat)
sns.heatmap(dp_t_mat,xticklabels=dp_keys,yticklabels=dp_keys)
plt.show()

#透视表
piv_tb = pd.pivot_table(df,values="left",index=["promotion_last_5years","salary"],columns=["Work_accident"],aggfunc=np.mean)
sns.heatmap(piv_tb,vmin=0,vmax=1,cmap=sns.color_palette("Reds"))
plt.show()

分组与钻取
钻取是改变数据维度层次，变换分析粒度的过程，可分为向下和向上钻取。
连续属性在分组前需要进行离散化。
连续分组：

• 分割（一阶差分）、拐点（二阶差分）
• 聚类
• 不纯度（Gini系数）

#实例：分组分析
import pandas as pd
import scipy.stats as ss
import matplotlib.pyplot as plt
import seaborn as sns

sns.set_context(font_scale=1.5)
df = pd.read_csv("./data/HR.csv")
#离散值：
#设置hue向下根据部门钻取
# sns.barplot(x="salary",y="left",hue="department",data=df)
# plt.show()

#连续值
sl_s = df["satisfaction_level"]
sns.barplot(list(range(len(sl_s))),sl_s.sort_values())
plt.show()

相关分析

#实例：相关分析
import pandas as pd
import scipy.stats as ss
import matplotlib.pyplot as plt
import seaborn as sns
import math

sns.set_context(font_scale=1.5)
df = pd.read_csv("./data/HR.csv")

#计算相关技术，画相关图（会自动去除离散属性）
sns.heatmap(df.corr(),vmax=1,vmin=-1,cmap=sns.color_palette("RdBu",n_colors=128))
plt.show()

#离散情况下：

#Gini
def getGini(a1, a2):
    assert (len(a1) == len(a2))
    d = dict()
    for i in list(range(len(a1))):
        d[a1[i]] = d.get(a1[i], []) + [a2[i]]
    return 1 - sum([getProbSS(d[k]) * len(d[k]) / float(len(a1)) for k in d])
#可能性平方和
def getProbSS(s):
    if not isinstance(s,pd.core.series.Series):
        s = pd.Series(s)
    prt_ary = np.array(pd.groupby(s, by=s).count().values / float(len(s)))
    return sum(prt_ary ** 2)
#熵
def getEntropy(s):
    if not isinstance(s, pd.core.series.Series):
        s = pd.Series(s)
    prt_ary = np.array(pd.groupby(s, by=s).count().values / float(len(s)))
    return -(np.log2(prt_ary) * prt_ary).sum()
#条件熵
def getCondEntropy(a1, a2):
    assert (len(a1) == len(a2))
    d = dict()
    for i in list(range(len(a1))):
        d[a1[i]] = d.get(a1[i], []) + [a2[i]]
    return sum([getEntropy(d[k]) * len(d[k]) / float(len(a1)) for k in d])
#熵增益
def getEntropyGain(a1, a2):
    return getEntropy(a2) - getCondEntropy(a1, a2)
#熵增益率
def getEntropyGainRatio(a1, a2):
    return getEntropyGain(a1, a2) / getEntropy(a2)
#相关度
def getDiscreteRelation(a1, a2):
    return getEntropyGain(a1, a2) / math.sqrt(getEntropy(a1) * getEntropy(a2))


#离散相关性度量
s1 = pd.Series(["X1", "X1", "X2", "X2", "X2", "X2"])
s2 = pd.Series(["Y1", "Y1", "Y1", "Y2", "Y2", "Y2"])
print(getEntropy(s1))
print(getEntropy(s2))
print(getCondEntropy(s1, s2))
print(getCondEntropy(s2, s1))
print(getEntropyGain(s1, s2))
print(getEntropyGain(s2, s1))
print(getEntropyGainRatio(s1, s2))
print(getEntropyGainRatio(s2, s1))
print(getDiscreteRelation(s1, s2))
print(getDiscreteRelation(s2, s1))

因子分析

第5章 预处理理论

数据清洗

数据样本抽样

• 样本要具有代表性
• 样本比例要平衡以及样本不均衡时如何处理
• 考虑全量数据

异常值（空值）处理

• 识别异常值和重复值
  Pandas：isnull()/duplicated()
• 直接丢弃（包括重复数据）
  Pandas：drop()/dropna()/drop_duplicated()
• 把异常当作一个新的属性，替代原值
  Pandas：fillna()
• 集中值指代
  Pandas：fillna()
• 边界值指代
  Pandas：fillna()
• 插值
  Pandas：interpolate() --- Series

df = pd.DataFrame({"A": ["a0", "a1", "a1", "a2", "a3", "a4"], "B": ["b0", "b1", "b2", "b2", "b3", None],
                   "C": [1, 2, None, 3, 4, 5], "D": [0.1, 10.2, 11.4, 8.9, 9.1, 12], "E": [10, 19, 32, 25, 8, None],
                   "F": ["f0", "f1", "g2", "f3", "f4", "f5"]})
df.isnull() #去除空值
df.dropna(subset=["B","C"]) #指定去除某一行的空值
df.duplicated(["A"],keep="first")   #重复值，keep设定保留值
df.drop_duplicates(["A","B"],keep="first",inplace=False)    #AB同时重复
df["B"].fillna("b*")    #异常值替换
df["E"].fillna(df["E"].mean())
df["E"].interpolate(method="spline",order=3)    #插值
pd.Series([1, None, 4, 10, 8]).interpolate()
#四分位数法过滤
df[df['D'] < df["D"].quantile(0.75) + 1.5 * (df["D"].quantile(0.75) - df["D"].quantile(0.25))][df["D"] > df["D"].quantile(0.25) - 1.5 * (df["D"].quantile(0.75) - df["D"].quantile(0.25))]
df[[True if item.startswith("f") else False for item in list(df["F"].values)]]

特征预处理

标注（label）

• 特征选择
• 特征变换
• 特征降维
• 特征衍生

一、特征选择：剔除与标注不相关或冗余的特征

思路：过滤思想、包裹思想、嵌入思想

#例：特征选择
import pandas as pd
import numpy as np
import scipy.stats as ss
from sklearn.feature_selection import SelectKBest,RFE,SelectFromModel
from sklearn.svm import SVR
from sklearn.tree import DecisionTreeRegressor

def main():
    df=pd.DataFrame({"A":ss.norm.rvs(size=10),"B":ss.norm.rvs(size=10),\
                     "C":ss.norm.rvs(size=10),"D":np.random.randint(low=0,high=2,size=10)})
    X=df.loc[:,["A","B","C"]]   #特征
    Y=df.loc[:,"D"]     #标注
    print("X",X)
    print("Y",Y)
    #过滤思想
    skb=SelectKBest(k=2)
    skb.fit(X.values,Y.values)
    print(skb.transform(X.values))
    #包裹思想
    rfe=RFE(estimator=SVR(kernel="linear"),n_features_to_select=2,step=1)
    print(rfe.fit_transform(X,Y))
    #嵌入思想
    sfm=SelectFromModel(estimator=DecisionTreeRegressor(),threshold=0.01)
    print(sfm.fit_transform(X,Y))
if __name__=="__main__":
    main()

二、特征变换：对指化、离散化、数据平滑、归一化、数值化、正规化

离散化：将连续变量分成几段（bins）
原因：克服数据缺陷、某些算法要求、非线数据映射
方法：等频、等距、自因变量优化

离散化（分箱）：
深度：数的个数
宽度：数的区间

#数据分箱
import pandas as pd

lst = [6, 8, 10, 15, 16, 24, 25, 40, 67]
#等深分箱
x = pd.qcut(lst,q=3,labels=["low","medium","high"])
print(x)

#等宽分箱
x = pd.cut(lst,bins=3,labels=["low","medium","high"])
print(x)

归一化与标准化

import numpy as np
from sklearn.preprocessing import MinMaxScaler,StandardScaler

print(MinMaxScaler().fit_transform(np.array([1, 4, 10, 15, 21]).reshape(-1, 1)))
print(StandardScaler().fit_transform(np.array([1, 1, 1, 1, 0, 0, 0, 0]).reshape(-1, 1)))
print(StandardScaler().fit_transform(np.array([1, 0, 0, 0, 0, 0, 0, 0]).reshape(-1, 1)))

数值化
定类：标签化
定序：独热

import numpy as np

#标签化与独热编码
from sklearn.preprocessing import LabelEncoder,OneHotEncoder
print(LabelEncoder().fit_transform(np.array(["Down","Down","Up","Down","Up"]).reshape(-1,1)))
print(LabelEncoder().fit_transform(np.array(["Low","Medium","Low","High","Medium"]).reshape(-1,1)))

lb_encoder=LabelEncoder()
lb_trans_f=lb_encoder.fit_transform(np.array(["Red","Yellow","Blue","Green"]))
print(lb_trans_f)

oht_enoder=OneHotEncoder().fit(lb_trans_f.reshape(-1,1))
print(oht_enoder.transform(lb_encoder.transform(np.array(["Red","Blue"])).reshape(-1,1)).toarray())

正规化
1、直接用在特征上
2、用在每个对象的各个特征的表示（特征矩阵的行）
3、模型的参数上（回归模型使用较多）

import numpy as np

# 规范化
from sklearn.preprocessing import Normalizer

print(Normalizer(norm="l1").fit_transform(np.array([[1, 1, 3, -1, 2]])))
print(Normalizer(norm="l2").fit_transform(np.array([[1, 1, 3, -1, 2]])))

三、特征降维

• PCA、奇异值分解等线性降维
• LDA降维

LDA：线性判别式分析
核心思想：投影变化后同一标注内距离尽可能小；不同标注间距离尽可能大

import numpy as np
# LDA降维
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis

X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]])
y = np.array([0, 0, 0, 1, 1, 1])
clf = LinearDiscriminantAnalysis()
print(clf.fit_transform(X,y))
#当做分类器
clf.fit(X, y)
print(clf.predict([[-0.8, -1]]))

四、特征衍生

• 加减乘除
• 求导与高阶求导
• 人工归纳

实例：HR表的特征处理

第6章 挖掘建模

• 训练集：用来训练与拟合模型
• 测试集：模型泛化能力的考量，泛化：对数据的预测能力
• 验证集：当通过训练集训练出多个模型后，使用验证集数据纠偏或比较预测
  K-fold交叉验证：将数据集分成K份，每份轮流作一遍测试集，其他作训练集

#用train_test_split划分训练集、测试集、验证集
from sklearn.model_selection import train_test_split
f_v=features.values
f_names=features.columns.values
l_v=label.values
#验证集占20%
X_tt,X_validation,Y_tt,Y_validation=train_test_split(f_v,l_v,test_size=0.2)
#训练集占60%，测试集占20%
X_train,X_test,Y_train,Y_test=train_test_split(X_tt,Y_tt,test_size=0.25)

步骤如下：
1）算距离：给定测试对象，计算它与训练集中的每个对象的距离
2）找邻居：圈定距离最近的k个训练对象，作为测试对象的近邻
3）做分类：根据这k个近邻归属的主要类别，来对测试对象分类

#KNN 算法演示
import pandas as pd
from sklearn.preprocessing import MinMaxScaler,StandardScaler
from sklearn.preprocessing import LabelEncoder,OneHotEncoder
from sklearn.decomposition import PCA

#sl:satisfaction_level---False:MinMaxScaler;True:StandardScaler
#le:last_evaluation---False:MinMaxScaler;True:StandardScaler
#npr:number_project---False:MinMaxScaler;True:StandardScaler
#amh:average_monthly_hours--False:MinMaxScaler;True:StandardScaler
#tsc:time_spend_company--False:MinMaxScaler;True:StandardScaler
#wa:Work_accident--False:MinMaxScaler;True:StandardScaler
#pl5:promotion_last_5years--False:MinMaxScaler;True:StandardScaler
#dp:department--False:LabelEncoding;True:OneHotEncoding
#slr:salary--False:LabelEncoding;True:OneHotEncoding

def hr_preprocessing(sl=False,le=False,npr=False,amh=False,tsc=False,wa=False,pl5=False,dp=False,slr=False,lower_d=False,ld_n=1):
    df=pd.read_csv("./data/HR.csv")

    #1、清洗数据
    df=df.dropna(subset=["satisfaction_level","last_evaluation"])
    df=df[df["satisfaction_level"]<=1][df["salary"]!="nme"]

    #2、得到标注
    label = df["left"]
    df = df.drop("left", axis=1)

    #3、特征选择
    #4、特征处理
    scaler_lst=[sl,le,npr,amh,tsc,wa,pl5]
    column_lst=["satisfaction_level","last_evaluation","number_project",\
                "average_monthly_hours","time_spend_company","Work_accident",\
                "promotion_last_5years"]
    for i in range(len(scaler_lst)):
        if not scaler_lst[i]:
            df[column_lst[i]]=\
                MinMaxScaler().fit_transform(df[column_lst[i]].values.reshape(-1,1)).reshape(1,-1)[0]
        else:
            df[column_lst[i]]=\
                StandardScaler().fit_transform(df[column_lst[i]].values.reshape(-1,1)).reshape(1,-1)[0]

    scaler_lst=[slr,dp]
    column_lst=["salary","department"]
    for i in range(len(scaler_lst)):
        if not scaler_lst[i]:
            if column_lst[i]=="salary":
                df[column_lst[i]]=[map_salary(s) for s in df["salary"].values]
            else:
                df[column_lst[i]]=LabelEncoder().fit_transform(df[column_lst[i]])
            df[column_lst[i]]=MinMaxScaler().fit_transform(df[column_lst[i]].values.reshape(-1,1)).reshape(1,-1)[0]

        else:
            df=pd.get_dummies(df,columns=[column_lst[i]])
    if lower_d:
        return PCA(n_components=ld_n).fit_transform(df.values),label
    return df,label

d=dict([("low",0),("medium",1),("high",2)])

def map_salary(s):
    return d.get(s,0)

def hr_modeling(features,label):
    # 用train_test_split划分训练集、测试集、验证集
    from sklearn.model_selection import train_test_split
    f_v=features.values
    l_v=label.values
    #验证集占20%
    X_tt,X_validation,Y_tt,Y_validation=train_test_split(f_v,l_v,test_size=0.2)
    #训练集占60%，测试集占20%
    X_train,X_test,Y_train,Y_test=train_test_split(X_tt,Y_tt,test_size=0.25)

    #KNN
    from sklearn.neighbors import NearestNeighbors,KNeighborsClassifier
    knn_clf = KNeighborsClassifier(n_neighbors=3)   #设置k=3个邻居
    knn_clf.fit(X_train,Y_train)    #拟合
    Y_pred = knn_clf.predict(X_validation)      #验证

    #衡量指标 准确率、召回率、F值
    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))

    #模型存储
    from sklearn.externals import joblib
    joblib.dump(knn_clf,"knn_clf")  #存储
    knn_clf = joblib.load("knn_clf")    #使用
    Y_pred = knn_clf.predict(X_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))

def main():
    features,label=hr_preprocessing()
    hr_modeling(features,label)

if __name__=="__main__":
    main()

#为方便调用，可以使用models[]列表统一管理模型
def hr_modeling(features,label):
    # 用train_test_split划分训练集、测试集、验证集
    from sklearn.model_selection import train_test_split
    f_v=features.values
    l_v=label.values
    #验证集占20%
    X_tt,X_validation,Y_tt,Y_validation=train_test_split(f_v,l_v,test_size=0.2)
    #训练集占60%，测试集占20%
    X_train,X_test,Y_train,Y_test=train_test_split(X_tt,Y_tt,test_size=0.25)

    #衡量指标：准确率、召回率、F值
    from sklearn.metrics import accuracy_score, recall_score, f1_score

    #KNN
    from sklearn.neighbors import NearestNeighbors,KNeighborsClassifier
    #为以后调用方便，可以建立models列表，将模型统一管理
    models=[]
    models.append(("KNN",KNeighborsClassifier(n_neighbors=3)))

    for clf_name,clf in models:
        clf.fit(X_train,Y_train)
        #xy_lst[i]:0训练集、1验证集、2测试集
        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)
            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))

决策树切分方法

• 信息增益-ID3
• 信息增益率-C4.5
• Gini系数-CART

image.png