文本挖掘之文本聚类（DBSCAN）

刘 勇   Email：lyssym@sina.com

简介

　　鉴于基于划分的文本聚类方法只能识别球形的聚类，因此本文对基于密度的文本聚类算法展开研究。DBSCAN(Density-Based Spatial Clustering of Applications with Noise)是一种典型的基于密度的聚类方法，可以找出形状不规则的聚类，而且聚类时无需事先知道聚类的个数。

基本概念

　　DBSCAN算法中有两个核心参数：Eps和MinPts(文献与程序中经常使用)。前者定义为邻域半径，后者定义为核心对象的阈值。本文为了描述方便，下文将Eps和MinPts分别简记为E和M。

　　(1)   E 邻域：给定对象半径E内的区域成为该对象的E邻域。该E邻域为球形，其半径的界定可以采用距离（欧式距离）、余弦相似度、Word2Vec等表征，本文实现采用余弦相似度来表征。

　　(2)   核心对象：若给定对象E 邻域内的对象（样本点）个数大于等于M，则称该对象为核心对象。

　　(3)   直接密度可达：给定一个对象集合D，若对象p在q的E 邻域内，且q是一个核心对象，则称对象p从对象q出发是直接密度可达的（directly density-reachable）。

　　(4)   密度可达：给定一个对象集合D，若存在一个对象链p1，p2，p3，...，pn，p1=q，pn=p，对于pi属于D，i属于1~n，p（i+1）是从pi关于E和M直接密度可达的，则称对象p从对象q关于E和M密度可达的。

　　(5)   密度相连：给定一个对象集合D，若存在对象o属于D，使对象p和q均从o关于E和M密度可达的，那么对于对象p到q是关于E和M密度相连的。

　　(6)   边界对象：给定一个对象集合D，若核心对象p中存在对象q，但是q对象自身并非核心对象，则称q为边界对象。

　　(7)   噪声对象：给定一个对象集合D，若对象o既不是核心对象，也不是边界对象，则称o为噪声对象。

图1 集合对象

　　如图1所示，其设定M=3，红色节点为核心对象，黄色节点为边界节点，蓝色为噪声节点。

　　DBSCAN算法不仅能对对象进行聚类，同时还能识别噪声对象，即不属于任何一个聚类。需要指出：密度可达是直接密度可达的传递闭包，这种关系是非对称的，只有核心对象之间相互密度可达；但是，密度相连是一种对称的关系。

　　DBSCAN的核心思想：寻找密度相连的最大集合，即从某个选定的核心对象（核心点）出发，不断向密度可达的区域扩张，从而得到一个包含核心对象和边界对象的最大化区域，区域中任意两点密度相连。

　　算法伪代码（参考维基百科）：

 DBSCAN(D, eps, MinPts) {
    C =
    for each point P in dataset D {
       if P is visited
          continue next point
       mark P as visited
       NeighborPts = regionQuery(P, eps)
       if sizeof(NeighborPts) < MinPts
          mark P as NOISE
       else {
          C = next cluster
          expandCluster(P, NeighborPts, C, eps, MinPts)
       }
    }
 }

 expandCluster(P, NeighborPts, C, eps, MinPts) {
    add P to cluster C
    for each point P' in NeighborPts {
       if P' is not visited {
          mark P' as visited
          NeighborPts' = regionQuery(P', eps)
          if sizeof(NeighborPts') >= MinPts
             NeighborPts = NeighborPts joined with NeighborPts'
       }
       if P' is not yet member of any cluster
          add P' to cluster C
    }
 }

 regionQuery(P, eps)
    return all points within P's eps-neighborhood (including P)

　　程序源代码如下：

 import java.util.List;

 import com.gta.cosine.ElementDict;

 public class DataNode {
     private List<ElementDict> terms;
     private boolean isVisited;
     private int category;

     public DataNode(List<ElementDict> terms)
     {
         this.terms = terms;
         this.isVisited = false;
         this.category = 0;
     }

     public void setVisitLabel(boolean isVisited)
     {
         this.isVisited = isVisited;
     }

     public void setCatagory(int category)
     {
         this.category = category;
     }

     public boolean getVisitLabel()
     {
         return isVisited;
     }

     public int getCategory()
     {
         return category;
     }

     public List<ElementDict> getAllElements()
     {
         return terms;
     }

 }

 import java.util.List;
 import java.util.ArrayList;

 import com.gta.cosine.TextCosine;
 import com.gta.cosine.ElementDict;

 public class DBScan {
     private double         eps;
     private int            minPts;
     private TextCosine     cosine;
     private int            threshold;
     private List<DataNode> dataNodes;
     private int            delta;

     public DBScan()
     {
         this.eps = 0.20;
         this.minPts = 3;
         this.threshold = 10000;
         this.cosine = new TextCosine();
         this.delta = 0;
         dataNodes = new ArrayList<DataNode>();
     }

     public DBScan(double eps, int minPts, int threshold)
     {
         this.eps = eps;
         this.minPts = minPts;
         this.threshold = threshold;
         this.cosine = new TextCosine();
         this.delta = 0;
         dataNodes = new ArrayList<DataNode>();
     }

     public void setThreshold(int threshold)
     {
         this.threshold = threshold;
     }

     public int getThreshold()
     {
         return threshold;
     }

     public double getEps()
     {
         return eps;
     }

     public int getMinPts()
     {
         return minPts;
     }

     public List<DataNode> getNeighbors(DataNode p, List<DataNode> nodes)
     {
         List<DataNode> neighbors = new ArrayList<DataNode>();
         List<ElementDict> vec1 = p.getAllElements();
         List<ElementDict> vec2 = null;
         double countDistance = 0;
         for (DataNode node : nodes)
         {
             vec2 = node.getAllElements();
             countDistance = cosine.analysisText(vec1, vec2);
             if (countDistance >= eps)
             {
                 neighbors.add(node);
             }
         }
         return neighbors;
     }

     public List<DataNode> cluster(List<DataNode> nodes)
     {
         int category = 1;
         for (DataNode node : nodes)
         {
             if (!node.getVisitLabel())
             {
                 node.setVisitLabel(true);
                 List<DataNode> neighbors = getNeighbors(node, nodes);
                 if (neighbors.size() < minPts)
                 {
                     node.setCatagory(-1);
                 }
                 else
                 {
                     node.setCatagory(category);
                     expandCluster(neighbors, category, nodes);
                 }
             }
             category ++;
         }

         return nodes;
     }

     public void expandCluster(List<DataNode> neighbors, int category, List<DataNode> nodes)
     {
         for (DataNode node : neighbors)
         {
             if (!node.getVisitLabel())
             {
                 node.setVisitLabel(true);
                 List<DataNode> newNeighbors = getNeighbors(node, nodes);
                 if (newNeighbors.size() >= minPts)
                 {
                     expandCluster(newNeighbors, category, nodes);
                 }
             }

             if (node.getCategory() <= 0)   // not be any of category
             {
                 node.setCatagory(category);
             }
         }
     }

     public void showCluster(List<DataNode> nodes)
     {
         for (DataNode node : nodes)
         {
             List<ElementDict> ed = node.getAllElements();
             for (ElementDict e: ed)
             {
                 System.out.print(e.getTerm() + "  ");
             }
             System.out.println();
             System.out.println("所属类别： "+ node.getCategory());
         }
     }

     public void addDataNode(String s)
     {
         List<ElementDict> ed = cosine.tokenizer(s);
         DataNode dataNode = new DataNode(ed);
         dataNodes.add(dataNode);
         delta ++;
     }

     public void analysis()
     {
         if (delta >= threshold)
         {
             showCluster(cluster(dataNodes));
             delta = 0;
         }
     }
 }

　　关于计算余弦相似度及其源代码，见本系列之文本挖掘之文本相似度判定。本文考虑到随着文本数量的递增，文本聚类结果会分化，即刚开始聚类的文本与后面文本数据相差甚远，本文非常粗略地采用门限值进行限定，本文后续系列联合KMeans和DBSCAN进行解决，若有更好的方法，请联系我。

　　需要指出：DBSCAN算法对输入参数E和M非常敏感，即参数稍有变化，其聚类结果则会有明显变化。此外，对E和M的选择在实际应用中，需要大规模数据集调优选择（小数据集另当别论），同时对该算法进行改进也是重要研究方向。

---

　　作者：志青云集
　　出处：http://www.cnblogs.com/lyssym
　　如果，您认为阅读这篇博客让您有些收获，不妨点击一下右下角的【推荐】。
　　如果，您希望更容易地发现我的新博客，不妨点击一下左下角的【关注我】。
　　如果，您对我的博客所讲述的内容有兴趣，请继续关注我的后续博客，我是【志青云集】。
　　本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接。

---