搞数仓也得懂几个常用机器学习算法

作者：数据一哥  来源：数据社

全文共10793个字，建议收藏阅读

 一、理解线性回归模型

首先讲回归模型，回归模型研究的是因变量（目标）和自变量（预测器）之间的关系，因变量可以是连续也可以离散，如果是离散的就是分类问题。思考房价预测模型，我们可以根据房子的大小、户型、位置、南北通透等自变量预测出房子的售价，这是简单的回归模型，在初中里面回归表达式一般这样写，其中x是自变量，y是因变量，w是特征矩阵，b是偏置。

在机器学习推导里面引入线性代数的思想，将假设我们用一个表达式来描述放假预测模型，x代表一个房子的特征集，它是一个n×1的列向量，总共有m个特征集，θ是一个n×1的列向量，是我们想要求得未知数。

我们采用误差小的策略，比如有预测表达式：y工资=Θ1*学历+Θ2*工作经验+Θ3*技术能力+.......+Θn*x+基本工资，预测的y值和实际值y_存有差距，策略函数就是使得m个特征集的（真实值y-预测值）的平方和小。（差值可能是负数，所以采用平方和）；

按照对于正规方程的求法，我们对θ 求偏导：

也就是，给定特征矩阵X和因变量y，即可以求使误差率小的θ值，满足后续的回归模型。了解线性代数的童靴可以看出来问题，在θ的表达式中有求逆运算，需要保证矩阵可逆，这一般是无法保证的，这样就会造成θ无解，策略失效；

二、计算机的做法：梯度下降

常规的方程需要大量的矩阵运算，尤其是矩阵的逆运算，在矩阵很大的情况下，会大大增加计算复杂性。，且正规方程法对矩阵求偏导有一定的局限性（无法保证矩阵可逆），下面介绍梯度下降法，也就是计算机的解决方法，每次走一小步，保证这一小步是有效的一步，可以想象自己正在下山，你不知道目的地（全局小值）在哪，但是你能够保证自己每次走的都是陡峭的一步；

我们的策略仍然保持不变，就是使得m个特征集的（真实值y-预测值）的平方和小：

梯度下降法实现：赋予初始θ 值，并根据公式逐步更新θ 使得J(θ) 不断减少，终至收敛，对应的参数θ 即为解。为了推导方便，首先研究只有一个训练样本时，如何计算推导公式。

θ 的每个分量更新公式为：

推广到m个训练数据，参数更新公式为：

逻辑回归与线性回归同属广义线性模型，逻辑回归是以线性回归为理论支持，是一个二分类模型，也可以推广多到分类问题，通过Sigmoid函数引入了非线性因素，因此可以轻松处理0/1分类问题，首先介绍一下Sigmoid函数：

sigmoid函数图像是一个S曲线，取值在[0, 1]之间，在远离0的地方函数的值会很快接近0或者1，sigmoid函数的求导特性是：

逻辑回归的预测函数是下图，只是在特征到结果的映射中加入了一层函数映射，先把特征线性求和，然后使用函数g(z)将为假设函数来预测。g(z)可以将连续值映射到0到1之间：

通过求似然函数，两边取log后，对θ求偏导：

    这样我们就得到了梯度上升每次迭代的更新方向，那么θ的迭代表达式为：
   

发现同线性回归模型是同一个表达式，这并不仅仅是巧合，两者存在深层的联系；

四、回归模型使用

数据是2014年5月至2015年5月美国King County的房屋销售价格以及房屋的基本信息。数据分为训练数据和测试数据，分别保存在kc_train.csv和kc_test.csv两个文件中，其中训练数据主要包括10000条记录，14个字段：销售日期,销售价格,卧室数,浴室数,房屋面积,停车面积,楼层数,房屋评分,建筑面积,地下室面积,建筑年份,修复年份,纬度,经度。

import pandas as pdfrom pandas import DataFrameimport numpy as npimport matplotlib.pyplot as plt%matplotlib inlineimport seaborn as snsfrom sklearn.linear_model import LogisticRegressionfrom sklearn.ensemble import RandomForestClassifierfrom sklearn.linear_model import LinearRegression# 数据读取baseUrl="C:\\Users\\71781\\Desktop\\2020\\ML-20200422\\houre_price\\"house_df=pd.read_csv(baseUrl+'train.csv' )test_df=pd.read_csv(baseUrl+'test.csv')house_df.head()
# 删除无关变量house_df=house_df.drop(['saleTime','year','repairYear','latitude','longitude','buildingSize'],axis=1)test_df=test_df.drop(['saleTime','year','repairYear','latitude','longitude','buildingSize'],axis=1)
# 模型建立X_price=house_df.drop(['price'],axis=1)# X_price.head()Y_price=house_df['price']Y_price.head()
LR_reg=LinearRegression()LR_reg.fit(X_price, Y_price)Y_pred = LR_reg.predict(test_df)LR_reg.score(X_price, Y_price)

# 可以选择进行特征缩放#new_house=house_df.drop(['price'],axis=1)#from sklearn.preprocessing import MinMaxScaler#minmax_scaler=MinMaxScaler().fit(new_house)   #进行内部拟合，内部参数会发生变化#scaler_housing=pd.DataFrame(minmax_scaler.transform(new_house),columns=new_house.columns)
#mm=MinMaxScaler()#mm.fit(test_df)#scaler_t=mm.transform(test_df)#scaler_t=pd.DataFrame(scaler_t,columns=test_df.columns)

二、熵增益（ID3）

通信层面，信息熵衡量信息的不确定性，信息熵越大表明信息越不准确，可以用信息熵的减少值来衡量信息的价值。在决策树模型中把信息确定性叫做熵增益，有了熵增益后，我们就可以根据熵增益来判断特征值的重要程度，从而选取重要的特征作为次切分，再根据相同的方法用其他特征进行切分，直到得到得到每个划分的叶子节点。信息熵的定义是：

计算各个特征属性的熵增益后，比较哪个熵增益大，就选择该属性做分类特征。

4、剪枝处理

5、鸢尾花(iris)分类模型

import pandas as pdfrom pandas import DataFrameimport numpy as npimport matplotlib.pyplot as plt%matplotlib inlineimport seaborn as snsfrom sklearn.tree import DecisionTreeClassifierfrom sklearn import metrics 
baseUrl="C:\\Users\\71781\\Desktop\\2020\\ML-20200422\\iris\\"iris_df=pd.read_csv(baseUrl+"iris.csv")iris_df.head()iris_df.describe()

 数据分布探索：

# pandas 自带的散点图iris_df.plot(kind="scatter", x="Sepal.Length", y="Sepal.Width")

# seaborn 的联合分布图sns.jointplot(x="Sepal.Length", y="Sepal.Width", data=iris_df, height=5)

# 上面的两个散点图并不能显示每一个点所属的类别# 所以，接下来用 seaborn 的 FacetGrid 函数按照Species花的种类来在散点图上标上不同的颜色，hue英文是色彩的意思。sns.FacetGrid(iris_df, hue="Species", height=5).map(plt.scatter, "Sepal.Length", "Sepal.Width").add_legend()

# 通过箱线图来查看单个特征的分布# 对 Numerical Variable，可以用 Box Plot 来直观地查看不同花类型的分布。sns.boxplot(x="Species", y="Sepal.Length", data=iris_df)

# 下面的操作，将每一个Species所属的点加到对应的位置，加上散点图，# 振动值jitter=True 使各个散点分开，要不然会是一条直线# 注意此处要将坐标图用ax先保存起来，这样第二次才会在原来的基础上加上散点图ax = sns.boxplot(x="Species", y="Sepal.Length", data=iris_df)ax = sns.stripplot(x="Species", y="Sepal.Length", data=iris_df, jitter=True, edgecolor="gray")

# violinplot 小提琴图，查看密度分布，结合了前面的两个图，并且进行了简化# 数据越稠密越宽，越稀疏越窄sns.violinplot(x="Species", y="Sepal.Length", data=iris_df, height=6) # sns.kdeplot == kernel density 核密度图（单个变量）sns.FacetGrid(iris_df, hue="Species", height=6).map(sns.kdeplot, "Sepal.Length").add_legend() # pairplot 任意两个变量间的关系sns.pairplot(iris_df, hue="Species", height=3)

# 模型构建比较简单，关键是模型的调参train_df=test_df=iris_df.sample(frac=0.8,replace=False, random_state=None)train_X=train_df.drop(['Species'],axis=1)train_Y=train_df['Species']# 由于么有提供建模数据集，所以我们随机从样本集中选择40%的数据集# replace=False 无放回的抽取# random-state 数据不能重复test_df=iris_df.sample(frac=0.9,replace=False, random_state=None)test_df.head()
test_X=test_df.drop(['Species'],axis=1)test_Y=test_df['Species']
model=DecisionTreeClassifier()model.fit(train_X, train_Y)prediction = model.predict(test_X)print('The accuracy of the Decision Tree is: {0}'.format(metrics.accuracy_score(prediction,test_Y)))

1、朴素贝叶斯算法

import pandas as pdimport seaborn as snsimport matplotlib.pyplot as pltimport numpy as np
# 修改baseUrl的路径即可完成数据读取修改baseUrl="C:\\Users\\71781\\Desktop\\2020\\ML-20200422\\bayes\\"mushrooms=pd.read_csv(baseUrl+"mushrooms.csv")mushrooms.columns=['class','cap-shape','cap-surface','cap-color','ruises','odor','gill-attachment','gill-spacing','gill-size','gill-color','stalk-shape','stalk-root','stalk-surface-above-ring','stalk-surface-below-ring','stalk-color-above-ring','stalk-color-below-ring','veil-type','veil-color','ring-number','ring-type','spore-print-color','population','habitat']mushrooms.shape

pd.set_option("display.max_columns",100) #让所有列都能加载出来mushrooms.head()# 可以发现，所有特征都是离散的，都属于分类型

# class标识有毒无毒np.unique(mushrooms['cap-shape'])

fig,(ax1,ax2)=plt.subplots(1,2,figsize=(15,5))# 探究 形状和颜色对于是否有毒的贡献度，发现形状为b的无毒蘑菇比例大sns.countplot(x='cap-shape',data=mushrooms,hue='class',ax=ax1)sns.countplot(x='cap-surface',data=mushrooms,hue='class',ax=ax2)

sns.countplot(x='cap-color',hue='class',data=mushrooms)

# 把有毒无毒换成0/1类型，1标识无毒mushrooms['class'].replace('e',1,inplace=True)mushrooms['class'].replace('p',,inplace=True)# 计算每个颜色无毒的概率perc = mushrooms[["cap-color", "class"]].groupby(['cap-color'],as_index=False).mean()percsns.barplot(x='cap-color',y='class',data=perc)

# 使用sklearn进行预处理from sklearn.preprocessing import LabelEncoderlabelencoder=LabelEncoder()for col in mushrooms.columns:    mushrooms[col] = labelencoder.fit_transform(mushrooms[col])
mushrooms.head()

sns.countplot(x='cap-shape',data=mushrooms,hue='class',)

X=mushrooms.drop('class',axis=1) #Predictorsy=mushrooms['class'] #Response#X.head()
#这里采用用哑变量编码，为的是后面能更好的计算特征的各属性的重要性，并且避免数值变量分类时偏向于数值大的属性X=pd.get_dummies(X,columns=X.columns,drop_first=True)X.head()

from sklearn.model_selection import train_test_splitX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.3, random_state=1234)

# 贝叶斯from sklearn.naive_bayes import GaussianNBfrom sklearn import metrics model2 = GaussianNB()model2.fit(X_train, y_train)prediction2 = model2.predict(X_test)print('The accuracy of the Decision Tree is: {0}'.format(metrics.accuracy_score(prediction2,y_test)))

所谓物以类聚-人以群分，“类”指的是具有相似性的集合，聚类是指将数据集划分为若干类，使得各个类之内的数据为相似，而各个类之间的数据相似度差别尽可能的大。聚类分析就是以相似性为基础，在一个聚类中的模式之间比不在同一个聚类中的模式之间具有更多的相似性。对数据集进行聚类划分，属于无监督学习。

K-Means是常用且简单的聚类算法，大特点是好理解，运算速度快，时间复杂度近于线性，适合挖掘大规模数据集。但是只能应用于连续型的数据，并且一定要在聚类前需要手工指定要分成几类；

K-Means采用距离作为相似性指标，从而发现给定数据集中的K个类，且每个类的中心是根据类中所有数值的均值得到的，每个类的中心用聚类中心来描述。对于给定的一个（包含n个一维以及一维以上的数据点的）数据集X以及要得到的类别数量K，选取欧式距离作为相似度指标，聚类目标是使得类的聚类平方和小，即小化：

2、K-Means算法流程：

1. 随机选取K个样本作为聚类中心；

2. 计算各样本与各个聚类中心的距离；

3. 将各样本回归于与之距离近的聚类中心；

4. 求各个类的样本的均值，作为新的聚类中心；

5. 判定：若类中心不再发生变动或者达到迭代次数，算法结束，否则回到第二步。

from sklearn import datasetsimport pandas as pdimport seaborn as snsimport matplotlib.pyplot as pltURL="C:\\Users\\71781\\Desktop\\2020\\ML-20200422\\K-means\\"data=pd.read_csv(URL+"xigua.csv")data.head()data.describe()fig,(axis1,axis2) = plt.subplots(1,2,figsize=(10,3))sns.distplot(data["density"],ax=axis1)sns.distplot(data["sugercontent"],ax=axis2)sns_test=sns.scatterplot(x="density",y="sugercontent",data=data)import sklearn.cluster as sc# n_clusters: 聚类数model = sc.KMeans(n_clusters=4)# 不断调整聚类中心，直到终聚类中心稳定则聚类完成model.fit(data)# 获取训练结果的聚类中心centers = model.cluster_centers_

n_clusters：整型，缺省值=8 ，生成的聚类数。

max_iter：整型，缺省值=300 ，执行一次k-means算法所进行的大迭代数。

n_init：整型，缺省值=10 ，用不同的聚类中心初始化值运行算法的次数，终解是在inertia意义下选出的优结果。

init：有三个可选值：’k-means++’， ‘random’，或者传递一个ndarray向量，此参数指定初始化方法，默认值为 ‘k-means++’。（１）‘k-means++’ 用一种特殊的方法选定初始聚类，可加速迭代过程的收敛（２）‘random’ 随机从训练数据中选取初始质心。（３）如果传递的是一个ndarray，则应该形如 (n_clusters, n_features) 并给出初始质心。

precompute_distances：三个可选值，‘auto’，True 或者 False，预计算距离，计算速度更快但占用更多内存。（１）‘auto’：如果 样本数乘以聚类数大于 12million 的话则不预计算距离。（２）True：总是预先计算距离。（３）False：永远不预先计算距离。

tol：float类型，默认值= 1e-4　与inertia结合来确定收敛条件。

n_jobs：整形数。　指定计算所用的进程数。内部原理是同时进行n_init指定次数的计算。（１）若值为 -1，则用所有的CPU进行运算。若值为1，则不进行并行运算。（２）若值小于-1，则用到的CPU数为(n_cpus + 1 + n_jobs)。因此如果 n_jobs值为-2，则用到的CPU数为总CPU数减1。

random_state：整型或 numpy.RandomState 类型，可选，用于初始化质心的生成器（generator）。如果值为一个整数，则确定一个seed。此参数默认值为numpy的随机数生成器。

copy_x：布尔型，默认值=True 　　，当我们precomputing distances时，将数据中心化会得到更准确的结果。如果把此参数值设为True，则原始数据不会被改变。如果是False，则会直接在原始数据上做修改并在函数返回值时将其还原。但是在计算过程中由于有对数据均值的加减运算，所以数据返回后，原始数据和计算前可能会有细小差别。

1、关联规则简介

关联规则挖掘可以让我们从数据集中发现项与项之间的关系，它在我们的生活中有很多应用场景，“购物篮分析”就是一个常见的场景，这个场景可以从消费者交易记录中发掘商品与商品之间的关联关系，进而通过商品捆绑销售或者相关推荐的方式带来更多的销售量。

1. 搞懂关联规则中的几个重要概念：支持度、置信度、提升度

2. Apriori 算法的工作原理

3. 在实际工作中，我们该如何进行关联规则挖掘

2、关联规则中重要的概念

我举一个超市购物的例子，下面是几名客户购买的商品列表：

支持度

支持度是个百分比，它指的是某个商品组合出现的次数与总次数之间的比例。支持度越高，代表这个组合出现的频率越大。

我们看啤酒出现了3次，那么5笔订单中啤酒的支持度是3/5=0.6。同理，尿布出现了5次，那么尿布的支持度是5/5=1。尿布和啤酒同时出现的支持度是3/6=0.6。

置信度

它指的就是当你购买了商品 A，会有多大的概率购买商品 B。

我们可以看上面的商品，购买尿布的同时又购买啤酒的订单数是3，购买啤酒的订单数是3，那么（尿布->啤酒）置信度= 3/3=1。

再看购买了啤酒同时购买尿布的订单数是3，购买尿布的订单数是5，那么（啤酒->尿布）置信度=3/5=0.6。

提升度

提升度代表的是“商品 A 的出现，对商品 B 的出现概率提升的”程度。所以我们在做商品推荐的时候，重点考虑的是提升度。

我们来看提升度公式：那么我们来计算下尿布对啤酒的提升度是多少： 

怎么解读1.67这个数值呢？

1. 提升度 (A→B)>1：代表有提升

2. 提升度 (A→B)=1：代表有没有提升，也没有下降

3. 提升度 (A→B)<1：代表有下降。

其实看上面提升度的公式，我们就可以理解，也就是AB同时出现的次数越多，单独出现B的次数越少，那么支持度也就越大也就是B的出现总是伴随着A的出现，那么A对B出现的概率就越有提升！

3、Apriori 的工作原理

我们一起来看下经典的关联规则 Apriori 算法是如何工作的。

Apriori 算法其实就是查找频繁项集 (frequent itemset) 的过程，所以我们需要先了解是频繁项集。

频繁项集就是支持度大于等于小支持度阈值的项集，所以小于小值支持度的项目就是非频繁项集，而大于等于小支持度的项集就是频繁项集。

下面我们来举个栗子：

假设我随机指定小支持度是0.2。首先，我们先计算单个商品的支持度：

因为小支持度是 0.2，所以你能看到商品 鸡蛋 是不符合小支持度的，不属于频繁项集，于是经过筛选商品的频繁项集如下：

在这个基础上，我们将商品两两组合，得到两个商品的支持度：

筛选大于小支持度（0.2）的数据后

在这个基础上，我们再将商品三个组合，得到三个商品的支持度：

筛选大于小支持度（0.2）的数据后

在这个基础上，我们将商品四个组合，得到四个商品的支持度：

再次筛选大于小支持度（0.2）数据的话，就全删除了，那么，此时算法结束，上一次的结果就是我们要找的频繁项，也就是{牛奶、面包、尿布}、{面包、尿布、啤酒}。

我们来总结一下上述Apriori算法过程：

1. K=1，计算 K 项集的支持度

2. 筛选掉小于小支持度的项集

3. 如果项集为空，则对应 K-1 项集的结果为终结果

4. 否则 K=K+1，重复 1-3 步

我们可以看到 Apriori 在计算的过程中有以下几个缺点：

1. 可能产生大量的候选集。因为采用排列组合的方式，把可能的项集都组合出来了

2. 每次计算都需要重新扫描数据集，来计算每个项集的支持度

这就好比我们数据库中的“全表扫描”查询一样，非常浪费IO和时间。在数据库中我们都知道使用索引来快速检索数据，那Apriori 能优化吗？

4、Apriori 的改进算法：FP-Growth 算法

FP-growth算法是基于Apriori原理的，通过将数据集存储在FP树上发现频繁项集，但不能发现数据之间的关联规则。FP-growth算法只需要对数据库进行两次扫描，而Apriori算法在求每个潜在的频繁项集时都需要扫描一次数据集，所以说Apriori算法是高效的。其中算法发现频繁项集的过程是：(1)构建FP树；(2)从FP树中挖掘频繁项集。

创建项头表

概念知识不在这凑字数了，我们直接来干货！假设我们从以下数据中来挖掘频繁项。

首先创建，项头表，这一步的流程是先扫描一遍数据集，对于满足小支持度的单个项按照支持度从高到低进行排序，这个过程中删除了不满足小支持度的项（假设小支持度是0.2）。

构建FP树

整个流程是需要再次扫描数据集，对于每一条数据，按照支持度从高到低的顺序进行创建节点（也就是步中项头表中的排序结果），节点如果存在就将计数 count+1，如果不存在就进行创建。同时在创建的过程中，需要更新项头表的链表。

先把原始数据按照支持度排序，那么原始数据变化如下：

下面我们把以上每行数据，按照顺序插入到FP树中，注意FP树的根节点记为 NULL 节点。

接下来插入第二行数据，由于第二行数据个数据也是B，和已有的树结构重合，那么我们保持原来树结构中的B位置不变，同时计数加1，C、D是新增数据，那么就会有新的树分叉，结果如下图：

以此类推，读取下面的三行数据到FP树中

后生成的FP数如下：

根据FP数挖掘频繁项

我们终于把FP树建立好了，那么如何去看这颗树呢？得到 FP 树后，需要对每一个频繁项，逐个挖掘频繁项集。具体过程为：首先获得频繁项的前缀路径，然后将前缀路径作为新的数据集，以此构建前缀路径的条件 FP 树。然后对条件 FP 树中的每个频繁项，获得前缀路径并以此构建新的条件 FP 树。不断迭代，直到条件 FP 树中只包含一个频繁项为止（反正我次看完这句话是没理解）。

FP树是从下往上看了，也就是根据子节点找父节点，接下来还是来图解~

首先，我们看包含A的频繁项：

我们可以看到包含A的树有两个，我们先看树2，可以得到路径{B:2,C:2}，此处的2是根据A出现的次数定的。接着我们创建FP树，具体的创建过程和上面创建 FP 树的过程一样，如下图：

注意此时头指针表中包含两个元素，所以对每个元素，需要获得前缀路径，并将前缀路径创建成条件 FP 树，直到条件 FP 树中只包含一个元素时返回。

• 对元素 B，获得前缀路径为{}，则频繁项集返回{A:2,B:2};

• 对元素 C，获得前缀路径{B:2}，则将前缀路径创建成条件 FP 树，如下图  所示。

  注意此时条件 FP 树中只包含一个元素，故返回频繁项集{A:2,C:2,B:2}。由于元素 C 也是频繁项，所以{A:2,C:2}也是频繁项集。

再加上{A:2}本身就是频繁项集，所以 A 对应的频繁项集有：{A:2},{A:2,C:2} ,{A:2,B:2},{A:2,C:2,B:2}。

同理，我们来看树1，树1比较简单，就一个路径{B:1}，根据上述方法我们得到此分支频繁项为{A:1,B:1},{A:1}。

综上，我们可以看到两个分支都包含频繁项{A,B},{A}的，此时我们进行合并两个分支，得到包含A的频繁项：{A:3},{A:3,B:3},{A:2,C:2} ,{A:2,C:2,B:2}，我们用出现的次数转换下，即 (A,): 3, (A, B): 3, (A, C): 2, (A, B, C): 2。

同理，按照上述方法，我们可以依次找到包含B的频繁项是(D): 2, (C, D): 2, (B, D): 2, (B, C, D): 2,  (C): 4, (B, C): 4, (B): 5。

5、实践总结

经典的算法，很多大神已经实现，我们直接拿来用就行了，比如上面的FP-GROWTH算法，介绍一款专门的包pyfpgrowth。

代码：

import pyfpgrowth as fp
itemsets = [['A','B'], ['B','C','D'],['B','C'],['A','B','C'],['A','B','C','D']]# 频数删选  频数大于2patterns = fp.find_frequent_patterns(itemsets, 2)print(patterns)
#输出 {('D',): 2, ('C', 'D'): 2, ('B', 'D'): 2, ('B', 'C', 'D'): 2, ('A',): 3, ('A', 'B'): 3, ('A', 'C'): 2, ('A', 'B', 'C'): 2, ('C',): 4, ('B', 'C'): 4, ('B',): 5}