HAWQ + MADlib 玩转数据挖掘之（八）——聚类方法之k-means

用户1148526

发布于 2018-01-03 17:08:57

1.3K0

发布于 2018-01-03 17:08:57

文章被收录于专栏：Hadoop数据仓库

一、聚类方法简介

所谓“物以类聚，人以群分”，其核心思想就是聚类。通过聚类，人们能意识到密集和稀疏的区域，发现全局的分布模式，以及数据属性之间有趣的相互关系。

在实践中，聚类往往为分类服务，即先通过聚类来判断事务的合适类别，然后再利用分类技术对新的样本进行分类。分类与聚类的区别是：分类是事先定义好类别，类别数不变，分类需要由人工标注训练得到，属于监督学习范畴。聚类则没有事先预定的类别，类别数不确定。聚类不需要人工标注的预先训练，类别在聚类过程中自动生成，是一种非监督学习。

1. 聚类的概念

将物理或抽象对象的集合分成由类似的对象组成的多个类或簇（Cluster）的过程被称为聚类（Clustering）。由聚类所生成的簇是一组数据对象的集合，这些对象与同一个簇中的对象相似度较高，与其它簇中的对象相似度较低。相似度是根据描述对象的属性值来度量的，距离是经常采用的度量方式。分析事物聚类的过程称为聚类分析或群分析，是研究样品或指标分类问题的一种统计分析方法。

作为一个数据挖掘的功能，聚类能作为独立的工具来获得数据分布情况，观察每个簇的特点，集中对特定簇做进一步的分析。此外，聚类分析还可以作为其它算法的预处理步骤，简少计算量，提高分析效率。

2. 类的度量方法

虽然类的形式各有不同，但总的来说，一般用距离作为类的度量方法。

设x、y是两个向量

和

，聚类分析中常用的距离有以下几种：

（1）曼哈顿距离

x、y的曼哈顿距离定义为：

（2）欧氏距离

x、y的欧氏距离定义为：

（3）欧氏平方距离

x、y的欧氏平方距离定义为：

（4）角距离

x、y的角距离定义为：

，分母是x、y两个向量的2范数乘积。

（5）谷本距离

x、y的谷本距离定义为：

二、k-means方法

在数据挖掘中，k-means算法是一种广泛使用的聚类分析算法，也是Madlib 1.10.0官方文档中唯一提及的聚类算法。

1. 基本思想

k-means聚类划分方法的基本思想是：将一个给定的有N个数据记录的集合，划分到K个分组中，每一个分组就代表一个簇，K<N。而且这K个分组满足下列条件：

（1）每一个分组至少包含一个数据记录。

（2）每一个数据记录属于且仅属于一个分组。

算法首先给出一个初始的分组，以后通过反复迭代的方法改变分组，使得每一次改进之后的分组方案都较前一次好，而所谓好的标准就是：同一分组中对象的距离越近越好（已经收敛，反复迭代至组内数据几乎无差异），而不同分组中对象的距离越远越好。

2. 原理与步骤

k-means算法的工作原理是：首先随机从数据集中选取K个点，每个点初始地代表每个簇的中心，然后计算剩余各个样本到中心点的距离，将它赋给最近的簇，接着重新计算每一簇的平均值作为新的中心点，整个过程不断重复，如果相邻两次调整没有明显变化，说明数据聚类形成的簇已经收敛。本算法的一个特点是在每次迭代中都要考察每个样本的分类是否正确。若不正确，就要调整，在全部样本调整完后，再修改中心点，进入下一次迭代。这个过程将不断重复直到满足某个终止条件，终止条件可以是以下任何一个：

没有对象被重新分配给不同的聚类。
聚类中心不再发生变化。
误差平方和局部最小。

k-means算法是很典型的基于距离的聚类算法，采用距离作为相似性的评价指标，即认为两个对象的距离越近，其相似度就越大。该算法认为簇是由距离靠近的对象组成，因此把得到紧凑且独立的簇作为最终目标。

k-means算法：

输入：聚类个数k，以及n个数据对象。

输出：满足误差最小标准的k个聚簇。

处理流程：

从n个数据对象中任意选择k个对象作为初始中心。
计算每个对象与这些中心对象的距离，并根据最小距离对相应的对象进行划分。
重新计算每个有变化聚类的均值作为新的中心。
循环2、3直到每个聚类不再发生变化为止。终止条件一般为最小化对象到其聚类中心的距离的平方和，如下：

k-means算法接受输入量k，然后将n个数据对象划分为k个簇以便使得所获得的簇满足：同一簇中的对象相似度较高，而不同簇中的对象相似度较低。簇相似度是利用各簇中对象的均值所获得的中心对象来进行计算的。为了便于理解k-means算法，可以参考图1所示的二维向量的例子。

图1

从图中我们可以看到A、B、C、D、E五个点。而灰色的点是初始中心点，也就是用来找簇的点。有两个中心点，所以K=2。

k-means的算法如下：

随机在图中取K（这里K=2）个初始中心点。
对图中的所有点求到这K个中心点的距离，假如点Pi离种子点Si最近，那么Pi属于Si聚类。图1中，我们可以看到A、B属于上面的中心点，C、D、E属于下面中部的中心点。
移动中心点到属于它的簇的中心，作为新的中心点，见图1上的第三步
重复第2和第3步，直到中心点没有移动，可以看到图1中的第四步上面的中心点聚合了A、B、C，下面的中心点聚合了D、E。

二维坐标中两点之间距离公式如下：

公式中(x1，y1)，(x2，y2)分别为A、B两个点的坐标。求聚类中心点的算法可以简单使用各个点的X/Y坐标的平均值。

3. k-means++算法

k-means主要有两个最重大的缺陷，并且都和初始值有关：

K是事先给定的，这个K值的选定是非常难以估计的。很多时候，事先并不知道给定的数据集应该分成多少个类别才最合适。（ISODATA算法通过类的自动合并和分裂，得到较为合理的类型数目K）
k-means算法以初始随机中心点为基础，这个随机中心点太重要，不同的随机中心点会有得到完全不同的结果。k-means++算法就是用来解决这个问题，其可以有效地选择初始点。

k-means++算法步骤：

先从输入数据对象中随机挑一个作为中心点。
对于每个数据对象x，计算其和最近的一个中心点的距离D(x)并保存在一个数组里，然后把这些距离加起来得到Sum(D(x))。
再取一个随机值，用权重的方式来取计算下一个中心点。这个算法的实现是，先取一个能落在Sum(D(x))中的随机值Random，然后用Random -= D(x)，直到其<=0，此时的x就是下一个中心点。
重复第2和第3步直到所有的K个中心点都被选出来。
进行k-means算法。

三、Madlib中的k-means方法相关函数

1. 技术背景

形式上，我们希望最小化以下目标函数：

其中x1，...，xn是n个数据对象，c1，...，ck是k个中心点，常见的情况下，距离使用欧氏平方距离。这个问题在计算上很困难（NP-hard问题），但由于局部启发式搜索算法在实践中表现的相当好，如今被普遍采用，其中之一前面所讨论的k-means算法。

2. 训练函数

（1）语法

Madlib提供了以下四个k-means算法的训练函数。

使用随机中心点方法，语法如下：

kmeans_random( rel_source,

               expr_point,

k,

               fn_dist,

               agg_centroid,

               max_num_iterations,

               min_frac_reassigned

使用kmeans++中心点方法，语法如下：

kmeanspp( rel_source,

          expr_point,

k,

          fn_dist,

          agg_centroid,

          max_num_iterations,

          min_frac_reassigned,

          seeding_sample_ratio

由rel_initial_centroids参数提供一个包含初始中心点的表名，语法如下：

kmeans( rel_source,

        expr_point,

        rel_initial_centroids,

        expr_centroid,

        fn_dist,

        agg_centroid,

        max_num_iterations,

        min_frac_reassigned

由initial_centroids参数提供的数组表达式，指定一个初始中心点集合，语法如下：

kmeans( rel_source,

        expr_point,

        initial_centroids,

        fn_dist,

        agg_centroid,

        max_num_iterations,

        min_frac_reassigned

（2）参数

rel_source：TEXT类型，含有输入数据对象的表名。数据对象和预定义中心点（如果使用的话）应该使用一个数组类型的列存储，如FLOAT[]或INTEGER[]。调用任何以上四种函数进行数据分析时，都会跳过具有non-finite值的数据对象，non-finite值包括NULL、NaN、infinity等。

expr_point：TEXT类型，包含数据对象的列名。

k：INTEGER类型，指定要计算的中心点的个数。

fn_dist（可选）：TEXT类型，缺省值为‘squared_dist_norm2’，指定计算数据对象与中心点距离的函数名称。可以使用以下距离函数，括号内为均值计算方法：

dist_norm1：1范数/曼哈顿距离（元素中位数）。
dist_norm2: 2范式/欧氏距离（元素平均数）。
squared_dist_norm2：欧氏平方距离（元素平均数）。
dist_angle：角距离（归一化数据的元素平均数）。
dist_tanimoto：谷本距离（归一化数据的元素平均数）。
具有DOUBLE PRECISION[] x, DOUBLE PRECISION[] y -> DOUBLE PRECISION参数形式的用户自定义函数。

agg_centroid（可选）：TEXT类型，缺省值为‘avg’。确定中心点使用的聚合函数名，可以使用以下聚合函数：

avg：平均值（缺省）。
normalized_avg：归一化平均值。

max_num_iterations（可选）：INTEGER类型，缺省值为20，指定执行的最大迭代数。

min_frac_reassigned（可选）：DOUBLE PRECISION类型，缺省值为0.001。相邻两次迭代所有中心点相差小于该值时计算完成。

seeding_sample_ratio（可选）：DOUBLE PRECISION，缺省值为1.0。kmeans++将扫描数据‘k’次，对大数据集会很慢。此参数指定用于确定初始中心点所使用的原始数据集样本比例。当此参数大于0时（最大值为1.0），初始中心点在数据均匀分布的随机样本上。注意，k-means算法最终会在全部数据集上执行。此参数只是为确定初始中心点建立一个子样本，并且只对kmeans++有效。

rel_initial_centroids：TEXT类型，包含初始中心点的表名。

expr_centroid：TEXT类型，rel_initial_centroids指定的表中包含中心点的列名。

initial_centroids：TEXT类型，包含初始中心点的DOUBLE PRECISION数组表达式的字符串。

（3）输出格式

k-means模型的输出具有以下列的复合数据类型：

centroids DOUBLE PRECISION[][]类型，最终的中心点。

cluster_variance DOUBLE PRECISION[]类型，每个簇的方差。

objective_fn DOUBLE PRECISION类型，方差合计。

frac_reassigned DOUBLE PRECISION类型，在最后一次迭代的误差。

num_iterations INTEGER类型，迭代执行的次数。

3. 簇分配函数

（1）语法

得到中心点后，可以调用以下函数为每个数据对象进行簇分配：

closest_column( m, x )

（2）参数

m：DOUBLE PRECISION[][]类型，训练函数返回的中心点。

x：DOUBLE PRECISION[]类型，输入数据。

（3）输出格式

column_id INTEGER类型，簇ID，从0开始。

distance DOUBLE PRECISION类型，数据对象与簇中心点的距离。

4. 轮廓系数函数

轮廓系数（Silhouette Coefficient），是聚类效果好坏的一种评价方法。作为 k-means模型的一部分，Madlib提供了一个轮廓系数方法的简化版本函数，该函数结果值处于-1~1之间,值越大，表示聚类效果越好。注意，对于大数据集，该函数的计算代价很高。

（1）语法

simple_silhouette( rel_source,
                   expr_point,
                   centroids,
                   fn_dist
                 )

（2）参数

rel_source：TEXT类型，含有输入数据对象的表名。

expr_point：TEXT类型，数据对象列名。

centroids：TEXT类型。中心点表达式。

fn_dist（可选）：TEXT类型，缺省值为‘dist_norm2’，计算数据点到中心点距离的函数名。

四、k-means示例

1. 问题提出

RFM模型是在做用户价值细分时常用的方法，主要涵盖的指标有最近一次消费时间R（Recency）、消费频率（Frequency），消费金额(Monetary)。我们用R、F、M三个指标作为数据对象属性，应用Madlib的k-means模型相关函数对用户进行聚类分析，并得出具有实用性和解释性的结论。

2. 建立测试数据表并装载原始数据

-- 创建原始数据表
drop table if exists t_source;
create table t_source
(cust_id int,
 amount decimal(10 , 2 ),
 quantity int,
 dt date);

-- 添加100条数据
insert into t_source (cust_id,amount,quantity,dt) values 
(567,1100.51,2,'2017-07-20'),(568,2003.47,2,'2017-07-20'),(569,297.91,2,'2017-07-14'),
(570,300.02,2,'2017-07-12'),(571,198.48,2,'2017-07-19'),(572,4003.07,3,'2017-07-20'),
(573,4003.07,3,'2017-07-20'),(574,393.39,2,'2017-06-29'),(575,611.3,3,'2017-07-13'),
(576,597.73,2,'2017-07-13'),(577,399.32,2,'2017-06-29'),(578,20026.55,2,'2017-07-18'),
(579,1997.57,2,'2017-06-22'),(580,3202.77,3,'2017-07-13'),(581,597.72,2,'2017-06-29'),
(582,600.04,3,'2017-07-14'),(583,3995.11,2,'2017-06-22'),(584,3995.11,2,'2017-06-22'),
(585,3984.27,2,'2017-06-22'),(586,7003.05,3,'2017-06-26'),(587,2001.23,2,'2017-06-27'),
(588,2001.23,2,'2017-06-19'),(589,2094.91,3,'2017-06-19'),(590,2964.5,4,'2017-06-26'),
(591,1982.58,2,'2017-06-09'),(592,3000.62,2,'2017-06-20'),(593,4000,2,'2017-06-22'),
(594,5003.06,2,'2017-06-19'),(595,2098.71,3,'2017-06-27'),(596,196.44,2,'2017-06-20'),
(597,401.46,2,'2017-07-11'),(598,20007.34,5,'2017-07-20'),(599,2001.23,2,'2017-06-22'),
(600,2961.03,2,'2017-06-21'),(601,3997.09,2,'2017-06-20'),(602,1491.21,2,'2017-07-13'),
(603,4105.47,5,'2017-07-18'),(604,1998.17,2,'2017-06-13'),(605,497.28,2,'2017-06-09'),
(606,2306.61,2,'2017-06-27'),(607,9006.76,5,'2017-07-21'),(608,5982.51,3,'2017-06-29'),
(609,2199.46,2,'2017-07-20'),(610,1088.6,2,'2017-06-20'),(611,3991.01,3,'2017-06-20'),
(612,2000.01,2,'2017-06-08'),(613,501.79,3,'2017-07-17'),(614,15002.45,5,'2017-07-13'),
(615,601.1,2,'2017-07-11'),(616,2986.69,2,'2017-06-19'),(617,2012.68,2,'2017-06-30'),
(618,1500.5,2,'2017-06-07'),(619,3988.51,3,'2017-06-19'),(620,20010.44,2,'2017-06-05'),
(621,20002.57,2,'2017-06-02'),(622,5266.72,4,'2017-07-17'),(623,5266.72,4,'2017-07-17'),
(624,7801.58,2,'2017-07-11'),(625,294.18,2,'2017-05-29'),(626,972.54,2,'2017-05-24'),
(627,1978.62,2,'2017-06-08'),(628,694.73,2,'2017-06-05'),(629,1196.04,2,'2017-06-08'),
(630,4451.68,4,'2017-06-20'),(631,2010.49,2,'2017-06-19'),(632,2994.46,2,'2017-06-30'),
(633,1000.37,2,'2017-05-29'),(634,3199.49,3,'2017-06-22'),(635,6023.75,3,'2017-06-08'),
(636,1296.24,12,'2017-07-19'),(637,4003.67,3,'2017-06-26'),(638,4001.54,2,'2017-06-19'),
(639,4000.61,3,'2017-06-23'),(640,4001.83,3,'2017-06-19'),(641,5999.42,3,'2017-06-21'),
(642,4975.83,4,'2017-06-27'),(643,12052.96,5,'2017-07-21'),(644,5010.82,2,'2017-06-07'),
(645,3001.22,2,'2017-07-13'),(646,2992.68,3,'2017-06-23'),(647,4002.45,2,'2017-06-19'),
(648,5938.52,2,'2017-05-22'),(649,4001.83,3,'2017-06-19'),(650,7141.16,2,'2017-06-28'),
(651,26010.8,16,'2017-07-20'),(652,9102.11,7,'2017-07-19'),(653,1225.07,2,'2017-05-31'),
(654,6168.28,3,'2017-06-19'),(655,2997.94,3,'2017-07-11'),(656,2972.38,2,'2017-06-07'),
(657,4303.51,2,'2017-05-23'),(658,4100.16,4,'2017-07-18'),(659,2001.23,2,'2017-06-19'),
(660,11594.24,10,'2017-07-20'),(661,12039.49,2,'2017-06-22'),(662,1494.97,2,'2017-06-13'),
(663,954.77,2,'2017-06-27'),(664,6006.78,3,'2017-06-22'),(665,25755.7,2,'2017-06-06'),
(666,60201.48,2,'2017-07-11');

3. 数据预处理

将最近一次访问日期处理成最近一次访问日期到当前日期的间隔天数，代表该用户是否最近有购买记录（即目前是否活跃）。
因为k-means受异常值影响很大，并且金额变异比较大，所以去除该维度的异常值。
使用PCA方法消除维度之间的相关性。
0-1归一化处理。

-- 去掉异常值
drop table if exists t_source_change;
create table t_source_change 
(row_id serial,
 cust_id int,
 amount decimal(10 , 2 ),
 quantity int,
 dt int);

insert into t_source_change (cust_id,amount,quantity,dt) 
select cust_id, 
       amount,
       quantity,
       current_date-dt dt 
  from t_source 
 where amount < (select percentile_cont (0.99) within group (order by amount)
                   from t_source);

select * from t_source_change order by cust_id;

查询结果为：

...
     94 |     660 | 11594.24 |       10 |  2
     95 |     661 | 12039.49 |        2 | 30
     96 |     662 |  1494.97 |        2 | 39
     97 |     663 |   954.77 |        2 | 25
     98 |     664 |  6006.78 |        3 | 30
     99 |     665 | 25755.70 |        2 | 46
(99 rows)

可以看到，因为cust_id=666用户的金额不在99%的范围内，所以t_source_change表中去掉了该条记录。在此去除异常并非这个用户异常，而是为了改善聚类结果。最后需要给这些“异常用户”做业务解释。

-- PCA去掉相关性
drop table if exists mat;  
create table mat (id integer,  
                  row_vec double precision[]  
                  );  
insert into mat
select row_id,
       string_to_array(amount||','||quantity||','||dt,',')::double precision[] row_vec
  from t_source_change;

drop table if exists result_table, result_table_mean;  
select madlib.pca_train('mat',              -- source table  
                        'result_table',     -- output table  
                        'id',               -- row id of source table  
                        3                   -- number of principal components  
                       );  

drop table if exists residual_table, result_summary_table, out_table;  
select madlib.pca_project( 'mat',  
                           'result_table',  
                           'out_table',  
                           'id',  
                           'residual_table',  
                           'result_summary_table'  
                           );

-- 0-1归一化
drop table if exists t_source_change_nor;
create table t_source_change_nor
as 
select row_id,
       string_to_array(amount_nor||','||quantity_nor||','||dt_nor,',')::double precision[] row_vec
  from
(
select row_id, 
       (row_vec[1] - min_amount)/(max_amount - min_amount) amount_nor,
       (row_vec[2] - min_quantity)/(max_quantity - min_quantity) quantity_nor,
       (max_dt - row_vec[3])/(max_dt - min_dt) dt_nor
  from out_table,
       (select max(row_vec[1]) max_amount,
               min(row_vec[1]) min_amount,
               max(row_vec[2]) max_quantity,
               min(row_vec[2]) min_quantity,
               max(row_vec[3]) max_dt,
               min(row_vec[3]) min_dt
          from out_table) t) t;

select * from t_source_change_nor order by row_id;

查询结果为：

...
     94 | {0.558470357737996,0.954872666162949,0.296935710714377}
     95 | {0.54122257689463,0.482977156688704,0.81244230552888}
     96 | {0.949697477408967,0.385844448834949,0.65901807391295}
     97 | {0.970623648952883,0.62014760223173,0.704941708880569}
     98 | {0.774918367989914,0.513405499602443,0.666993533505089}
     99 | {0.00988267286683593,0.150872332720288,0.908966781310526}
(99 rows)

4. k-means聚类

（1）调用kmeanspp函数执行聚类

drop table if exists km_result;
create table km_result as
select * from madlib.kmeanspp( 't_source_change_nor',   -- table of source data
                               'row_vec',     -- column containing point co-ordinates 
                               3,             -- number of centroids to calculate
                               'madlib.squared_dist_norm2',   -- distance function
                               'madlib.avg',  -- aggregate function
                               20,            -- number of iterations
                               0.001          -- fraction of centroids reassigned to keep iterating 
                             );

\x on;
select * from km_result;

结果如下：

-[ RECORD 1 ]----+-----------------------------------------------------------------------------------------------------------------------------------------------
centroids        | {{0.791217523987,0.920651641252,0.673871940211},{0.874057597294,0.532762557118,0.682720362738},{0.796875366696,0.204531299723,0.663443078965}}
cluster_variance | {3.49163639093,0.657987496465,1.91771776225}
objective_fn     | 6.06734164965
frac_reassigned  | 0
num_iterations   | 3

（2）调用simple_silhouette函数评价聚类质量

select * from madlib.simple_silhouette( 't_source_change_nor',
                                        'row_vec',
                                        (select centroids from
                                            madlib.kmeanspp('t_source_change_nor',
                                                            'row_vec',
                                                            3,
                                                            'madlib.squared_dist_norm2',
                                                            'madlib.avg',
                                                            20,
                                                            0.001)),
                                        'madlib.dist_norm2'
                                      );

结果如下：

-[ RECORD 1 ]-----+------------------
simple_silhouette | 0.640471849127657

（3）调用closest_column函数执行簇分配

\x off;

select cluster_id,
       round(count(cust_id)/99.0,4) pct,
       round(avg(amount),4) avg_amount,  
       round(avg(quantity),4) avg_quantity, 
       round(avg(dt),2) avg_dt
  from 
(
select t2.*,    
    (madlib.closest_column(centroids, row_vec)).column_id as cluster_id
  from t_source_change_nor as t1, km_result, t_source_change t2
 where t1.row_id = t2.row_id) t
 group by cluster_id;

查询结果为：

 cluster_id |  pct   | avg_amount | avg_quantity | avg_dt 
------------+--------+------------+--------------+--------
          2 | 0.1919 |  5439.9795 |       2.0526 |  48.79
          1 | 0.4848 |  3447.5631 |       2.4375 |  29.56
          0 | 0.3232 |  5586.0203 |       4.0313 |   5.56
(3 rows)

5. 解释聚类结果

类别	占比	描述
第一类：高价值用户	32.3%	购买频率高（平均4次）；消费金额较高（平均5586元）；最近一周有过购买行为，这部分用户需要大力发展。
第二类：中价值用户	48.5%	购买频率中等（平均2.4次）；消费金额不高（平均3447）；最近一个月有个购买行为，这部分用户可以适当诱导购买。
第三类：高价值挽留用户	19.2	购买频率一般（平均2次）；消费金额较高（平均5439元）；较长时间没有购买行为，这部分客户需要尽量挽留。

参考文献：

《大数据挖掘——系统方法与实力分析》：讲述聚类方法的基本概念及k-means方法实例。
k-Means Clustering：Madlib官方文档对k-means方法的说明。
深入浅出K-Means算法：简单易懂的K-Means算法描述
基本Kmeans算法介绍及其实现：详细阐述k-means算法需要注意的问题。

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2017年08月14日，如有侵权请联系 cloudcommunity@tencent.com 删除

数据处理

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

数据处理

登录后参与评论

0 条评论

热度