基本凝聚层次聚类算法

最新推荐文章于 2025-02-27 23:29:31 发布

Xxy_

最新推荐文章于 2025-02-27 23:29:31 发布

阅读量1w

点赞数

分类专栏： JAVA 文章标签：算法

本文链接：https://blog.youkuaiyun.com/xxy0118/article/details/54408715

版权

JAVA 专栏收录该内容

4 篇文章

订阅专栏

一、基本凝聚层次聚类算法

1：如果需要，计算近邻度矩阵

2：repeat

2.1：合并最接近的两个簇

2.2：更新近邻性矩阵，以反映新的簇与原来的簇之间的近邻性

3：until 仅剩下一个簇

存储近邻度个数：m²/2,m位数据点个数。

时间复杂度：O(m²log m)，其中，t为迭代次数，K为簇的数目，m为记录数，n为维数

空间复杂度：O(m²)，其中，K为簇的数目，m为记录数，n为维数

二、详细内容

2.1 簇之间的近邻性

基本凝聚层次聚类算法的关键操作就是计算两个簇之间的近邻度，并且正是簇的近邻性定义区分了各种凝聚层次技术。

(1)单链(MIN):定义簇的邻近度为不同两个簇的两个最近的点之间的距离。

(2)全链(MAX):定义簇的邻近度为不同两个簇的两个最远的点之间的距离。

(3)组平均：定义簇的邻近度为取自两个不同簇的所有点对邻近度的平均值。

(4)基于原型的观点：簇用质心代表，计算邻近度。

(5)Ward方法：也假定簇用其质心表示，但它使用合并两个簇导致的SSE增加来度量两个簇之间的近邻性。试图最小化点到其簇质心的距离的平方和。

2.2 簇邻近度的Lance-Williams公式

本文讨论的任何簇邻近度都可以看作簇Q和R之间邻近度的不同参数的Lance-Williams公式的一种选择，其中R是通过合并簇A和B形成的。

Lance-Williams公式：

p(R,Q)=αAp(A,Q)+αBp(B,Q)+βp(A,B)+γ|p(A,Q)−p(B,Q)|

A、B、Q合并得到R。p(. , .)是邻近度函数，以上表示它们为线性函数。下面是Lance-Williams公式的系数值：

2.3 主要问题

1.缺乏全局目标函数

这种方法生产的聚类算法避开了解决困难的组合优化问题。

2.如何处理待合并的簇对的相对大小

这个问题值适用于涉及求和的簇临近性方案，如质心，Ward方法和组平均。

有两种方法：加权方法，平等地对待所有簇；非加权方法考虑每个簇的点数。换言之，平等地对待不同大小的簇表示赋予不同簇中的点不同的权值，而考虑簇的大小则赋予不同簇中的点相同的权值。

3.合并决策是最终的

凝聚层次聚类算法趋向于作出好的局部决策，然而，一旦作出合并两个簇的决策，以后就不能撤销了。这种方法阻碍了局部最优标准编程全局最优标准。

一些试图克服这个问题限制的技术：

（1）修补层次聚类：移动树的分支以改善全局目标函数。

（2）划分聚类技术（如K均值）来创建许多小簇，然后从这些小簇出发进行层次聚类。

2.4 优缺点

通常，使用这类算法是因为基本应用需要层次结构，如创建一种分类方法。这些算法能够产生较高质量的聚类。

然而，这类算法的计算量和存储需求代价昂贵。另外，对于噪声、高位数据，也可能造成问题。可先使用其他技术（如K均值）进行部分聚类，这两个问题都会在一定程度上得到解决。

三、实现

本实验以《数据挖掘导论》第32页的六个二维点为数据，实现了基本凝聚层次聚类算法。

数据如下：

点	X坐标	Y坐标
P0	0.4005	0.5306
P1	0.2148	0.3854
P2	0.3457	0.3156
P3	0.2652	0.1875
P4	0.0789	0.4139
P5	0.4548	0.3022

package min;

import java.awt.Point;
import java.util.Iterator;
import java.util.Vector;

public class MIN {
	public static final int k = 6;
	public static double[][] DistanceMatrix = new double[k][k];
	public static Vector<Vector<Point>> cluster = new Vector();

	public static double distance(Point p0, Point p1) {
		double distance;
		distance = Math.pow(p0.getX() / 10000 - p1.getX() / 10000, 2)
				+ Math.pow(p0.getY() / 10000 - p1.getY() / 10000, 2);
		distance = Math.sqrt(distance);
		return distance;
	}

	public static void Algorithm(Point[] p0) {
		// 1.compute distance matrix
		for (int i = 0; i < p0.length; i++) {
			for (int j = i; j < p0.length; j++) {
				double result = distance(p0[i], p0[j]);
				DistanceMatrix[i][j] = result;
			}
		}
		double max = (double) 0;
		for (int i = 0; i < cluster.size(); i++) {
			for (int j = i + 1; j < cluster.size(); j++) {
				for (int ii = 0; ii < cluster.get(i).size(); ii++) {
					for (int jj = 0; jj < cluster.get(j).size(); jj++) {
						double dstc = distance(cluster.get(i).get(ii), cluster.get(j).get(jj));
						if (dstc > max) {
							max = dstc;
						}
					}
				}
			}
		}

		int r1 = 0, r2 = 0;
		while (cluster.size() != 1) {
			double min = max;
			for (int i = 0; i < cluster.size(); i++) {
				for (int j = i + 1; j < cluster.size(); j++) {
					for (int ii = 0; ii < cluster.get(i).size(); ii++) {
						for (int jj = 0; jj < cluster.get(j).size(); jj++) {
							double dstc = distance(cluster.get(i).get(ii), cluster.get(j).get(jj));
							if (dstc < min) {
								min = dstc;
								r1 = i;
								r2 = j;
							}
						}
					}
				}
			}
			for (int k = 0; k < cluster.get(r2).size(); k++) {
				cluster.get(r1).add(cluster.get(r2).get(k));
			}
			cluster.removeElementAt(r2);
			System.out.println("***");
			for(int i=0;i<cluster.size();i++){
				System.out.print("{");
				for(int j=0;j<cluster.get(i).size();j++){
					System.out.print(cluster.get(i).get(j));	
				}
				System.out.println("}");
			}
			System.out.println("***");
		}
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Point[] p = new Point[k];
		p[0] = new Point(4005, 5306);
		p[1] = new Point(2148, 3854);
		p[2] = new Point(3457, 3156);
		p[3] = new Point(2652, 1875);
		p[4] = new Point(789, 4139);
		p[5] = new Point(4548, 3022);
		for (int i = 0; i < k; i++) {
			Vector<Point> clst = new Vector();
			clst.addElement(p[i]);
			cluster.addElement(clst);
		}
		Algorithm(p);
	}
}

3.1Vector的使用

1.可以这样多层迭代，但是使用是不便于阅读，下次尽可能不要这样使用了。

public staticVector<Vector<Point>> cluster = newVector();

2.取index位置的对象

Vector<Point>test3= cluster.get(r1);

3.删除index位置的对象

cluster.removeElementAt(r2);

4.Vecter类型声明要用类。

Double 是类 double是基础数据类型。Double类型是double的包装类，在JDK1.5以后，二者可以直接相互赋值，称为自动拆箱和自动装箱。

如下是错误示范：

Vector<double> cluster;

正确的是：

Vector<Double> cluster;

3.2求方差

distance = Math.sqrt(power);

四、结果展示

***

{java.awt.Point[x=4005,y=5306]}

{java.awt.Point[x=2148,y=3854]}

{java.awt.Point[x=3457,y=3156]java.awt.Point[x=4548,y=3022]}

{java.awt.Point[x=2652,y=1875]}

{java.awt.Point[x=789,y=4139]}

***

{java.awt.Point[x=4005,y=5306]}

{java.awt.Point[x=2148,y=3854]java.awt.Point[x=789,y=4139]}

{java.awt.Point[x=3457,y=3156]java.awt.Point[x=4548,y=3022]}

{java.awt.Point[x=2652,y=1875]}

***

{java.awt.Point[x=4005,y=5306]}

{java.awt.Point[x=2148,y=3854]java.awt.Point[x=789,y=4139]java.awt.Point[x=3457,y=3156]java.awt.Point[x=4548,y=3022]}

{java.awt.Point[x=2652,y=1875]}

***

{java.awt.Point[x=4005,y=5306]}

{java.awt.Point[x=2148,y=3854]java.awt.Point[x=789,y=4139]java.awt.Point[x=3457,y=3156]java.awt.Point[x=4548,y=3022]java.awt.Point[x=2652,y=1875]}

***

{java.awt.Point[x=4005,y=5306]java.awt.Point[x=2148,y=3854]java.awt.Point[x=789,y=4139]java.awt.Point[x=3457,y=3156]java.awt.Point[x=4548,y=3022]java.awt.Point[x=2652,y=1875]}

***