k_means算法

最新推荐文章于 2024-03-14 06:20:16 发布
最新推荐文章于 2024-03-14 06:20:16 发布
阅读量321 收藏
点赞数
分类专栏： 数据挖掘
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39464369/article/details/88801209
版权

k_means算法基本原理

1.算法首先随机地选择k个对象作为一个初始簇的中心（或平均值）。
2.对剩余的每个对象根据其与各个簇中心的距离，将它赋给最近的簇。
3.重新计算每个簇的簇中心。
4.重复第2，3步，直到簇中心收敛（不收敛则达到最大迭代次数后结束）。

package k_means;
import java.util.ArrayList;
import java.util.List;
import java.util.function.BiFunction;
//k均值聚类
public class K_Means <K> {
	//簇表
	List<Cluster<K>> clusterList;
	//距离公式
	Distance<K> distance;
	//簇中心公式
	ClusterCenter<K> clusterCenter;
	//精度
	double accuracy=0.001;
	//迭代次数
	int count=0;
	//最大迭代次数
	int MAXCOUNT=1000;
	//数据表
	ArrayList<K> dataList;
	public K_Means() {
	}
	//聚合
	public List<Cluster<K>> clustering(ArrayList<K> list,int num ) {
		this.dataList=list;
		if(num<=1||num>=dataList.size()) {
			return null;
		}
		initialCluster(dataList, num);
		while(!criterionFunction()) {
			upCluster();
			count++;
			this.show();
		}
		clusterList.forEach(e->{
			System.out.println(e.getItems());
		});
		return null;
	}
	//更新簇（簇中心和子集）
	public void upCluster() {
		for( Cluster<K> clu:clusterList) {
			clu.getItems().clear();;
		}
		for(K itme:dataList) {
			Cluster<K> recent=recentClusters(itme);
			recent.add(itme);
		}
		for( Cluster<K> clu:clusterList) {
			clu.upCenter(clusterCenter);
		}
	}
	//准则函数，使生成的结果簇尽可能地紧凑和独立
	public boolean criterionFunction() {
		if(count>MAXCOUNT)
			return true;
		if(clusterList.get(0).getOldCenter()==null) {
			return false;
		}
		double tmp=0.0;
		for(Cluster<K> cluster:clusterList) {
			tmp+=distance.apply(cluster.getOldCenter(), cluster.getCenter()).doubleValue();
		}
		return tmp<this.accuracy;
	}
	//寻找最近簇
	public Cluster<K> recentClusters(K itme) {
		Cluster<K> recent=null;
		double dis=Double.MAX_VALUE;
		for(Cluster<K> cluster:clusterList) {
			double tmp=distance.apply(itme, cluster.getCenter()).doubleValue();
			if(tmp<dis) {
				dis=tmp;
				recent=cluster;
			}
		}
		return recent;
	}
	//初始化簇
	public void initialCluster(ArrayList<K> dataList,int num) {
		clusterList=new ArrayList<Cluster<K>>();
		for(Integer index:K_Means.randomMumber(1,dataList.size(),num)) {
			Cluster<K> cluster=new  Cluster<K>();
			cluster.setCenter(dataList.get(index));
			clusterList.add(cluster);
		}
	}
	//在[start  end]内随机选取 num个不重复数据
	public static ArrayList<Integer> randomMumber(int start,int end,int num){
		ArrayList<Integer> list =new ArrayList<Integer>();
		while(list.size()<num) {
			int tmp=(int)(1+Math.random()*(end-start));
			boolean done=true;
			for(Integer i:list) {
				if(i.intValue()==tmp) {
					done=false;
					break;
				}
			}
			if(done)
				list.add(tmp);
		}
		return list;
	}
	public void setDistance(Distance<K> distance) {
		this.distance = distance;
	}
	public void setClusterCenter(ClusterCenter<K> clusterCenter) {
		this.clusterCenter = clusterCenter;
	}
	public void  show() {
		System.out.println("The ( "+ count+" )iteration");
		for(Cluster<K> clu:clusterList) {
			System.out.println(clu);
		}
	}
}
//簇类
class  Cluster<C> {
	//簇中心
	private C center;
	//旧的簇中心
	private C oldCenter;
	//子集
	private ArrayList<C> items =new ArrayList<C>();
	public ArrayList<C> getItems() {
		return items;
	}
	public void  clearItems() {
		this.items.clear();
	}
	//更新簇中心
	public  C upCenter(ClusterCenter<C> clusterCenter){
		this.oldCenter=this.center;
		this.center = clusterCenter.upCenter(this.items);
		return this.center;
	}
	public C getCenter() {
		return center;
	}
	public void setCenter(C center) {
		this.center= center;
	}
	public C getOldCenter() {
		return oldCenter;
	}
	public void  addAll(Cluster<C> cluster) {
		this.items.addAll(cluster.items);
	}
	public void  add(C e) {
		this.items.add(e);
	}
	public String toString() {
		String str="Cluster Center: "+center;
		for(C itme:items) {
			str+="\n\t"+itme;
		}
		return str;
	}
}
//距离公式
abstract class Distance<D> implements BiFunction<D,D,Number>{
}
//簇中心公式
interface ClusterCenter<T> {
	T upCenter(ArrayList<T> items);
}


puclic class TestK_Means{
 
	public static void main(String[] args) {
		ArrayList<Data> dataList =new ArrayList<Data>();
		dataList.add(new Data(1,1,1));
		dataList.add(new Data(2,2,1));
		dataList.add(new Data(3,1,2));
		dataList.add(new Data(4,2,2));
		dataList.add(new Data(5,4,3));
		dataList.add(new Data(6,5,3));
		dataList.add(new Data(7,4,4));
		dataList.add(new Data(8,5,4));
		System.out.print(randomMumber(1,8,5));
		K_Means<Data> k=new K_Means<Data>();

		k.setDistance(new Distance<Data>() {
			public Number apply(Data t, Data u) {
				//欧氏距离
				return Math.sqrt((t.x-u.x)*(t.x-u.x)+(t.y-u.y)*(t.y-u.y));
			}
		});
		k.setClusterCenter(new ClusterCenter<Data> () {
			public Data upCenter(ArrayList<Data> items) {
				double sumx=0.0,sumy=0.0;
				for(Data itme:items) {
					sumx+=itme.x;
					sumy+=itme.y;
				}
				//新的簇中心
				return new Data(0,sumx/items.size(), sumy/items.size());
			}
		});
		
		k.clustering(dataList, 2);
	}
}
//测试数据类
class Data{
	int id;
	double x, y;
	public Data(int id,double x,double y) {
		this.id=id;
		this.x=x;
		this.y=y;
	}
	public String toString() {
		return "Data "+id+":("+x+","+y+")";
	}
}

测试结果

The ( 1 )iteration
Cluster Center: Data 0:(2.7142857142857144,2.4285714285714284)
	Data 1:(1.0,1.0)
	Data 2:(2.0,1.0)
	Data 3:(1.0,2.0)
	Data 4:(2.0,2.0)
	Data 5:(4.0,3.0)
	Data 7:(4.0,4.0)
	Data 8:(5.0,4.0)
Cluster Center: Data 0:(5.0,3.0)
	Data 6:(5.0,3.0)
The ( 2 )iteration
Cluster Center: Data 0:(1.5,1.5)
	Data 1:(1.0,1.0)
	Data 2:(2.0,1.0)
	Data 3:(1.0,2.0)
	Data 4:(2.0,2.0)
Cluster Center: Data 0:(4.5,3.5)
	Data 5:(4.0,3.0)
	Data 6:(5.0,3.0)
	Data 7:(4.0,4.0)
	Data 8:(5.0,4.0)
The ( 3 )iteration
Cluster Center: Data 0:(1.5,1.5)
	Data 1:(1.0,1.0)
	Data 2:(2.0,1.0)
	Data 3:(1.0,2.0)
	Data 4:(2.0,2.0)
Cluster Center: Data 0:(4.5,3.5)
	Data 5:(4.0,3.0)
	Data 6:(5.0,3.0)
	Data 7:(4.0,4.0)
	Data 8:(5.0,4.0)

在第三次迭代时簇中心已经收敛，迭代结束。

k-means算法的性能分析

  • 主要优点：
    • 是解决聚类问题的一种经典算法，简单、快速。
    • 对处理大数据集，该算法是相对可伸缩和高效率的。
    • 当结果簇是密集的，它的效果较好。
  • 主要缺点：
    • 在簇的平均值被定义的情况下才能使用，可能不适用于某些应用。
    • 必须事先给出k（要生成的簇的数目），而且对初值敏感，对于不同的初始值，可能会导致不同结果（初始值的选取也会影响收敛速度）。
    • 不适合于发现非凸面形状的簇或者大小差别很大的簇。而且，它对于“躁声”和孤立点数据是敏感的。
大知无涯者
关注
专栏目录
机器学习算法之K-means（K均值聚类）算法
tttaeyang的博客
10-08 7205
聚类 聚类，简单来说，就是将一个庞杂数据集中具有相似特征的数据自动归类到一起，称为一个簇，簇内的对象越相似，聚类的效果越好。它是一种无监督的学习(Unsupervised Learning)方法,不需要预先标注好的训练集。聚类与分类最大的区别就是分类的目标事先已知，例如猫狗识别，你在分类之前已经预先知道要将它分为猫、狗两个种类；而在你聚类之前，你对你的目标是未知的，同样以动物为例，对于一个动物集来...
K-Means算法解析
an819821664的博客
12-08 1130
  K-means 是常用的基于欧式距离的聚类算法，其认为两个目标的距离越近，相似度越大，属于无监督学习方法。在K-Means算法中，簇的个数K是一个超参数，需要人为输入来确定。K-Means的核心任务就是根据设定好的K，找出K个最优的质心，并将离这些质心最近的数据分别分配到这些质心代表的簇中去。  从K-Means的算法流程中可以发现，k值的选择、初始质心点、中止条件对分类结果的影响较大。  K 值的选取对 K-means 影响很大，这也是 K-means 算法调优的重点，常见的选取 K 值的方法有：手肘
[机器学习]K-means算法详解：原理、优缺点、代码实现、变体及实际应用
ShiinaMashiro0402的博客
04-06 4191
K-means算法是一种非常流行的无监督学习方法，主要应用于聚类问题。本篇博客将详细介绍K-means算法的原理、优缺点及实际应用场景。
机器学习之K-Means（k均值）算法
十年以上架构设计经验，专注于软件架构和人工智能领域，对机器视觉、NLP、音视频等领域都有涉猎
06-20 1万+
K-Means算法又称K均值算法，属于聚类（clustering）算法的一种，是应用最广泛的聚类算法之一。所谓聚类，即根据相似性原则，将具有较高相似度的数据对象划分至同一类簇，将具有较高相异度的数据对象划分至不同类簇。聚类与分类最大的区别在于，聚类过程为无监督过程，即待处理数据对象没有任何先验知识，而分类过程为有监督过程，即存在有先验知识的训练数据集。K-Means是无监督学习的杰出代表之一。
K-means算法（一篇文章讲透）
最新发布
2303_79387663的博客
03-14 6350
请注意，这只是一个简单的示例，实际应用中，您可能需要对数据进行预处理（如标准化或归一化），选择适当的K值，并评估聚类结果的质量。K-means算法是一种基于距离的聚类算法，其核心思想是通过迭代的方式将数据划分为K个簇，使得每个簇内的数据点尽可能接近其簇中心，而不同簇之间的数据点尽可能远离。其中，最具代表性的是K-means++算法和密度敏感的K-means算法。K-means算法的聚类效果受到初始聚类中心选择的影响，不同的初始值可能导致不同的聚类结果。
K_means程序.rar_K means matlab_K._k_means_k_means 算法_算法实现；Matlab
07-15
在本资源中，"K_means程序.rar" 提供了一个用Matlab实现的KMeans算法示例，这对于理解和实践该算法非常有帮助。 首先，我们来详细了解KMeans算法的基本概念和工作流程： 1. **算法简介**：KMeans是一种迭代的聚类...
K01_K-Means聚类_K._kernelk-means_k_means算法_Kernel
09-11
标题中的"K01_K-Means聚类_K._kernelk-means_k_means算法_Kernel"指的是K-means聚类算法的一种变体，即Kernel K-means（核K-means）。传统的K-means算法在欧氏距离下工作，对线性可分数据效果良好，但面对非线性分布...
基于改进k⁃means算法的电网数据实时交换方法研究
01-12
针对传统k⁃means算法对电网数据实时交换过程控制效果不佳，交互过程不稳定，交互时间长等问题，对k⁃means算法进行改选，提出了一种新的电网数据实时交换方法。以电压数据、功率数据、电流数据及容量数据为基础数据建立电网数据实时交换数学模型；由发电机、输电线路、配电线路和低压线路构建电网结构，通过电网数据预处理、特征数据提取、k⁃means计算实现电网数据的实时交互。为检测方法效果，与传统k⁃means算法进行对比，设计了对比实验。结果表明，给出的方法在电网数据交互过程中稳定性高，交互时间短，能够为用户提供质量更高的电能。
【海量数据挖掘/数据分析】之 K-Means 算法（K-Means算法、K-Means 中心值计算、K-Means 距离计算公式、K-Means 算法迭代步骤、K-Means算法实例）
仙魁XAN
07-07 2万+
① 给定条件 :给定数据集 X , 该数据集有 n 个样本;将其分成 K 个聚类;③ 聚类分组要求 :每个聚类分组中 , 所有的数据样本 , 与该分组的中心点的距离之和最小;将每个样本的与中心点距离计算出来 , 分组中的这些距离累加 , K 个分组的距离之和 也累加起来 , 总的距离最小;①设置中心点 :设置了 3 个初始中心点 , A1​(2,4) 对应聚类 1 中心点 , B1​(5,8) 对应聚类 2 中心点 , C1​(6,2) 对应聚类 3 中心点;②计算中心点距离。
K-means算法
m0_64334839的博客
06-28 4955
K-means算法笔记
全面解析Kmeans聚类算法（Python）
Python学习与数据挖掘
04-21 4万+
Clustering (聚类) 是常见的unsupervised learning (无监督学习)方法，简单地说就是把相似的数据样本分到一组（簇），聚类的过程. 我们并不清楚某一类是什么（通常无标签信息），需要实现的目标只是把相似的样本聚到一起，即只是利用样本数据本身的分布规律。 在本文中，我将详细介绍聚类算法，喜欢本文记得收藏、关注、点赞。 【注】完整版代码、数据、技术交流文末提供。 聚类算法可以大致分为传统聚类算法以及深度聚类算法： 传统聚类算法主要是根据原特征+基于划分/密度/层次等方法。
K-Means聚类算法
热门推荐
软件工程小施同学 的专栏
06-14 6万+
什么是聚类分析聚类分析是数据挖掘中一个重要概念，其核心是寻找数据对象中隐藏的有价值的信息，根据相似性原则，把具有较高相似度的数据对象划分到同一类簇，把具有较高相异度的数据对象划分到不同类簇，从而使相同组中的数据点之间比其他组中的数据点更具有相似性。聚类算法典型的聚类算法分为三个阶段，主要包括特征选择和特征提取、数据对象间相似度计算以及根据相似度将数据对象分组。聚类算法可以分为两大类：层次聚类算法和划分聚类算法。层次聚类算法通过不同类别间的数据对象的相似度试图构建一个高层次的嵌套聚类树结构，聚类树的构建有两种
K-means 算法【基本概念篇】
编程小栈
11-14 2万+
写在前面的话 k-means 算法是一个聚类的算法 也就是clustering 算法。是属于无监督学习算法，也是就样本没有label(标签)的算分，然后根据某种规则进行“分割”， 把相同的或者相近的objects 物体放在一起。 在这里K就是我们想要分割的的聚类的个数。 当然了，很多资料都会说这个算法吧，毕竟简单粗暴可依赖 算法描述 首先我们有以下的几个点 A1 (2,10) ...
图解K-Means算法
尤尔小屋
12-18 5845
图解K-Means算法 本文中介绍的是一种常见的无监督学习算法，名字叫做K均值算法：K-Means算法。 K-Means算法在无监督学习，尤其是聚类算法中是最为基础和重要的一个算法。它实现起来非常简单。聚类效果也很不错的，因此应用非常广泛。 本文将会从以下8个方面进行详细的讲解： 算法思想 无监督学习 在正式介绍K-Means算法之前，我们先解释一下无监督学习。用一句很通俗的话来解释： 是否有监督（supervised），我们只需要看输入的数据是否有标签 输入的数据如果带有标签，则是有监督学习，比如K
K-means算法详解与实现
"这篇资源主要介绍了K-means算法，适合初学者学习。同时提到了相关的GMM（高斯混合模型）和EM（期望最大化）算法，并包含了一段MATLAB实现K-means算法的代码示例。" K-means算法是一种广泛应用的无监督学习方法，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值