Python3数据分析与挖掘建模实战 笔记

第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

你可能感兴趣的:(Python3数据分析与挖掘建模实战 笔记)