数据挖掘笔记-聚类-SpectralClustering-原理与简单实现

谱聚类(Spectral Clustering, SC)是一种基于图论的聚类方法——将带权无向图划分为两个或两个以上的最优子图，使子图内部尽量相似，而子图间距离尽量距离较远，以达到常见的聚类的目的。其中的最优是指最优目标函数不同，可以是Min Cut、Nomarlized Cut、Ratio Cut等。谱聚类能够识别任意形状的样本空间且收敛于全局最优解，其基本思想是利用样本数据的相似矩阵(拉普拉斯矩阵)进行特征分解后得到的特征向量进行聚类。

Spectral Clustering 算法步骤：

1）根据数据构造一个Graph，Graph的每一个节点对应一个数据点，将相似的点连接起来，并且边的权重用于表示数据之间的相似度。把这个Graph用邻接矩阵的形式表示出来，记为 W。

2）把W的每一列元素活者行元素加起来得到N个数，把它们放在对角线上（其他地方都是零），组成一个N*N的度矩阵，记为D 。

3）根据度矩阵与邻接矩阵得出拉普拉斯矩阵 L = D - W 。

4）求出拉普拉斯矩阵L的前k个特征值（除非特殊说明，否则“前k个”指按照特征值的大小从小到大的顺序）以及对应的特征向量。

5）把这k个特征（列）向量排列在一起组成一个N*k的矩阵，将其中每一行看作k维空间中的一个向量，并使用 K-Means算法进行聚类。聚类的结果中每一行所属的类别就是原来Graph中的节点亦即最初的N个数据点分别所属的类别。

示例

Spectral Clustering 和传统的聚类方法（如 K-Means等）对比：
1）和 K-Medoids 类似，Spectral Clustering 只需要数据之间的相似度矩阵就可以了，而不必像K-means那样要求数据必须是 N 维欧氏空间中的向量。Spectral Clustering 所需要的所有信息都包含在 W 中。不过一般 W 并不总是等于最初的相似度矩阵——回忆一下，W 是我们构造出来的 Graph 的邻接矩阵表示，通常我们在构造 Graph 的时候为了方便进行聚类，更加强到“局部”的连通性，亦即主要考虑把相似的点连接在一起，比如：我们可以设置一个阈值，如果两个点的相似度小于这个阈值，就把他们看作是不连接的。另一种构造 Graph 邻接的方法是将 n 个与节点最相似的点与其连接起来。
2）由于抓住了主要矛盾，忽略了次要的东西，因此比传统的聚类算法更加健壮一些，对于不规则的误差数据不是那么敏感，而且性能也要好一些。许多实验都证明了这一点。事实上，在各种现代聚类算法的比较中，K-means 通常都是作为 baseline 而存在的。实际上 Spectral Clustering 是在用特征向量的元素来表示原来的数据，并在这种“更好的表示形式”上进行 K-Means 。实际上这种“更好的表示形式”是用 Laplacian Eig进行降维的后的结果。而降维的目的正是“抓住主要矛盾，忽略次要的东西”。
3）计算复杂度比 K-means 要小。这个在高维数据上表现尤为明显。例如文本数据，通常排列起来是维度非常高（比如几千或者几万）的稀疏矩阵，对稀疏矩阵求特征值和特征向量有很高效的办法，得到的结果是一些 k 维的向量（通常 k 不会很大），在这些低维的数据上做 K-Means 运算量非常小。但是对于原始数据直接做 K-Means 的话，虽然最初的数据是稀疏矩阵，但是 K-Means 中有一个求 Centroid 的运算，就是求一个平均值：许多稀疏的向量的平均值求出来并不一定还是稀疏向量，事实上，在文本数据里，很多情况下求出来的 Centroid 向量是非常稠密，这时再计算向量之间的距离的时候，运算量就变得非常大，直接导致普通的 K-Means 巨慢无比，而 Spectral Clustering 等工序更多的算法则迅速得多的结果。

Java简单实现代码如下：

public class SpectralClusteringBuilder {

	public static int DIMENSION = 30;
	
	public static double THRESHOLD = 0.01;

	public Data getInitData() {
		Data data = new Data();
		try {
			String path = SpectralClustering.class.getClassLoader()
					.getResource("测试").toURI().getPath();
			DocumentSet documentSet = DocumentLoader.loadDocumentSet(path);
			List<Document> documents = documentSet.getDocuments();
			DocumentUtils.calculateTFIDF_0(documents);
			DocumentUtils.calculateSimilarity(documents, new CosineDistance());
			Map<String, Map<String, Double>> nmap = new HashMap<String, Map<String, Double>>();
			Map<String, String> cmap = new HashMap<String, String>();
			for (Document document : documents) {
				String name = document.getName();
				cmap.put(name, document.getCategory());
				Map<String, Double> similarities = nmap.get(name);
				if (null == similarities) {
					similarities = new HashMap<String, Double>();
					nmap.put(name, similarities);
				}
				for (DocumentSimilarity similarity : document.getSimilarities()) {
					if (similarity.getDoc2().getName().equalsIgnoreCase(similarity.getDoc1().getName())) {
						similarities.put(similarity.getDoc2().getName(), 0.0);
					} else {
						similarities.put(similarity.getDoc2().getName(), similarity.getDistance());
					}
				}
			}
			String[] docnames = nmap.keySet().toArray(new String[0]);
			data.setRow(docnames);
			data.setColumn(docnames);
			data.setDocnames(docnames);
			int len = docnames.length;
			double[][] original = new double[len][len];
			for (int i = 0; i < len; i++) {
				Map<String, Double> similarities = nmap.get(docnames[i]);
				for (int j = 0; j < len; j++) {
					double distance = similarities.get(docnames[j]);
					original[i][j] = distance;
				}
			}
			data.setOriginal(original);
			data.setCmap(cmap);
			data.setNmap(nmap);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return data;
	}

	/**
	 * 获取距离阀值在一定范围内的点
	 * @param data
	 * @return
	 */
	public double[][] getWByDistance(Data data) {
		Map<String, Map<String, Double>> nmap = data.getNmap();
		String[] docnames = data.getDocnames();
		int len = docnames.length;
		double[][] w = new double[len][len];
		for (int i = 0; i < len; i++) {
			Map<String, Double> similarities = nmap.get(docnames[i]);
			for (int j = 0; j < len; j++) {
				double distance = similarities.get(docnames[j]);
				w[i][j] = distance < THRESHOLD ? 1 : 0;
			}
		}
		return w;
	}
	
	/**
	 * 获取距离最近的K个点
	 * @param data
	 * @return
	 */
	public double[][] getWByKNearestNeighbors(Data data) {
		Map<String, Map<String, Double>> nmap = data.getNmap();
		String[] docnames = data.getDocnames();
		int len = docnames.length;
		double[][] w = new double[len][len];
		for (int i = 0; i < len; i++) {
			List<Map.Entry<String, Double>> similarities = 
					new ArrayList<Map.Entry<String, Double>>(nmap.get(docnames[i]).entrySet());
			sortSimilarities(similarities, DIMENSION);
			for (int j = 0; j < len; j++) {
				String name = docnames[j];
				boolean flag = false;
				for (Map.Entry<String, Double> entry : similarities) {
					if (name.equalsIgnoreCase(entry.getKey())) {
						flag = true;
						break;
					}
				}
				w[i][j] = flag ? 1 : 0;
			}
		}
		return w;
	}

	/**
	 * 垂直求和
	 * @param W
	 * @return
	 */
	public double[][] getVerticalD(double[][] W) {
		int row = W.length;
		int column = W[0].length;
		double[][] d = new double[row][column];
		for (int j = 0; j < column; j++) {
			double sum = 0;
			for (int i = 0; i < row; i++) {
				sum += W[i][j];
			}
			d[j][j] = sum;
		}
		return d;
	}

	/**
	 * 水平求和
	 * @param W
	 * @return
	 */
	public double[][] getHorizontalD(double[][] W) {
		int row = W.length;
		int column = W[0].length;
		double[][] d = new double[row][column];
		for (int i = 0; i < row; i++) {
			double sum = 0;
			for (int j = 0; j < column; j++) {
				sum += W[i][j];
			}
			d[i][i] = sum;
		}
		return d;
	}
	
	/**
	 * 相似度排序，并取前K个，倒叙
	 * @param similarities
	 * @param k
	 */
	public void sortSimilarities(List<Map.Entry<String, Double>> similarities, int k) {
		Collections.sort(similarities, new Comparator<Map.Entry<String, Double>>() {
			@Override
			public int compare(Entry<String, Double> o1,
					Entry<String, Double> o2) {
				return o2.getValue().compareTo(o1.getValue());
			}
		});
		while (similarities.size() > k) {
			similarities.remove(similarities.size() - 1);
		}
	}

	public void print(double[][] values) {
		for (int i = 0, il = values.length; i < il; i++) {
			for (int j = 0, jl = values[0].length; j < jl; j++) {
				System.out.print(values[i][j] + "  ");
			}
			System.out.println("\n");
		}
	}

	// 随机生成中心点，并生成初始的K个聚类
	public List<DataPointCluster> genInitCluster(List<DataPoint> points, int k) {
		List<DataPointCluster> clusters = new ArrayList<DataPointCluster>();
		Random random = new Random();
		Set<String> categories = new HashSet<String>();
		while (clusters.size() < k) {
			DataPoint center = points.get(random.nextInt(points.size()));
			String category = center.getCategory();
			if (categories.contains(category))
				continue;
			categories.add(category);
			DataPointCluster cluster = new DataPointCluster();
			cluster.setCenter(center);
			cluster.getDataPoints().add(center);
			clusters.add(cluster);
		}
		return clusters;
	}

	// 将点归入到聚类中
	public void handleCluster(List<DataPoint> points,
			List<DataPointCluster> clusters, int iterNum) {
		for (DataPoint point : points) {
			DataPointCluster maxCluster = null;
			double maxDistance = Integer.MIN_VALUE;
			for (DataPointCluster cluster : clusters) {
				DataPoint center = cluster.getCenter();
				double distance = DistanceUtils.cosine(point.getValues(),
						center.getValues());
				if (distance > maxDistance) {
					maxDistance = distance;
					maxCluster = cluster;
				}
			}
			if (null != maxCluster) {
				maxCluster.getDataPoints().add(point);
			}
		}
		// 终止条件定义为原中心点与新中心点距离小于一定阀值
		// 当然也可以定义为原中心点等于新中心点
		boolean flag = true;
		for (DataPointCluster cluster : clusters) {
			DataPoint center = cluster.getCenter();
			DataPoint newCenter = cluster.computeMediodsCenter();
			double distance = DistanceUtils.cosine(newCenter.getValues(),
					center.getValues());
			if (distance > 0.5) {
				flag = false;
				cluster.setCenter(newCenter);
			}
		}
		if (!flag && iterNum < 25) {
			for (DataPointCluster cluster : clusters) {
				cluster.getDataPoints().clear();
			}
			handleCluster(points, clusters, ++iterNum);
		}
	}

	/**
	 * KMeans方法
	 * @param dataPoints
	 */
	public void kmeans(List<DataPoint> dataPoints) {
		List<DataPointCluster> clusters = genInitCluster(dataPoints, 4);
		handleCluster(dataPoints, clusters, 0);
		int success = 0, failure = 0;
		for (DataPointCluster cluster : clusters) {
			String category = cluster.getCenter().getCategory();
			for (DataPoint dataPoint : cluster.getDataPoints()) {
				String dpCategory = dataPoint.getCategory();
				if (category.equals(dpCategory)) {
					success++;
				} else {
					failure++;
				}
			}
		}
		System.out.println("total: " + (success + failure) + " success: "
				+ success + " failure: " + failure);
	}

	public void build() {
		Data data = getInitData();
		double[][] w = getWByKNearestNeighbors(data);
		double[][] d = getHorizontalD(w);
		Matrix W = new Matrix(w);
		Matrix D = new Matrix(d);
		Matrix L = D.minus(W);
		EigenvalueDecomposition eig = L.eig();
		double[][] v = eig.getV().getArray();
		double[][] vs = new double[v.length][DIMENSION];
		for (int i = 0, li = v.length; i < li; i++) {
			for (int j = 1, lj = DIMENSION; j <= lj; j++) {
				vs[i][j-1] = v[i][j];
			}
		}
		Matrix V = new Matrix(vs);
		Matrix O = new Matrix(data.getOriginal());
	    double[][] t = O.times(V).getArray();
	    List<DataPoint> dataPoints = new ArrayList<DataPoint>();
		for (int i = 0; i < t.length; i++) {
			DataPoint dataPoint = new DataPoint();
			dataPoint.setCategory(data.getCmap().get(data.getColumn()[i]));
			dataPoint.setValues(t[i]);
			dataPoints.add(dataPoint);
		}
		for (int n = 0; n < 10; n++) {
			kmeans(dataPoints);
		}
	}

	public static void main(String[] args) {
		new SpectralClusteringBuilder().build();
	}
}

代码托管:https://github.com/fighting-one-piece/repository-datamining.git