程序猿成长之路之数据挖掘篇——Kmeans聚类算法

已于 2024-08-25 21:15:18 修改
阅读量252 收藏 3
点赞数 2
分类专栏： 数据挖掘 文章标签： 数据挖掘 算法 kmeans
于 2024-08-25 14:26:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31236027/article/details/141528814
版权

Kmeans 是一种可以将一个数据集按照距离（相似度）划分成不同类别的算法，它无需借助外部标记，因此也是一种无监督学习算法。

什么是聚类

用官方的话说聚类就是将物理或抽象对象的集合分成由类似的对象组成的多个类的过程。用自己的话说聚类是根据不同样本数据间的相似度进行种类划分的算法。这种划分可以基于我们的业务需求或建模需求来完成，也可以单纯地帮助我们探索数据的自然结构和分布。

什么是K-means聚类

用官方的话说：k均值聚类算法（k-means clustering algorithm）是一种迭代求解的聚类分析算法，其步骤是，预将数据分为K组，则随机选取K个对象作为初始的聚类中心，然后计算每个对象与各个种子聚类中心之间的距离，把每个对象分配给距离它最近的聚类中心。聚类中心以及分配给它们的对象就代表一个聚类。每分配一个样本，聚类的聚类中心会根据聚类中现有的对象被重新计算。这个过程将不断重复直到满足某个终止条件。终止条件可以是没有（或最小数目）对象被重新分配给不同的聚类，没有（或最小数目）聚类中心再发生变化，误差平方和局部最小。

K-means聚类实现流程在这里插入图片描述

K-means聚类聚类的优劣性

优点：

  1. K-means聚类可以支持无监督学习，无需人工标记即可进行分类
  2. K-means聚类有处理不同类型数据的能力，如二元、序数、标称、数值等类型数据都可以处理。
  3. K-means聚类算法基于欧几里得或者曼哈顿距离度量来决定聚类。基于这样的距离度量的算法趋向于发现具有相近尺度和密度的球状簇。但是，一个簇可能是任意形状的。提出能发现任意形状簇的算法是很重要的。

缺点：

  1. 需要提前确定几何中心的数量
  2. 设置初始几何中心需要考虑尽可能选取差异较大的数据作为初始几何中心
  3. 适用于有明显中心的数据样本，对于相对分散的数据样本处理效果欠佳。
  4. 噪点数据对于聚类的影响较大

典型案例

学校A有若干不同年龄分布的学生，并且性别也不一样，想要依据这两个参数对学生进行分类。

学生类

import java.util.List;

public class Student{
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + ", gender=" + gender + ", myHobby=" + myHobby
				+ ", myDream=" + myDream + "]";
	}
	public List<MyHobby> getMyHobby() {
		return myHobby;
	}
	public Student setMyHobby(List<MyHobby> myHobby) {
		this.myHobby = myHobby;
		return this;
	}
	public String getName() {
		return name;
	}
	public Student setName(String name) {
		this.name = name;
		return this;
	}
	public int getAge() {
		return age;
	}
	public Student setAge(int age) {
		this.age = age;
		return this;
	}
	public String getGender() {
		return gender;
	}
	public Student setGender(String gender) {
		this.gender = gender;
		return this;
	}
	String name;
	
	@Elem(type = ElemType.NUMBER)
	int age;
	
	@Elem(type = ElemType.XUSHU,list={"男","女"})
	String gender;
	
	@Elem()
	List<MyHobby> myHobby;
	
	@Elem()
	List<String> myDream;
	
	public Student(String name, int age, String gender) {
		super();
		this.name = name;
		this.age = age;
		this.gender = gender;
	}
	
	public Student(String name, int age, String gender,List<MyHobby> myHobby) {
		this(name,age,gender);
		this.myHobby = myHobby;
	}
	
	public Student(String name, int age, String gender,List<MyHobby> myHobby, List<String> myDreams) {
		this(name,age,gender);
		this.myHobby = myHobby;
		this.myDream = myDreams;
	}
}

配置类

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Elem {
	ElemType type() default ElemType.BASIC; //属性类型
	String[] list() default {}; //选择项
}


package kmeans;
/**
 * 元素属性类型（标称属性、序数属性、数值属性、二元属性）
 * @author zygswo
 *
 */
public enum ElemType {
	BASIC("标称属性"),
	XUSHU("序数属性"),
	NUMBER("数值属性"),
	ERYUAN("二元属性");
	
	private String name;
	
	private ElemType(String name) {
		this.setName(name);
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
}


package kmeans;

public enum DistanceType {
	EUCLID("欧几里得距离"),
	MANHATTAN("曼哈顿距离"),
	QIEBIXUEFU("切比雪夫距离");
	
	private String name;
	
	private DistanceType(String name) {
		this.setName(name);
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
}

主方法

package kmeans;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * kmeans聚类工具类
 * @author zygswo
 *
 */
public class KmeansUtils<T> {
	private int initKNodeNb; //kmeans初始几何中心数量
	
	private List<T> trainData; //kmeans训练数据
	
	private DistanceType distanceType;
	
	/**
	 * kmeans构造方法(默认为欧式距离公式）
	 * @param initKNodeNb kmeans初始几何中心数量
	 * @param trainData	训练数据
	 */
	public KmeansUtils(List<T> trainData, int initKNodeNb) {
		this.initKNodeNb = initKNodeNb;
		this.trainData = trainData;
		this.distanceType = DistanceType.EUCLID;
	}
	
	/**
	 * kmeans构造方法(默认为欧式距离公式）
	 * @param initKNodeNb kmeans初始几何中心数量
	 * @param trainData	训练数据
	 * @param distanceType 距离公式
	 */
	public KmeansUtils(List<T> trainData, int initKNodeNb, DistanceType distanceType) {
		this.initKNodeNb = initKNodeNb;
		this.trainData = trainData;
		this.distanceType = distanceType;
	}
	
	/**
	 * kmeans模型训练
	 */
	public void fit(){
		//计算距离
		List<Map<String,Double>> initKNodeDistanceVal = Collections.synchronizedList(
				new ArrayList<>()
		);
		//初始化几何列表
		List<List<T>> resList = Collections.synchronizedList(
				new ArrayList<>()
		);
		if (this.trainData == null || this.trainData.isEmpty()) {
			throw new IllegalArgumentException("训练集为空");
		}
		if (this.initKNodeNb <=0) {
			throw new IllegalArgumentException("几何中心数量小于0");
		}
		if (this.initKNodeNb > this.trainData.size()) {
			throw new IllegalArgumentException("几何中心数量超过数组数量");
		}
		if (this.distanceType == null) {
			throw new IllegalArgumentException("距离类型为空");
		}
		//1.获取前initKNodeNb个数据放入initKNodeList列表中
		//初始化的几何中心，需要选择差异较大的
		this.trainData.sort((T item1,T item2)-> {
			return (int)(calcDiff(item1,this.trainData.get(0)) - calcDiff(item2,this.trainData.get(0)));
		});
		int step = this.trainData.size() / initKNodeNb;
		//选择从小到大的initKNodeNb个元素作为初始几何
		for (int i = 0; i < this.trainData.size() && resList.size() < initKNodeNb; i+=step) {
			List<T> temp = Collections.synchronizedList(
					new ArrayList<>()
			);
			temp.add(this.trainData.get(i));
			resList.add(temp); //多个几何列表设置初始结点
		}
		//2.计算所有变量到不同的几何中心距离,如果稳定了(几何中心固定了)，就退出循环
		while(true) {
			boolean balanced = true; //是否已经平衡
			for (T item: this.trainData) {
				double distance, minDistance = Double.MAX_VALUE; //求最小距离
				int preIndex = 0,afterIndex = 0; //preIndex-原位置
				initKNodeDistanceVal.clear();
//				for (List<T> list : resList) {
//					System.out.println(list.toString());
//				}
				//计算几何中心
				for (int i = 0; i < initKNodeNb; i++) {
					if (resList.get(i).size() > 0)
						initKNodeDistanceVal.add(calc(resList.get(i))); //计算初始结点距离
				}
				//计算原来的位置
				for (int i = 0; i < initKNodeNb; i++) {
					if(resList.get(i).contains(item)) {
						preIndex = i;
						break;
					}
				}
//				System.out.println("item = " + item.toString());
				//计算不同变量到不同的几何中心距离
				for (int i = 0; i < initKNodeNb; i++) {
					if (resList.get(i).size() > 0 && i < initKNodeDistanceVal.size()) {
						distance = calcDistance(item, initKNodeDistanceVal.get(i));
//						System.out.println("distance = " + distance);
//						System.out.println("minDistance = " + minDistance);
						if (distance < minDistance) {
							minDistance = distance;
							afterIndex = i;
						}
					}					
				}
//				System.out.println("preIndex = " + preIndex);
//				System.out.println("afterIndex = " + afterIndex);
				//位置替换,如果替换就还没结束
				if (preIndex != afterIndex) {
					resList.get(preIndex).remove(item);
					resList.get(afterIndex).add(item);
					balanced = false;
				} 
				if (preIndex == afterIndex) {
					//如果新增就还没结束
					if (!resList.get(preIndex).contains(item)) {
						resList.get(preIndex).add(item);
						balanced = false;
					}
				}
			}
			if (balanced){
				break;
			}
		}
//		//打印结果
		for (List<T> list : resList) {
			System.out.println(list.toString());
		}
	}
	
	/**
	 * 计算距离
	 * @param item1 item1
	 * @param item2 item2
	 * @return
	 */
	private double calcDiff(T item1, T item2) {
		List<T> list = Collections.synchronizedList(new ArrayList<>());
		list.add(item2);
		Map<String, Double> map = calc(list);
		double dist = calcDistance(item1, map);
		return dist;
	}
/**
	 * 计算距离
	 * @param item 当前对象
	 * @param map 几何中心
	 * @return
	 */
	private double calcDistance(T item, Map<String, Double> map) {
		double distance = 0.0;//距离
		int level = 0;//根据距离公式判断距离计算等级
		Class<?> cls = item.getClass();
		Field[] fs = cls.getDeclaredFields();
		for (Field f : fs) {
			double dist1 = 0.0, dist2 = 0.0;
			f.setAccessible(true);
			//获取需要计算的参数
			Elem el = f.getAnnotation(Elem.class);
			if (el == null) {
				continue;
			}
			try {
				switch(el.type()) {
				case BASIC: break;
				case XUSHU:
					//获取数组
					String[] arr = el.list();
					if (arr == null) {
						throw new IllegalArgumentException("序数属性需配置属性集合数组");
					}
					//数组排序
					Arrays.sort(arr);
					List<String> list = Arrays.asList(arr);
					//计算差距步长
					Double diffStep = 1 / (list.size() * 1.0);
					//获取当前对象序数属性的值
					Object value = f.get(item);
					dist1 = list.indexOf(value) * diffStep;
					break;
				case NUMBER: 
					//获取当前对象数值属性的值
					Object value1 = f.get(item); 
					//数据转换
					Double intVal = Double.parseDouble(String.valueOf(value1));
					dist1 = intVal;
					break;
				case ERYUAN:
					//获取数组
					String[] arr1 = el.list();
					if (arr1 == null) {
						arr1 = new String[]{"0","1"};
					} else {
						//数组排序
						Arrays.sort(arr1);
					}
					//转列表
					List<String> list1 = Arrays.asList(arr1);
					//计算差距步长
					Double diffStep1 = 1 / (list1.size() * 1.0);
					Object value2 = f.get(item);
					int ind = list1.indexOf(value2);
					dist1 = ind * diffStep1;
					break;
				}
				//获取当前几何中心属性的值
				dist2 = map.get(f.getName());
				//计算距离
				switch(distanceType) {
					case EUCLID: level = 2; break;
					case MANHATTAN: level = 1;break;
					case QIEBIXUEFU: level = 100;break;
				}
				distance += Math.pow(Math.abs(dist1 - dist2),level);
			} catch(Exception ex) {
				throw new RuntimeException(ex.getMessage());
			}
			distance = Math.pow(distance, 1/(level * 1.0));
		}	
		return distance;
	}

	/**
	 * 计算几何中心坐标
	 * @param kNodeList
	 * @return 几何中心坐标map
	 */
	private Map<String, Double> calc(List<T> kNodeList) {
		if (kNodeList == null || kNodeList.size() <= 0) {
			throw new IllegalArgumentException("几何中心列表数组为空");
		}
		//反射获取参数,形成数值数组
		Map<String, Double> result = new ConcurrentHashMap<>();
		T item = kNodeList.get(0);
		Class<?> cls = item.getClass();
		Field[] fs = cls.getDeclaredFields();
		for (Field f: fs) {
			//获取需要计算的参数
			Elem el = f.getAnnotation(Elem.class);
			if (el == null) {
				continue;
			}
			//将数据转换成数值
			Double dist = 0.0;
			switch(el.type()) {
				case BASIC: break;
				case XUSHU: 
					//获取数组
					String[] arr = el.list();
					if (arr == null) {
						throw new IllegalArgumentException("序数属性需配置属性集合数组");
					}
					//数组排序
					Arrays.sort(arr);
					//转列表
					List<String> list = Arrays.asList(arr);
					//计算差距步长
					Double diffStep = 1 / (list.size() * 1.0);
					for (T kNode : kNodeList) {
						try {
							//获取当前对象序数属性的值
							Object value = f.get(kNode);
							int ind = list.indexOf(value);
							//求和
							dist += ind * diffStep;
						} catch (IllegalArgumentException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						} catch (IllegalAccessException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
					}
					break;
				case NUMBER: 
					for (T kNode : kNodeList) {
						try {
							//获取当前对象数值属性的值
							Object value = f.get(kNode);
							//数据转换
							Double intVal = Double.parseDouble(String.valueOf(value));
							dist += intVal;
						} catch (IllegalArgumentException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						} catch (IllegalAccessException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
					}
					break;
				case ERYUAN:
					//获取数组
					String[] arr1 = el.list();
					if (arr1 == null) {
						arr1 = new String[]{"0","1"};
					} else {
						//数组排序
						Arrays.sort(arr1);
					}
					//转列表
					List<String> list1 = Arrays.asList(arr1);
					//计算差距步长
					Double diffStep1 = 1 / (list1.size() * 1.0);
					for (T kNode : kNodeList) {
						try {
							//获取当前对象二元属性的值
							Object value = f.get(kNode);
							int ind = list1.indexOf(value);
							//求和
							dist += ind * diffStep1;
						} catch (IllegalArgumentException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						} catch (IllegalAccessException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
					}
					break;
			}
			dist /= (kNodeList.size() * 1.0); //求平均值
			result.put(f.getName(), dist);
		}
		return result;
	}
	
	public static void main(String[] args) {
		List<Student> trainData = new ArrayList<>();
		trainData.add(new Student("zyl",28,"男"));
		trainData.add(new Student("sjl",28,"女"));
		trainData.add(new Student("xxx",27,"男"));
		trainData.add(new Student("stc",30,"男"));
		trainData.add(new Student("wxq",30,"女"));
		trainData.add(new Student("zzz",27,"男"));
		trainData.add(new Student("sss",27,"女"));
		trainData.add(new Student("mmm",20,"男"));
		trainData.add(new Student("qqq",20,"女"));
		trainData.add(new Student("666",30,"男"));
//		trainData.add(new Student("mmm",19,"男"));
		KmeansUtils<Student> utils = new KmeansUtils<>(trainData, 4);
		utils.fit();
	}
}

运行结果
在这里插入图片描述

zygswo
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
聚类算法实现本次作业实现了3个经典算法：KNN算法、K-Means算法、朴素贝叶斯算法
08-15
本次作业实现了3个经典算法：KNN算法、K-Means算法、朴素贝叶斯算法。
Python聚类算法效果图，写代码需要注意的五个细节.docx
05-31
Python 提供了丰富的库支持聚类算法的实现，其中最常用的包括 K-Means 和层次聚类。本篇文章主要关注的是如何在 Python 中有效地应用 K-Means 算法，并展示了该算法在二维数据上的可视化效果。 K-Means 是一种迭代...
数据可视化与数据挖掘——条形图&K-means聚类
AtlasWong的博客
06-29 921
一、 导入数据集 df = pd.read_csv('D:/code_data/virtualization/mtcars.csv') df.head(5) 字段解释： 1.mpg：英里每加仑（Miles per gallon） 值越大性能越好，或许是能源利用效率更高，或许速度较快 2. cyl：气缸数量（Number of cylinders） 3. disp ：排量（Displacement） 4.hp：总马力（horsepower） 5.drat：驱动轴比（drive axle ratio） 6.
机器学习之K均值聚类算法K-Means（python代码实现）
热门推荐
记录知识，学习分享
05-24 1万+
K均值聚类（K-Means） k-means 算法：根据给定的数据样本构建 k 个划分聚类，每个划分聚类即为一个簇。 该算法是一个典型的基于距离的聚类算法，采用距离作为相似性的评价指标（两个样本的距离越近，相似度就越大）。 每个数据样本必须属于而且只能属于一个簇。 同一簇中的数据样本相似度高，不同簇中的数据样本相似度较小。 聚类相似度是利用各簇中样本的均值来进行计算的。 注：因为在该算法第一步中是随机的选取任意k个对象作为初始聚类的中心，初始地代表一个簇，因此k个初始类聚类中心点的选取对聚类
基于粒子群算法优化Kmeans聚类的居民用电行为分析研究（Matlb代码实现）
2301_77414277的博客
04-07 298
因此，提出利用粒子群优化（PSO）算法来优化K-means聚类，旨在提高聚类的准确性和效率。- **评估**：使用K-means算法根据每个粒子的位置（即聚类中心的候选）来分配数据点，并计算聚类质量（如总内聚度）作为该粒子的适应度值。- **聚类分析**：应用基于PSO优化的K-means算法进行聚类，以识别不同的用电行为模式。- **初始化**：随机初始化一组粒子，每个粒子代表一组可能的K-means聚类中心的解。- **更新**：根据粒子的个体经验和群体经验更新粒子的速度和位置，以寻找更好的聚类中心。
MATLAB实现聚类模型【数学建模、科学计算算法】
04-22
1. **K-means**：是最常用的聚类算法之一，基于迭代过程来最小化簇内的平方误差和。MATLAB中的`kmeans`函数提供了一种简单易用的接口，用户只需要指定数据集和簇的数量即可。 2. **层次聚类**：包括凝聚型...
【K-means聚类】K-means聚类与DBSCAN原理及代码实现
07-20
“聚类算法”是无监督学习中经常使用的算法，因此今天我们来聊聊两种典型聚类算法：K-means聚类算法及DBSCAN聚类算法。 通常来说，聚类是将数据集中的样本划分为若干个不相交的子集，每个子集称为一个簇（cluster）...
中文文本聚类
09-05
接着，k-means算法是无监督学习中的经典聚类算法，适用于处理大数据集。该算法通过迭代过程将数据点分配到最近的聚类中心，然后更新每个聚类的中心，直到聚类中心不再显著移动为止。在中文文本聚类中，通常先将文本...
基于数据挖掘的心力衰竭疾病风险评估系统
Python极客之家
08-25 587
本项目它利用大量患者数据，覆盖了40至95岁的广泛年龄群体，包含了丰富的生理和生活方式指标，通过 XGBoost 机器学习模型来预测心力衰竭的发作风险，测试集预测 AUC 达到 90.7%，并利用 Flask、Bootstrap、Ajax 搭建web系统，为医疗专业人员提供了深入理解心衰风险因素的新视角。
算法日记day 45（单调栈之每日温度|接雨水）
m0_74980681的博客
08-22 826
如果大于，则取栈顶元素为中间值并弹出栈顶元素，将遍历的元素与新的栈顶元素值比较取较小者，减去中间值得到高度h，然后栈顶元素下标值减去当前遍历的元素下标值再减一得到宽度w，最后高×宽得到面积，并记录，重复上述操作，直到遍历结束。第三种，如果遍历的元素值大于栈顶元素，用该下标减去栈顶元素下标，并将栈顶元素弹出，继续用该元素与新的栈顶元素比较，如果小于等于，则压入栈，如果大于，重复第三步操作。第一种，如果之后遍历的元素值小于栈顶压入的元素，将该元素的下标压入栈中。如果小于栈顶元素值，则压入栈内。
代码随想录算法训练营19-回溯1
weixin_53416771的博客
08-22 342
画出来的树是这样记录所有组合，一个变量current装当前的处理结果，一个res装所有的处理的结果下面的代码还可以剪枝优化。
【算法】深入浅出聚类算法：原理、应用与Java实现
最新发布
一个不断前行的程序者
08-26 446
聚类算法是一种将数据集中的对象自动划分为多个子集的算法。每个子集称为一个簇，簇内的对象具有较高的相似度，而簇与簇之间的相似度较低。聚类算法的主要目的是发现数据中的自然结构，而不是通过已知的类别标签。本文介绍了聚类算法的原理、应用场景以及如何在Java中实现一个简单的聚类算法。通过聚类算法，我们可以发现数据集中的自然结构，有助于更好地理解数据。在实际应用中，可以根据具体需求选择合适的聚类算法。希望本文能够帮助读者更好地理解和应用聚类算法。
最小区间00
青釉Oo的博客
08-21 470
最小区间
河南萌新2024第二场
2301_80281705的博客
08-25 224
将用户名和对应信息set映射到map中: map< string ,set< string > > 方便了存储。给两个整数a和b，输出a∗b 但是a,b非常大，0
算法笔试-编程练习-01-B-23
志远的博客
08-23 771
小红组内有 n 个人，大家合作完成了一个初版方案，初始时大家的愤怒值都是 0。 但是领导对方案并不满意，共需要修改 m 次方案，每次修改会先让第 l 到 r 个人的愤怒值加 1，然后再修改方案；
超分之最近邻插值、线性插值、双线性插值、双三次插值原理
weixin_44342777的博客
08-25 482
超分用于对照实验，或生成低分辨率数据集的常用插值方式：最近邻插值、线性插值、双线性插值、双三次插值的实现原理
代码随想录算法训练营第二十二天| 回溯算法理论基础 77. 组合 216.组合总和III 17.电话号码的字母组合
Mwicogito的博客
08-23 1083
回溯法章节开始，逐渐开始正式复习算法设计课的知识。文章图片来源：代码随想录 (https://programmercarl.com/)
代码随想录day46 647. 回文子串 516.最长回文子序列
weixin_45461296的博客
08-22 354
【代码】代码随想录day46 647. 回文子串 516.最长回文子序列。
Python——Kmeans聚类算法
04-29
Kmeans聚类算法是一种无监督学习算法，用于将数据集划分为不同的簇。它是一个迭代算法，通过计算每个数据点与簇中心的距离，将数据点分配到最近的簇中心。然后，根据分配的数据点更新簇中心。重复这个过程，直到簇中心不再变化或达到预设的迭代次数。 下面是一个使用Python实现Kmeans聚类算法的示例： ``` python import numpy as np import matplotlib.pyplot as plt # 生成随机数据 np.random.seed(0) X = np.random.randn(100, 2) # 初始化K个簇中心 K = 3 centers = X[np.random.choice(len(X), K, replace=False)] # 迭代聚类 for i in range(10): # 计算每个数据点最近的簇中心 distances = np.linalg.norm(X[:, np.newaxis, :] - centers, axis=2) labels = np.argmin(distances, axis=1) # 更新簇中心 for k in range(K): centers[k] = np.mean(X[labels == k], axis=0) # 可视化聚类结果 colors = ['r', 'g', 'b'] for k in range(K): plt.scatter(X[labels == k, 0], X[labels == k, 1], c=colors[k]) plt.scatter(centers[:, 0], centers[:, 1], marker='*', s=200, c='#050505') plt.show() ``` 在这个例子中，我们生成了一个随机数据集，然后初始化了3个簇中心。然后，我们执行10次迭代，计算每个数据点最近的簇中心，并根据分配的数据点更新簇中心。最后，我们可视化聚类结果，其中每个簇用不同的颜色表示，簇中心用星号表示。 Kmeans聚类算法是一种简单有效的聚类算法，但它有一些缺点。例如，它需要预先指定簇的数量K，这可能不是很容易确定。此外，它对初始簇中心的选择很敏感，可能会导致陷入局部最优解。因此，在实际应用中，需要对它进行改进，例如Kmeans++算法和层次聚类算法等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

zygswo

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值