其实从某种角度讲，划分聚类是完全不用赘述的一种聚类方法，可能也是最常见的聚类算法了。著名的k-means算法就是个中典型。这次的内容主要是通过k-means聚类算法来总体介绍一下划分聚类。

简单来讲，k均值聚类究竟做了什么事，我们可以这样来看，有N个数据点的集合D={x1,x2,…,xn}，每个xi代表一个特征向量，目标是将这N个点根据某种相似准则将其划分到K个分类中。而k均值所表达的重要在于相似准则的选取，即不断的使用类簇的均值来完成这样的划分。当然也有书把这种相似准则称之为评分函数。基于划分的聚类算法对于homogeneity的实现是通过选取适当的评分函数并使每一个数据点到它所属的聚类中心的距离最小化。而关键就是如何定义这种距离，和所谓的聚类中心。举个例子来讲，如果定义聚类间距离为欧式距离，那么可以使用协方差的概念来定义通用的评分函数。划分聚类的思想是最直观和易懂的分类思想，因此我也不在这里长篇介绍，还是以算法的实现和代码来直观表现划分聚类的性能。

2. 算法实现

       我们以k-means算法为例来实现划分聚类。该算法的复杂度为O(KnI)，其中I是迭代次数。这种算法的一个变体是依次分析每个数据点，而且一旦有数据点被重新分配就更新聚类中心，反复的在数据点中循环直到解不再变化。k-means算法的搜索过程局限于全部可能的划分空间的一个很小的部分。因此有可能因为算法收敛到评分函数的局部而非全局最小而错过更好的解。当然缓解方法可以通过选取随机起始点来改进搜索（我们例子中的KMPP算法），或者利用模拟退火等策略来改善搜索性能。因此，从这个角度来理解，聚类分析实质上是一个在庞大的解空间中优化特定评分函数的搜索问题。

不多说了，直接上代码吧！！！

k-means算法：

for k = 1, … , K 令 r(k) 为从D中随机选取的一个点；

while 在聚类Ck中有变化发生 do

       形成聚类：

       For k = 1, … , K do

              Ck = { x ∈ D | d(rk,x) <= d(rj,x) 对所有j=1, … , K, j != k}；

       End;

       计算新聚类中心：

       For k = 1, … , K do

              Rk = Ck 内点的均值向量

       End;

End;

具体实现部分因为有Apache Commons Math的现成代码，秉着Eric Raymond的TAOUP中的极大利用工具原则，我没有写k-means的实现，而是直接利用Apache Commons Math中的k-means plus plus代码来作为例子。

具体如何测试这一算法，给出了测试代码如下：

 1private static void testKMeansPP(){
 2
 3        //ori is sample as n instances with m features, here n=8,m=2
 4
 5       int ori[][] = {{2,5},{6,4},{5,3},{2,2},{1,4},{5,2},{3,3},{2,3}};
 6
 7       int n = 8;
 8
 9       Collection<EuclideanIntegerPoint> col = new ArrayList<EuclideanIntegerPoint>();
10
11       for(int i=0;i<n;i++){
12
13           EuclideanIntegerPoint ec = new EuclideanIntegerPoint(ori[i]);
14
15           col.add(ec);
16
17       }
18
19       KMeansPlusPlusClusterer<EuclideanIntegerPoint> km = new KMeansPlusPlusClusterer<EuclideanIntegerPoint>(new Random(n));
20
21       List<Cluster<EuclideanIntegerPoint>> list = new ArrayList<Cluster<EuclideanIntegerPoint>>();
22
23       list = km.cluster(col, 3, 100);
24
25       output(list);
26
27    }
28
29private static void output(List<Cluster<EuclideanIntegerPoint>> list){
30
31       int ind = 1;
32
33       Iterator<Cluster<EuclideanIntegerPoint>> it = list.iterator();
34
35       while(it.hasNext()){
36
37           Cluster<EuclideanIntegerPoint> cl = it.next();
38
39           System.out.print("Cluster"+(ind++)+" :");
40
41           List<EuclideanIntegerPoint> li = cl.getPoints();
42
43           Iterator<EuclideanIntegerPoint> ii = li.iterator();
44
45           while(ii.hasNext()){
46
47              EuclideanIntegerPoint eip = ii.next();
48
49              System.out.print(eip+" ");
50
51           }
52
53           System.out.println();
54
55       }
56
57    }
58
59    /** *//**
60
61    *@param args
62
63    */
64
65    public static void main(String[] args) {
66
67       //testHierachicalCluster();
68
69       testKMeansPP();
70
71       //testBSAS();
72
73       //testMBSAS();
74
75    }
76
77

3. 小结

       划分聚类是聚类分析中最常用的一种聚类算法了，对于其研究的论文也是多如牛毛。感兴趣的朋友们完全可以通过阅读各种相关论文来感受这一算法的美妙。当然还要再次感谢Apache Commons Math对于诸多常用数学计算的实现。对于聚类分析的总结学习暂时到此告一段落，最近要忙着写论文，等过段时间有空可以考虑继续聚类算法的研究学习。

4. 参考文献及推荐阅读

[1]PatternRecognitionThird Edition, Sergios Theodoridis, Konstantinos Koutroumbas

[2]模式识别第三版, Sergios Theodoridis, Konstantinos Koutroumbas著, 李晶皎, 王爱侠, 张广源等译

[3]数据挖掘原理, David Hand and et al, 张银奎等译

[4]http://commons.apache.org/math/

1.    顺序聚类

事实上，将n个对象，聚类到k个聚类中这件事本身是一个NP难问题。熟悉组合数学应该知道这个问题的解事第二类Stirling数：。这样问题也就出现了，如果k值固定，那么计算还是可行的，如果k值不固定，就要对所有的可能k都进行计算，那运行时间可想而知了。然而并不是所有的可行聚类方案都是合理的，所谓的合理，我理解就是说接近你的聚类目标的，之所以我们要分类，必然有初始动机，那么可以根据这个动机制定可行的聚类方案，这样，复杂度的问题就回避了。

顺序算法（sequential algorithms）是一种非常简单的聚类算法，大多数都至少将所有特征向量使用一次或几次，最后的结果依赖于向量参与算法的顺序。这种聚类算法一般是不预先知道聚类数量k的，但有可能给出一个聚类数上界q。本文将主要介绍基本顺序算法（Basic Sequential Algorithmic Scheme,BSAS）和其几个变种，并给出代码实现。

首先看BSAS，这个算法方案需要用户定义参数：不相似性阈值θ和允许的最大聚类数q。算法的基本思想：由于要考虑每个新向量，根据向量到已有聚类的距离，将它分配到一个已有的聚类中，或者一个新生成的聚类中。算法的伪码描述如下：

1.       m=1   /*{聚类数量}*/

2.       C_m={x₁}

3.       For i=2 to N

4.           找C_k: d(x_i,C_k)=min_1£j£md(x_i,C_j)

5.           If (d(x_i,C_k)>Θ) AND (m<q) then

6.               m=m+1

7.               C_m={x_i}

8.           Else

9.               C_k=C_kÈ{x_i}

10.           如果需要，更新向量表达

11.       End {if}

12.   End {for}

由上面的描述可以看出BSAS算法对向量顺序非常依赖，无论是聚类数量还是聚类本身，不同的向量顺序会导致完全不同的聚类结果。另一个影响聚类算法结果的重要因素是阈值θ的选择，这个值直接影响最终聚类的数量，如果θ太小，就会生成很多不必要的聚类，因为很多情况下向量与聚类的合并条件都受到θ的限制，而如果θ太大，则聚类数量又会不够。BSAS比较适合致密聚类，其对数据集进行一次扫描，每次迭代中计算当前向量与聚类间的距离，因为最后的聚类数m被认为远小于N，故BSAS的时间复杂度为O(N)。

由于BSAS算法依赖于q，因此这里介绍一种自动估计聚类数q的简单方法，该方法也适用于其他的聚类算法，令BSAS(Θ)为具有给定不相似阈值θ的BSAS算法。

1.       For Θ=a to b step c

2.          算法BSAS(Θ)执行s次，每一次都使用不同的顺序表示数据。

3.          估计聚类数，m_Θ作为从s次BSAS(Θ)算法得来的最常出现的聚类数。

4.       Next Θ

其中a和b是数据集的所有向量对的最小和最大不相似级别，c的选择直接受d(x,C)的影响。

2. 算法实现

package util.clustering;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

/** *//**
 * @author Jia Yu
 *
 */
public class BSAS <T extends Clusterable<T>> {

    /** *//**
     * Basic Sequential Algorithmic Scheme
     * 适用于致密聚类
     */
    
    public BSAS() {
    }
    
    /** *//**
     * Basic Sequential Algorithmic Scheme
     * 考虑样本空间中每个向量，根据向量到已有的聚类中心的距离，将它分配到一个已有聚类中，或者一个新生成的聚类中。
     * time complexity is O(N)
     * BSAS算法对整个数据集只进行一次扫描。
     * @param points 待聚类的向量
     * @param Phi 用户定义的不相似性阈值
     * @param q 用户定义的允许的最大聚类数
     * @return
     */
    public List<Cluster<T>> cluster(final Collection<T> points,final double Phi,final int q){
        int m = 0;
        int n = points.size();
        double disOfXandCj = 0;
        double disOfXandCk;
        List<T> ptList = new ArrayList<T>(points);
        Cluster<T> C = new Cluster<T>(ptList.get(m));
        C.addPoint(ptList.get(m));
        Cluster<T> Ck = C;
        List<Cluster<T> > cList = new ArrayList<Cluster<T> >();
        cList.add(C);
        for(int i=1;i<n;i++){
            disOfXandCk = Double.MAX_VALUE;
            Iterator<Cluster<T> > cListIt = cList.iterator(); 
            while(cListIt.hasNext()){
                Cluster<T> Cj = cListIt.next();
                disOfXandCj = getDisOfPointAndCluster(ptList.get(i),Cj);
                if(disOfXandCk > disOfXandCj){
                    disOfXandCk = disOfXandCj;
                    Ck = Cj;
                }
            }
            if(disOfXandCk > Phi && m < q){            //不满足条件，则产生新的聚类
                m++;
                Cluster<T> cm = new Cluster<T>(ptList.get(i));
                cm.addPoint(ptList.get(i));
                cList.add(cm);
            }
            else{            //满足条件的将点加入已有聚类，并更新聚类中心
                if(cList.contains(Ck))
                    cList.remove(Ck);
                Ck.addPoint(ptList.get(i));
                final T newCenter = Ck.getCenter().centroidOf(Ck.getPoints());
                Cluster<T> tempCluster = new Cluster<T>(newCenter);
                for(int j=0;j<Ck.getPoints().size();j++){
                    tempCluster.addPoint(Ck.getPoints().get(j));
                }
                cList.add(tempCluster);
            }
        }
        return cList;
    }

    /** *//**
     * 选择不同的测度，有不同的算法。
     * 这里默认dis(x,C)为点到聚类中心的距离。
     */
    private double getDisOfPointAndCluster(T t, Cluster<T> cj) {
        return t.distanceFrom(cj.getCenter());
    }

}

3. 程序框架

       我的聚类程序主要扩展自Apache Commons Math开源框架，下面是其结构，我简单加入了Clusterer类作为抽象模板类，使用模板方法模式修改了框架，为后续加入的例如BSAS算法提供模板。

4. 小结

       顺序算法简单易实现，对于学习聚类来说是入门的最好选择，考虑到篇幅的限制，不能将代码全部发上来，如果有需要可以向我索要，Apache Commons Math框架可以到Apache的网站上下载。另外还有很多介绍不够详细，感兴趣的朋友可以继续深入研究BSAS的扩展。

5. 参考文献及推荐阅读

[1]Pattern Recognition Third Edition, Sergios Theodoridis, Konstantinos Koutroumbas

[2]模式识别第三版, Sergios Theodoridis, Konstantinos Koutroumbas著, 李晶皎, 王爱侠, 张广源等译

“数学上，测度(Measure)是一个函数，它对一个给定集合的某些子集指定一个数，这个数可以比作大小、体积、概率等等。传统的积分是在区间上进行的，后来人们希望把积分推广到任意的集合上，就发展出测度的概念，它在数学分析和概率论有重要的地位”                                          ——wikipedia

聚类之前一定要定义好向量之间的相似程度——即近邻测度。在聚类过程中我们使用的测度，范围要更广泛，首先定义向量之间的测度，接着就是集合与向量，集合之间的测度。

对于X上的不相似测度(Dissimilarity Measure, DM) d 是一个函数： 其中R是实数集合，如果d有以下的属性：

     （1.1）

               （1.2）

               （1.3）

如果又满足

                 （1.4）

                （1.5）

那么d被称为度量DM。其中的公式（1.5）也叫三角不等式。稍稍解释一下（其实太好理解了），不相似性测度其实就像我们说的距离一样，两个向量代表两个对象好了。公式1.2定义（向量）对象自己和自己的距离是d₀；公式1.1说明了任意两个对象之间的距离要小于正无穷却大于自己和自己的距离（你和别人的距离大于你和自己的距离，这不废话吗＾＿＾）；公式1.3说明距离的交互性；公式1.4不解释了，公式1.5就是三角不等式（初中水平）。

同理相似性测度(Similarity Measure, SM)定义为满足：

         （1.6）

        （1.7）

         （1.8）

如果又满足

          （1.9）

           （1.10）

就把s叫做度量SM。具体同DM，各公式的表达一目了然哦~~~

从定义和字面上我们都可以看出二者的不同，在表达相似性时两者都可以，只不过度量的角度不同，对于判别相似，DM越大说明越不相似，越小则越相似，而SM却正好相反，因此我们也可以联想，DM与SM可以利用这种对立关系来定义。举例来说，如果d是一个DM，那么s=1/d就是一个SM。

2. 向量之间的近邻测度

上面的定义只是一个宏观的概括，那么具体的向量之间的测度如何计算呢？下面将详细的介绍。

首先对于实向量的不相似测度，实际应用中最通用的就是加权l_p度量了：

          （2.1）

其中的x_i和y_i分别是向量x和y中的第i个值，w_i是第i个权重系数，l是向量的维数（以下公式定义同）。而我们比较感兴趣的就是当p=1时，该度量就是加权Manhattan范数，而当p=2时就是加权欧几里得范数，当p=∞时就是max_1£i£l w_i|x_i-y_i|了。根据这些DM，我们定义SM为b_max - d_p(x,y)。

另外还有一些其他的定义方法，比如

            （2.2）

          （2.3）

其他懒得列出了，先查阅资料，这里不详述了。

对于实向量的相似性测度，实际中常用的有：

内积：          （2.4）

Tanimoto测度：           （2.5）

其他：           （2.6）

------------------------------------------------take a nap------------------------------------------------------------

对于离散值的向量，首先必须要搞清楚一个概念，这里在《模式识别》的中文译作中我感觉翻译的并不好理解，所以这里展开说明一下，那就是一个叫做相依表(contingency table)的概念。对于一个向量x，其元素值属于有限集F={0,1,…,k-1}，其中k是正整数。令A(x,y)=[a_ij], i, j=0,1,…,k-1是一个k阶方阵，其中元素a_ij代表在x中所有i值所在的位置在y的同样位置有j值的个数。附原文：the number of places where x has the i-th symbol and y has the j-th symbol。举例来说吧，k=3，且x=[0,1,2,1,2,1]，y=[1,0,2,1,0,1]，那么A(x,y) = [0 1 0, 1 2 0, 1 0 1]。以第一个0(a₀₀)为例说明，0在A中的位置决定i=0，j=0，在x中0所在的位置是第一个位置，而y中0所在的位置为第二个和第五个，两个向量中没有相同位置上的相同0元素，因此A中第一个元素a₀₀为0，而A中第二个为1(a₀₁)，所以i=0，j=1，在x中0所在的位置是第一个，而y中1所在的位置为第一、四、六个，因此有一个相同，所以a₀₁=1。

关于计算矩阵A这里附加java代码实现，可参考：

 1/** *//**
 2     * 
 3     * @param k
 4     *            the number of finite set F
 5     * @param x
 6     *            the vector x belongs to F^l
 7     * @param y
 8     *            the vector y belongs to F^l
 9     * @return the contingency table A
10     * @author $Jia Yu
11     */
12    public Integer[][] calContingencyTable(Integer k, Vector<Integer> x,
13            Vector<Integer> y) {
14        if (x.size() != y.size())
15            throw new IllegalArgumentException(
16                    "The two vectors are not the same size!");
17        Integer[][] A = new Integer[k][k];
18        Integer count_ij;
19        for (int i = 0; i < k; i++) {
20            for (int j = 0; j < k; j++) {
21                count_ij = 0;
22                for (int xi = 0; xi < x.size(); xi++) {
23                    if (x.elementAt(xi).equals(i) && y.elementAt(xi).equals(j))
24                        count_ij++;
25                }
26                A[i][j] = count_ij;
27            }
28        }
29        return A;
30    }

有了相依表的定义，可以定义离散向量之间的不相似性测度了。

汉明距离：          （2.7）

L1距离：              （2.8）

同样，相似性测度有

Tanimoto测度：             （2.9）

其中的n_x( n_y)表示x(y)中非零元素的个数。

书本往往教给我们的是基础而不是应用，这些基础知识在实际应用中才会得到更多的改进和变化。也许我们不会简单的在聚类中应用这些测度概念，但是复杂的组合都是来源于基础。因此，对测度的基础概念一定要牢牢把握。在前一阶段做图像分割时，聚类算法执行的前提之一测度，我就做过多个实验，L1和L2范数，Tanimoto测度等。当然不同的图像特征有不同的计算距离方法，总之实际的经验告诉我，基础扎实后，在应用起来是相当的顺手啊~~~（最起码不会被复杂公式吓到）

3. 特殊情况处理

       考虑到实例向量的特征类型往往是复杂混合的，这种情况下，如何计算近邻测度呢？一些偷懒的做法就是将所有值都看作是实值类型，把混合向量当作实向量来处理。但是现实使用中，这样做的效果往往差强人意。考虑将实值类型转换成离散类型，这就是著名的离散化了，特征的离散化操作时特征或属性过滤(filter)的一个重要的方面。当然我最推荐的还是基于自己开发的应用场景，设计相关的近邻测度。这样可能通用性比较差，但是如果是问题驱动的话，或者目标驱动，那么这个作为一个solution也不失优良性。当然引入模糊测度的概念也是一种解决方法，这里就不细说了，具体应用可以参看有关模糊和不确定性的文章。另外一点需要说明就是实例向量中部分特征丢失的情况，对于丢失数据，如果我们知道数据的分布，那么合理假设是一个替代方案，但是如果为了省事，常用的做法是直接丢弃该实例向量，或者好点的做法是取所有实例的平均数据作为该维度的替代数据。

4. 点与集合之间的测度

       随着聚类过程的不断进行，层次逐渐深入，聚类已经不仅仅是判断点与点之间的相似程度了，点与集合的相似程度也需要计算。而如何定义向量x和聚类C之间的近邻性，从而判断是否将x归类为C。以下三个定义经常用到。

最大近邻函数Max proximity function：           （4.1）

最小近邻函数Min proximity function：           （4.2）

平均近邻函数Average proximity function：       （4.3）

其中n_c是集合C的势。

       可以看到，这样的定义在概念理论层次上仍旧将点视作点，将聚类视作集合。另一种情况则是将聚类视作一个点，因为点与点之间的近邻测度已经可以计算，那么将集合视为一个点，就将这个问题归约到了点与点之间的问题了。对聚类进行表达，主要有以下几种表达：

1）    点表达：将聚类视作一个点，可以是均值点(mean vector)，也可以是均值中心(mean center)，也可以是中值中心(median center)。关于这几个概念和公式，任何的统计教材里都有涉猎，我就不一一枚举了。（主要贴公式真的很累，怀念Tex）

2）    超平面表达：线性聚类中常用。不表。有兴趣者去查资料。

3）    超球面表达：球形聚类中常用。同上。

一切的学习都为应用，根据实际应用的不同，我们在定义这种点与集合之间测度时候也有很大的灵活性。

5. 集合与集合之间的测度

同样的，对于集合与集合的测度，可以同点与集合的测度类似。只要记住一点，那就是集合与集合间的近邻测度是建立在点与点之间的测度的基础上的。所以近邻测度的基础在点与点之间。当然聚类结果的优化是一个反复试验的过程，其中也要考虑领域专家的意见。

6. 小结

对于近邻测度的学习，乍一看像是纯数学知识的学习，其实则是对我们开始聚类算法研究之前的一个夯实基础的复习过程。

7. 参考文献及推荐阅读

[1]Pattern Recognition Third Edition, Sergios Theodoridis, Konstantinos Koutroumbas

[2] http://zh.wikipedia.org/wiki/%E6%B5%8B%E5%BA%A6%E8%AE%BA

[3]模式识别第三版, Sergios Theodoridis, Konstantinos Koutroumbas著, 李晶皎, 王爱侠, 张广源等译

传说：“聚类是人类最原始的精神活动，用于处理他们每天接收到的大量信息”。为方便广大同学学习使用，将我学习聚类时的笔记整理发布共享。

1. 聚类定义

“聚类是把相似的对象通过静态分类的方法分成不同的组别或者更多的子集（subset）,这样让在同一个子集中的成员对象都有相似的一些属性。”                                                          ——wikipedia

“聚类分析指将物理或抽象对象的集合分组成为由类似的对象组成的多个类的分析过程。它是一种重要的人类行为。聚类是将数据分类到不同的类或者簇这样的一个过程，所以同一个簇中的对象有很大的相似性，而不同簇间的对象有很大的相异性。”                          ——百度百科

说白了，聚类（clustering）是完全可以按字面意思来理解的——将相同、相似、相近、相关的对象实例聚成一类的过程。简单理解，如果一个数据集合包含N个实例，根据某种准则可以将这N个实例划分为m个类别，每个类别中的实例都是相关的，而不同类别之间是区别的也就是不相关的，这个过程就叫聚类了。

形式化一点，令，其中的x都是向量，一个X的m聚类R将X分割为m个集合C₁, C₂,…,C_m，使其满足下面三个条件：

（1）

（2）

（3）

满足上述条件的同时，在聚类C_i中的向量彼此相似，而与其他类中的向量不相似。

但是这种定义也只是定义了确定性的聚类，也叫做硬聚类(hard clustering)，每个实例x都确定的属于某个聚类。而不确定性聚类，也需要定义，这就引出了模糊聚类(fuzzy clustering)的概念了。模糊聚类中，每个实例向量x以一定的隶属度属于某个聚类。同上面的设置，X的模糊聚类是将X分成m个类，由m个函数u_j表示，其中满足：

（1）

（2）

（3）

其中这个隶属度函数越接近1，说明x_i越可能属于C_i，反之如果越接近0，则说明越不可能属于C_i。

2. 聚类过程

当我们知道聚类是什么时，我们下一步想知道的应该是怎么进行聚类。这一点，教材上做了详细介绍，补充一点自己理解：

1）特征选择(feature selection)：就像其他分类任务一样，特征往往是一切活动的基础，如何选取特征来尽可能的表达需要分类的信息是一个重要问题。表达性强的特征将很影响聚类效果。这点在以后的实验中我会展示。

2）近邻测度(proximity measure)：当选定了实例向量的特征表达后，如何判断两个实例向量相似呢？这个问题是非常关键的一个问题，在聚类过程中也有着决定性的意义，因为聚类本质在区分相似与不相似，而近邻测度就是对这种相似性的一种定义。

3）聚类准则(clustering criterion)：定义了相似性还不够，结合近邻测度，如何判断相似才是关键。直观理解聚类准则这个概念就是何时聚类，何时不聚类的聚类条件。当我们使用聚类算法进行计算时，如何聚类是算法关心的，而聚与否需要一个标准，聚类准则就是这个标准。（话说标准这东西一拿出来，够吓人了吧^_^）

4）聚类算法(clustering algorithm)：这个东西不用细说了吧，整个学习的重中之重，核心的东西这里不讲，以后会细说，简单开个头——利用近邻测度和聚类准则开始聚类的过程。

5）结果验证(validation of the results)：其实对于PR的作者提出这个过程也放到聚类任务流程中，我觉得有点冗余，因为对于验证算法的正确性这事应该放到算法层面吧，可以把4）和5）结合至一层。因为算法正确和有穷的验证本身就是算法的特性嘛。（谁设计了一个算法不得证明啊）

6）(interpretation of the results)：中文版的PR上翻译为结果判定，而我感觉字面意思就是结果解释。（聚类最终会将数据集分成若干个类，做事前要有原则，做事后要有解释，这个就是解释了。自圆其说可能是比较好的了^_^）

整个聚类任务详细的东西会在以后详细介绍，这里先细说一下聚类准则（虽然我感觉在上面我说的已经够细了）。举例吧，比如，有这样一个数据集X，包含了四名同学的基本信息和数学成绩。

聚类准则就是一个分类标准，对于示例中这样一个数据集合，如何聚类呢。当然聚类的可能情况有很多。比如，如果我们按照年级是否为大于1来分类，那么数据集X分为两类：{张三}，{李四，张飞，赵云}；如果按照班级不同来分，分为两类：{张三，李四}，{张飞，赵云}；如果按照成绩是否及格来分（假设及格为60分），分两类：{张三，李四，赵云}，{张飞}。当然聚类准则的设计往往是复杂的，就看你想怎么划分了。按照对分类思想的几何理解，数据集相当于样本空间，数据实例的特征数（本例共有4个特征[姓名，年级，班级，数学成绩]）相当于空间维度，而实例向量对应到空间中的一个点。那么聚类准则就应该是那些神奇的超平面（对应有数学函数表达式，我个人认为这些函数就等同于聚类准则），这些超平面将数据“完美的”分离开了。

3. 聚类特征类型

聚类时用到的特征如何区分呢，有什么类型要求？聚类的特征按照域划分，可以分为连续的特征和离散特征。其中连续特征对应的定义域是数据空间R的连续子空间，而离散特征对应的是离散子集，另外如果离散特征只包含两个特征值，那么这个离散特征又叫二值特征。

       根据特征取值的相对意义又可以将特征分为以下四种：标量的(Nominal)，顺序的(Ordinal)，区间尺度的(Interval-scaled)以及比率尺度的(Ratio-scaled)。其中，标量特征用于编码一类特征的可能状态，比如人的性别，编码为男和女；天气状况编码为阴、晴和雨等。顺序特征同标量特征类似，同样是一系列状态的编码，只是对这些编码稍加约束，即编码顺序是有意义的，比如对一道菜，它的特征有{很难吃，难吃，一般，好吃，美味}几个值来定义状态，但是这些状态是有顺序意义的。这类特征我认为就是标量特征的一个特定子集，或者是一个加约束的标量特征。区间尺度特征表示该特征数值之间的区间有意义而数值的比率无意义，经典例子就是温度，A地的温度（20℃）比B地（15℃）高5度，这里的区间差值是有意义的，但你不能说A地比B地热1/3，这是无意义的。比率特征与此相反，其比率是有意义的，经典例子是重量，C重100g，D重50g，那么C比D重2倍，这是有意义的。（当然说C比D重50g也是可以的，因此可以认为区间尺度是比率尺度的一个真子集）。

       在常见应用中，包括我们平日关心的编程实现中，一般只定义nominal特征和numeric特征，其中nominal可以用string来表示，而numeric可以用number来表示。（weka中的attribute的特征类型就是这么定义的）

4. 聚类分析的应用

       说了这么多基本概念，最实际的话题莫过于应用了。就像为聚类做广告一样，到底我们可以在哪里应用它呢。就像引言里我提到的传说一样，分类作为人类识别对象的一个基本活动大概与人类的意识共同存在着，也可以说人类智能认识的本质活动之一就是分类。而研究者对分类的研究又将分类划分为有监督与无监督，其中聚类就是无监督分类的最常用方法也是绝对代表性方法。设想一下，对于一组数据，或者一堆信息，计算机可以自动地将其分为若干类，那这对于辅助人类智能来说绝对是必要的也是有意义的。所以聚类的一个核心应用就是数据挖掘与模式识别。另外各个科学领域只要涉及到分类的任务，大家无不联想到聚类~~~（话说我第一次正式地解除聚类，还是在23教学楼听一个貌似是自动化的教授讲的信息化课程）。而学者比较权威的分类将聚类的应用分为四个基本的方向：1）数据去冗，即将海量数据中的冗余信息去除。2）假说生成，为了推导出数据的某些性质，我们可以对数据进行聚类分析。3）假说检验，其实就是通过聚类分析来验证某个决策的风险程度。4）基于分组的预测，同所有预测任务一样，将已有的数据都聚类分类后，新的未来数据可以用同样的规则进行识别预测其所属分类。

       聚类的应用非常广泛，如果按科目枚举，我是懒得罗列了。只要知道了其原理和目标，其应用领域也就自然理解了。

5. 小结

聚类的基本概念就是这么些了，关于聚类的学习和研究已经历经几十年，可以庆幸的一点是这里的学习我们可以站在很多巨人的肩膀上，而如何去改进创新扩展应用，那就是我们未来的目的，“工欲善其事，必先利其器”，这里聚类就是我们的“器”了。

6. 参考文献及推荐阅读

[1]Pattern Recognition Third Edition, Sergios Theodoridis, Konstantinos Koutroumbas

[2] http://baike.baidu.com/view/903740.htm?fr=ala0_1_1

[3] http://zh.wikipedia.org/zh-cn/%E6%95%B0%E6%8D%AE%E8%81%9A%E7%B1%BB

[4]数据挖掘概念与技术(Data mining concepts and techniques) Jiawei Han, Micheline Kamber著范明, 孟小峰译

[5]模式识别第三版, Sergios Theodoridis, Konstantinos Koutroumbas著, 李晶皎, 王爱侠, 张广源等译

[6]数据挖掘导论(Introduction to data mining) Pang-Ning Tan, Michael Steinbach, Vipin Kumar著范明, 范宏建等译

[7]数据挖掘实用机器学习技术 (Data mining practical machine learning tools and techniques) Ian H.Witten, Eibe Frank著董琳等译



文章转载请标明~~~