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

刘 勇  Email：lyssym@sina.com

简介

　　鉴于DBSCAN算法对输入参数，邻域半径E和阈值M比较敏感，在参数调优时比较麻烦，因此本文对另一种基于密度的聚类算法OPTICS（Ordering Points To Identify the Clustering Structure）展开研究，该算法是DBSCAN的改进算法，与DBSCAN相比，该算法对输入参数不敏感。此外，OPTICS算法不显示地生成数据聚类，其只是对数据对象集合中的对象进行排序，获取一个有序的对象列表，其中包含了足够的信息能用来提取聚类。在实际的应用中，可利用该有序的对象序列，对数据的分布展开分析以及对数据的关联进行分析。

基本概念

　　由于OPTICS是对DBSCAN算法的一种改进，因此许多概念是共用的，如核心对象、（直接）密度可达、密度相连等，具体内容参考DBSCAN。在上述内容的基础上，本文再引入两个核心概念。

　　(1) 核心距离

　　在数据集合D中，对于给定的参数E和M，称使得p成为核心对象的最小邻域半径为p的核心距离。具体数学表达式如下所示：

　　通俗意义上来说，在给定的参数E和M上，p的核心距离为距离值中的第M个最小值（最大值），该距离表征可以为欧式距离、余弦相似度或Word2Vec等。

　　(2) 可达距离

　　在数据集合D中，对于给定的参数E和M，称对象p的核心距离与对象p和o距离，二者之间最大值为o关于p的可达距离。具体数学表达式如下所示：

　　程序伪代码(参考维基百科):

OPTICS(DB, eps, MinPts)
    for each point p of DB
       p.reachability-distance = UNDEFINED
    for each unprocessed point p of DB
       N = getNeighbors(p, eps)
       mark p as processed
       output p to the ordered list
       if (core-distance(p, eps, Minpts) != UNDEFINED)
          Seeds = empty priority queue
          update(N, p, Seeds, eps, Minpts)
          for each next q in Seeds
             N' = getNeighbors(q, eps)
             mark q as processed
             output q to the ordered list
             if (core-distance(q, eps, Minpts) != UNDEFINED)
                update(N', q, Seeds, eps, Minpts)


update(N, p, Seeds, eps, Minpts)
    coredist = core-distance(p, eps, MinPts)
    for each o in N
       if (o is not processed)
          new-reach-dist = max(coredist, dist(p,o))
          if (o.reachability-distance == UNDEFINED) // o is not in Seeds
              o.reachability-distance = new-reach-dist
              Seeds.insert(o, new-reach-dist)
          else               // o in Seeds, check for improvement
              if (new-reach-dist < o.reachability-distance)
                 o.reachability-distance = new-reach-dist
                 Seeds.move-up(o, new-reach-dist)

　　程序源代码：

import java.util.List;

import com.gta.cosine.ElementDict;

public class DataPoint {
    private List<ElementDict> terms;
    private double initDistance;
    private double coreDistance;
    private double reachableDistance;
    private boolean isVisited;
    
    
    public DataPoint(List<ElementDict> terms) {
        this.terms = terms;
        this.initDistance = -1;
        this.coreDistance = -1;
        this.reachableDistance = -1;
        this.isVisited = false;
    }
    
    
    public double getCoreDistance() {
        return coreDistance;
    }


    public void setCoreDistance(double coreDistance) {
        this.coreDistance = coreDistance;
    }


    public double getReachableDistance() {
        return reachableDistance;
    }


    public void setReachableDistance(double reachableDistance) {
        this.reachableDistance = reachableDistance;
    }
    
    
    public boolean getIsVisitLabel() {
        return isVisited;
    }
    
    
    public void setIsVisitLabel(boolean isVisited) {
        this.isVisited = isVisited;
    }
    
    
    public double getInitDistance() {
        return initDistance;
    }


    public void setInitDistance(double initDistance) {
        this.initDistance = initDistance;
    }


    public List<ElementDict> getAllElements() {
        return terms;
    }
    
    
    public ElementDict getElement(int index) {
        return terms.get(index);
    }
    
    
    public boolean equals(DataPoint dp)
    {
        List<ElementDict> ed1 = getAllElements();
        List<ElementDict> ed2 = dp.getAllElements();
        int len = ed1.size();
        
        if (len != ed2.size())
        {
            return false;
        }
        
        for (int i = 0; i < len; i++)
        {
            if (!ed1.get(i).equals(ed2.get(i)))
            {
                return false;
            }
        }
        return true;
    }
    
}

import java.util.Comparator;
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Queue;
import java.util.PriorityQueue;

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

public class OPTICS {
    private double            eps;
    private int               minPts;
    private TextCosine        cosine;
    private List<DataPoint>   dataPoints;
    private List<DataPoint>   orderList;
    
    public OPTICS(double eps, int minPts)
    {
        this.eps = eps;
        this.minPts = minPts;
        this.cosine = new TextCosine();
        this.dataPoints = new ArrayList<DataPoint>();
        this.orderList = new ArrayList<DataPoint>();
    }
    
    
    public void addPoint(String s)
    {
        List<ElementDict> ed = cosine.tokenizer(s);
        dataPoints.add(new DataPoint(ed));
    }
    
    
    public double coreDistance(List<DataPoint> neighbors)
    {
        double ret = -1;
        if (neighbors.size() >= minPts)
        {
            Collections.sort(neighbors, new Comparator<DataPoint>() {
                        public int compare(DataPoint dp1, DataPoint dp2) {
                            double cd = dp1.getInitDistance() - dp2.getInitDistance();
                            if (cd < 0) {
                                return 1;
                            } else {
                                return -1;
                            }
                        }
                    });
            
            ret = neighbors.get(minPts-1).getInitDistance();
        }
        return ret;
    }
    
    
    public double cosineDistance(DataPoint p, DataPoint q)
    {
        List<ElementDict> vec1 = p.getAllElements();
        List<ElementDict> vec2 = q.getAllElements();
        return cosine.analysisText(vec1, vec2);
    }
    

    public List<DataPoint> getNeighbors(DataPoint p, List<DataPoint> points)
    {
        List<DataPoint> neighbors = new ArrayList<DataPoint>();
        double countDistance = -1;
        for (DataPoint q : points)
        {
            countDistance = cosineDistance(p, q);
            if (countDistance >= eps)
            {
                q.setInitDistance(countDistance);
                neighbors.add(q);
            }
        }
        return neighbors;
    }
    
    
    public void cluster(List<DataPoint> points)
    {
        for (DataPoint point : points)
        {
            if (!point.getIsVisitLabel())
            {
                List<DataPoint> neighbors = getNeighbors(point, points);
                point.setIsVisitLabel(true);
                orderList.add(point);
                double cd = coreDistance(neighbors);
                if (cd != -1)
                {
                    point.setCoreDistance(cd);
                    Queue<DataPoint> seeds = new PriorityQueue<DataPoint>(16, new Comparator<DataPoint>() {
                            public int compare (DataPoint dp1, DataPoint dp2) {
                                double rd = dp1.getReachableDistance() - dp2.getReachableDistance();
                                if (rd < 0) {
                                    return 1;
                                } else {
                                    return -1;
                                }
                            }
                        });
                    
                    update(point, neighbors, seeds, orderList);
                    while (!seeds.isEmpty()) 
                    {
                        DataPoint q = seeds.poll();
                        List<DataPoint> newNeighbors = getNeighbors(q, points);
                        q.setIsVisitLabel(true);
                        orderList.add(q);
                        if (coreDistance(newNeighbors) != -1)
                        {
                            update(q, newNeighbors, seeds, orderList);
                        }
                    }
                }
            }
        }
    }
    
    
    public void update(DataPoint p, List<DataPoint> neighbors, Queue<DataPoint> seeds, List<DataPoint> seqList)
    {
        double coreDistance = coreDistance(neighbors);
        for (DataPoint point : neighbors)
        {
            double cosineDistance = cosineDistance(p, point);
            double reachableDistance = coreDistance > cosineDistance ? coreDistance : cosineDistance;
            if (!point.getIsVisitLabel())
            {
                if (point.getReachableDistance() == -1)
                {
                    point.setReachableDistance(reachableDistance);
                    seeds.add(point);
                }
                else
                {
                    if (point.getReachableDistance() > reachableDistance)
                    {
                        if (seeds.remove(point)) 
                        {
                            point.setReachableDistance(reachableDistance);
                            seeds.add(point);
                        }
                    }
                }
            }
            else 
            {
                if (point.getReachableDistance() == -1)
                {
                    point.setReachableDistance(reachableDistance);
                    if (seqList.remove(point))
                    {
                        seeds.add(point);
                    }
                }
            }
        }
    }
    
    
    public void showCluster()
    {
        for (DataPoint point : orderList)
        {
            
            List<ElementDict> ed = point.getAllElements();
            for (ElementDict e : ed)
            {
                System.out.print(e.getTerm() + "  ");
            }
            System.out.println();
            System.out.println("core:  " + point.getCoreDistance());
            System.out.println("reach: " + point.getReachableDistance());
            System.out.println("***************************************");
        }
    }
    
    
    public void analysis()
    {
        cluster(dataPoints);
        showCluster();
    }
    
    
    public int IndexOfList(DataPoint o, Queue<DataPoint> points)
    {
        int index = 0;
        for (DataPoint p : points)
        {
            if (o.equals(p))
            {
                break;
            }
            index ++;
        }
        return index;
    }

}

　　本文计算距离时采用余弦相似度，具体内容参考本系列之文本挖掘之文本相似度判定。此外，本文经过分析，某些（个）对象之前已被访问后，例如某个边界对象，其核心距离保持为初始值，若严格按照伪代码所示处理，其结果与DBSCAN的结果有些出入，因此本文作者对OPTICS进行了一点修改，使这类对象的可达距离能被修改，并将其添加至列表中，因此，在整体上其处理结果与DBSCAN算法的处理结果保持一致。本文作者认为这样做是有效的，而且存在一定的必要性，若有更好的解决方案，请联系我。

　　由于OPTICS算法所获取的是对象的有序列表，对后续数据分析、挖掘，具有较高的应用价值，因此，该算法可以作为数据预处理的前奏部分。但是，该算法由于需要维护优先级队列，因而在效率上有点影响。

---

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

---