使用golang实现k-means

最新推荐文章于 2024-05-22 10:04:23 发布
最新推荐文章于 2024-05-22 10:04:23 发布
阅读量515 收藏 10
点赞数 6
分类专栏： 机器学习 模式识别 文章标签： golang kmeans 开发语言 人工智能 算法 深度学习 机器学习
--simon
本文链接：https://blog.csdn.net/qq_38177830/article/details/138653422
版权

k-means聚类算法

K-Means是一种无监督算法，其目标是将数据进行分类。分类个数要求已知。

k-means流程

  1. 随机确定K个点作为质心、
  2. 找到离每个点最近的质心，将这个点分配到这个质心代表的簇里
  3. 再对每个簇进行计算，以点簇的均值点作为新的质心
  4. 如果新的质心和上一轮的不一样，则迭代进行2-3步骤，直到质心位置稳定

本文目标

  1. 在golang中实现k-means算法。
  2. 使用matplotlib绘制聚类散点图。
  3. 尝试并行处理。
  4. 与sklearn结果对比。

执行结果

左侧：输出
中间：本文效果
右侧：sklearn效果
500样本5中心
Q: 为什么样本一样，结果不同？
A: 两方面，首先算法的结束方法中阈值不同，然后是初始k均值点选择不同。

确定数据结构

我把kMeans封装成了对象，此外还有Point。实现如下

type (
	Point struct {
		X, Y float64
	}
	KMeans struct {
		points       []Point
		k            int
		distanceFunc distanceFunc
		avgPoints    []Point
	}
	distanceFunc func(p1, p2 Point) float64
)

生成随机样本

func generateRandomPoints(n int) []tool.Point {
	points := make([]tool.Point, n)
	for i := 0; i < n; i++ {
		points[i] = tool.Point{
			X: rand.Float64() * 100,
			Y: rand.Float64() * 100,
		}
	}
	return points
}

确定距离度量函数

	distance := func(p1, p2 tool.Point) float64 {
		return math.Sqrt(math.Pow(p1.X-p2.X, 2) + math.Pow(p1.Y-p2.Y, 2))
	}

初始化kmeans对象

func (kMeans *KMeans) Init(k int, points []Point, distanceFunc distanceFunc) {
	kMeans.k = k
	kMeans.points = points
	kMeans.distanceFunc = distanceFunc
	kMeans.avgPoints = make([]Point, kMeans.k)
}
func (kMeans *KMeans) initializeAvgPoints() {
	copy(kMeans.avgPoints, kMeans.points[:kMeans.k])
}

确定算法大致流程

func (kMeans *KMeans) Do(checkFunc func(oldCentroids, newCentroids []Point) bool) ([][]Point, int) {
	kMeans.initializeAvgPoints()
	var (
		clusters     [][]Point
		tmpAvgPoints []Point
		count        int
	)

	for {
		// 获取聚类含有哪些点
		clusters = kMeans.computeDistanceToAvgPoints()
		// 更新聚类中心
		tmpAvgPoints = kMeans.updateAvgPoints(clusters)
		// 检查质心位置的变化
		if checkFunc(kMeans.avgPoints, tmpAvgPoints) {
			break
		}

		// 更新质心位置
		kMeans.avgPoints = tmpAvgPoints
		count++
	}
	return clusters, count
}

计算聚类（尝试并发）

Q: 为什么可以并发？
A: 因为计算聚类时，对每个点的运算的独立的，依赖的数据不会在计算时修改。

func (kMeans *KMeans) computeDistanceToAvgPoints() [][]Point {
	type BakPoint struct {
		i int
		p Point
	}
	clusters := make([][]Point, len(kMeans.avgPoints))
	resultCh := make(chan BakPoint, len(kMeans.points))
	for _, point := range kMeans.points {
		computeMinDistanceForSignlePoint := func(point Point, avgPoints []Point, distanceFunc func(p1, p2 Point) float64, ch chan BakPoint) {
			minDistance := struct {
				d float64
				i int
			}{
				d: math.MaxFloat64,
				i: -1,
			}
			for i, avgPoint := range avgPoints {
				if d := distanceFunc(avgPoint, point); d < minDistance.d {
					minDistance.d = d
					minDistance.i = i
				}
			}
			ch <- BakPoint{p: point, i: minDistance.i}
		}
		go computeMinDistanceForSignlePoint(point, kMeans.avgPoints, kMeans.distanceFunc, resultCh)
	}

	for i := 0; i < len(kMeans.points); i++ {
		result := <-resultCh
		clusters[result.i] = append(clusters[result.i], result.p)
	}

	close(resultCh)
	return clusters
}

更新K均值点

func (kMeans *KMeans) updateAvgPoints(clusters [][]Point) []Point {
	centroids := make([]Point, kMeans.k)
	for i, cluster := range clusters {
		sumX, sumY := 0.0, 0.0
		for _, point := range cluster {
			sumX += point.X
			sumY += point.Y
		}
		centroids[i].X = sumX / float64(len(cluster))
		centroids[i].Y = sumY / float64(len(cluster))
	}
	return centroids
}

使用matplotlib绘制图像

import matplotlib.pyplot as plt


def readFromFile():
    clusters = []
    current_cluster = []

    with open('points.txt', 'r') as file:
        for line in file:
            if line.strip() == "----":
                if current_cluster:
                    clusters.append(current_cluster)
                    current_cluster = []
            else:
                x, y = map(float, line.split())
                current_cluster.append((x, y))

        if current_cluster:
            clusters.append(current_cluster)

    return clusters


clusters = readFromFile()

for cluster in clusters:
    X = [point[0] for point in cluster]
    Y = [point[1] for point in cluster]
    plt.scatter(X, Y, marker='.')

plt.xlabel('X')
plt.ylabel('Y')
plt.title('Clustered Scatter Plot')
plt.show()

使用sklearn计算

import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans

points = []
with open('rawpoints.txt', 'r') as file:
    for line in file:
        x, y = map(float, line.split())
        points.append([x, y])

X = np.array(points)

n_clusters = 5
kmeans = KMeans(n_clusters=n_clusters)
kmeans.fit(X)
labels = kmeans.labels_
centroids = kmeans.cluster_centers_

plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis', marker='.')
plt.scatter(centroids[:, 0], centroids[:, 1], marker='x', s=10, color='red', label='Centroids')
plt.xlabel('X')
plt.ylabel('Y')
plt.title('K-Means Clustering')
plt.legend()
plt.show()

完整代码

项目结构如下

KMeans-golang
│  go.mod
│  main.go
│  raw.py
│  show.py
└─tool
	kmeans.go

main.go

package main

import (
	"fmt"
	"k-means/tool"
	"math"
	"math/rand"
	"os"
	"os/exec"
	"time"
)

func generateRandomPoints(n int) []tool.Point {
	points := make([]tool.Point, n)
	for i := 0; i < n; i++ {
		points[i] = tool.Point{
			X: rand.Float64() * 100,
			Y: rand.Float64() * 100,
		}
	}
	return points
}

func wrapper(name string, fun func()) {
	start := time.Now()
	fun()
	elapsed := time.Since(start)
	fmt.Printf("%s 函数执行时间：%s\n", name, elapsed)
	fmt.Printf("%s 函数执行时间（纳秒）：%dns\n", name, elapsed.Nanoseconds())
}

func writeToFile(points [][]tool.Point) {
	file, err := os.Create("points.txt")
	if err != nil {
		fmt.Println("Failed to create file:", err)
		return
	}
	defer file.Close()

	for _, row := range points {
		for _, p := range row {
			_, err := fmt.Fprintf(file, "%f %f\n", p.X, p.Y)
			if err != nil {
				fmt.Println("Failed to write to file:", err)
				return
			}
		}
		_, err := fmt.Fprintf(file, "----\n")
		if err != nil {
			fmt.Println("Failed to write to file:", err)
			return
		}
	}
	fmt.Println("Data written to file successfully.")
}
func writeToFile2(points []tool.Point) {
	file, err := os.Create("rawpoints.txt")
	if err != nil {
		fmt.Println("Failed to create file:", err)
		return
	}
	defer file.Close()

	for _, p := range points {
		_, err := fmt.Fprintf(file, "%f %f\n", p.X, p.Y)
		if err != nil {
			fmt.Println("Failed to write to file:", err)
			return
		}
	}
	fmt.Println("Data written to file successfully.")
}
func main() {
	rand.Seed(time.Now().UnixNano())
	// 样本数据
	var points []tool.Point
	wrapper("生成样本", func() {
		points = generateRandomPoints(100)
	})

	k := 5
	distance := func(p1, p2 tool.Point) float64 {
		return math.Sqrt(math.Pow(p1.X-p2.X, 2) + math.Pow(p1.Y-p2.Y, 2))
	}
	kMeansObj := new(tool.KMeans)
	kMeansObj.Init(k, points, distance)

	var (
		finalClusters [][]tool.Point
		count         int
	)

	wrapper("执行算法", func() {
		finalClusters, count = kMeansObj.Do(func(oldCentroids, newCentroids []tool.Point) bool {
			epsilon := 0.000001
			for i := 0; i < len(oldCentroids); i++ {
				if distance(oldCentroids[i], newCentroids[i]) > epsilon {
					return false
				}
			}
			return true
		})
	})
	fmt.Println("count: ", count)
	wrapper("写入文件", func() {
		writeToFile2(points)
		writeToFile(finalClusters)
	})
	go func() {
		command := exec.Command("C:\\Projects\\PycharmProjects\\deelLearn\\venv\\Scripts\\python.exe", "raw.py")
		command.Run()
		command.Wait()
	}()
	command := exec.Command("C:\\Projects\\PycharmProjects\\deelLearn\\venv\\Scripts\\python.exe", "show.py")
	command.Run()
	command.Wait()
}

raw.py

import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans

points = []
with open('rawpoints.txt', 'r') as file:
    for line in file:
        x, y = map(float, line.split())
        points.append([x, y])

X = np.array(points)

n_clusters = 5
kmeans = KMeans(n_clusters=n_clusters)
kmeans.fit(X)
labels = kmeans.labels_
centroids = kmeans.cluster_centers_

plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis', marker='.')
plt.scatter(centroids[:, 0], centroids[:, 1], marker='x', s=10, color='red', label='Centroids')
plt.xlabel('X')
plt.ylabel('Y')
plt.title('K-Means Clustering')
plt.legend()
plt.show()

show.py

import matplotlib.pyplot as plt


def readFromFile():
    clusters = []
    current_cluster = []

    with open('points.txt', 'r') as file:
        for line in file:
            if line.strip() == "----":
                if current_cluster:
                    clusters.append(current_cluster)
                    current_cluster = []
            else:
                x, y = map(float, line.split())
                current_cluster.append((x, y))

        if current_cluster:
            clusters.append(current_cluster)

    return clusters


clusters = readFromFile()

for cluster in clusters:
    X = [point[0] for point in cluster]
    Y = [point[1] for point in cluster]
    plt.scatter(X, Y, marker='.')

plt.xlabel('X')
plt.ylabel('Y')
plt.title('Clustered Scatter Plot')
plt.show()

tool/kmeans.go

package tool

import "math"

type (
	Point struct {
		X, Y float64
	}
	KMeans struct {
		points       []Point
		k            int
		distanceFunc distanceFunc
		avgPoints    []Point
	}
	distanceFunc func(p1, p2 Point) float64
)

func (kMeans *KMeans) Init(k int, points []Point, distanceFunc distanceFunc) {
	kMeans.k = k
	kMeans.points = points
	kMeans.distanceFunc = distanceFunc
	kMeans.avgPoints = make([]Point, kMeans.k)
}

func (kMeans *KMeans) Do(checkFunc func(oldCentroids, newCentroids []Point) bool) ([][]Point, int) {
	kMeans.initializeAvgPoints()
	var (
		clusters     [][]Point
		tmpAvgPoints []Point
		count        int
	)

	for {
		// 获取聚类含有哪些点
		clusters = kMeans.computeDistanceToAvgPoints()
		// 更新聚类中心
		tmpAvgPoints = kMeans.updateAvgPoints(clusters)
		// 检查质心位置的变化
		if checkFunc(kMeans.avgPoints, tmpAvgPoints) {
			break
		}

		// 更新质心位置
		kMeans.avgPoints = tmpAvgPoints
		count++
	}
	return clusters, count
}

func (kMeans *KMeans) initializeAvgPoints() {
	copy(kMeans.avgPoints, kMeans.points[:kMeans.k])
}

func (kMeans *KMeans) computeDistanceToAvgPoints() [][]Point {
	type BakPoint struct {
		i int
		p Point
	}
	clusters := make([][]Point, len(kMeans.avgPoints))
	resultCh := make(chan BakPoint, len(kMeans.points))
	for _, point := range kMeans.points {
		computeMinDistanceForSignlePoint := func(point Point, avgPoints []Point, distanceFunc func(p1, p2 Point) float64, ch chan BakPoint) {
			minDistance := struct {
				d float64
				i int
			}{
				d: math.MaxFloat64,
				i: -1,
			}
			for i, avgPoint := range avgPoints {
				if d := distanceFunc(avgPoint, point); d < minDistance.d {
					minDistance.d = d
					minDistance.i = i
				}
			}
			ch <- BakPoint{p: point, i: minDistance.i}
		}
		go computeMinDistanceForSignlePoint(point, kMeans.avgPoints, kMeans.distanceFunc, resultCh)
	}

	for i := 0; i < len(kMeans.points); i++ {
		result := <-resultCh
		clusters[result.i] = append(clusters[result.i], result.p)
	}

	close(resultCh)
	return clusters
}

func (kMeans *KMeans) updateAvgPoints(clusters [][]Point) []Point {
	centroids := make([]Point, kMeans.k)
	for i, cluster := range clusters {
		sumX, sumY := 0.0, 0.0
		for _, point := range cluster {
			sumX += point.X
			sumY += point.Y
		}
		centroids[i].X = sumX / float64(len(cluster))
		centroids[i].Y = sumY / float64(len(cluster))
	}
	return centroids
}
有头发的琦玉
关注
  • 6
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
用Go编写的k均值聚类算法实现-Golang开发
05-26
用Go语言编写的kmeans k均值聚类算法实现它做了什么k-means聚类将多维数据集划分为k个聚类，其中每个数据点均属于用m个最近的kmeans k-means聚类算法实现的聚类k-均值聚类的作用将多维数据集划分为k个聚类，其中每个...
golang实现aes-256-cbc
02-21
golang标准库每次只支持加密16个字节（即128bit）长度的密钥，拿到二级密钥明文和IV向量后，无法解密openssl aes-256-cbc密文。
机器学习之聚类算法k-means
wys的博客
04-02 3846
一、目的意义 内容包括： （1）问题描述：k-means聚类算法的研究，此算法主要对二维数据点进行聚类。 二、算法阐述（占20%） ---输入：期望得到的簇的数目k，n个对象的二维数据D。 ---输出：k个簇的集合。 算法步骤： （1）输入k及n个二维数据对象 （2）随机选择k个对象作为初始的簇的质心 （3）repeat （4）计算每个对象与各个簇的质心的距离，...
从头开始用Go实现KNN和K-Means算法 | Gopher Daily (2020.12.20) ʕ◔ϖ◔ʔ
TonyBai
12-20 720
每日一谚：Use io.LimitReader to avoid reading too much into memory你想知道Go诞生背后的“故事”么？你知道Go三大巨头：Rober...
Golang标准库-syscall（什么是系统调用/Go 语言中的系统调用）
热门推荐
西京刀客
05-25 1万+
文章目录一、什么是系统调用二、Golang标准库-syscall1. syscall无处不在2. syscall demo举例： go版本的straceStracego版本的strace三、参考 一、什么是系统调用 In computing, a system call is the programmatic way in which a computer program requests a service from the kernel of the operating system it is exe
GoLang反射
m0_53157173的博客
08-15 5464
反射是 Go 语言比较重要的特性。虽然在大多数的应用和服务中并不常见，但是很多框架都依赖 Go 语言的反射机制实现简化代码的逻辑。因为 Go 语言的语法元素很少、设计简单，所以它没有特别强的表达能力，但是 Go 语言的 reflect 包能够弥补它在语法上的一些劣势。reflect 实现了运行时的反射能力，能够让程序操作不同类型的对象。...
Golang常见面试题及解答
Mr_XiMu的博客
10-16 3746
Golang常见面试题及解答
gjson - Golang 解析 JSON
yang_kaiyue的博客
02-09 938
gjson的使用
深入理解Golang Map原理
剑心！的博客
06-11 1873
哈希表 是一种古老的数据结构，在 1953 年就有人使用拉链法实现了哈希表，它能够根据键（Key）直接访问内存中的存储位置，也就是说我们能够直接通过键找到该键对应的一个值，哈希表名称的来源是因为它使用了哈希函数将一个键映射到一个桶中，这个桶中就可能包含该键对应的值。哈希函数（常被称为散列函数）是可以用于将任意大小的数据映射到固定大小值的函数，常见的包括MD5、SHA系列等。 一个设计优秀的哈希函数应该包含以下特性：哈希函数在实际中遇到的最常见的问题就是哈希碰撞, 即不同的键通过哈希函数可能产生相同的哈希值
Golang map 三板斧第三式：实现原理
Dablelv 的博客专栏。
11-08 688
Go map 底层实现方式是 Hash 表（C++ map 基于红黑树实现，而 C++ 11 新增的 unordered_map 则与 Go map 类似，都是基于 Hash 表实现）。Go map 的数据被置入一个由桶组成的有序数组中，每个桶最多可以存放 8 个键值对。key 的 Hash 值低位用于在该数组中定位到桶，而高 8 位则用于在桶中区分 key/value 对。Go map 的 hash 表中的基本单位是桶，每个桶最多存 8 个键值对，超了则会链接到额外的溢出桶。
golang编写mysql operator
niwoxiangyu的博客
02-09 454
当集群的Spec（GreatDBClusterSpec）发生变化，比如用户修改了replica字段的值，operator将调动k8s资源使得集群status趋近于期望spec，具体表现为service/statefulset/pod等k8s内置资源的增删更新的操作（operator本质上也是调用k8s内置的controller）。Go语言是一种非常适合编写Kubernetes operator的语言，因为它具有高效的性能，易于编写和维护的代码，并且Kubernetes的大部分代码都是使用Go语言编写的。
golang-hex-dumper
05-01
golang-hex-dumper 一个简单的十六进制转储库例程，用于需要深入研究二进制文件的诊断。 以十六进制显示字节。 随附gohexdump目录中的示例命令行工具。 go get github.com/glycerine/golang-hex-dumper/... ...
用于分布式速率限制的滑动窗口算法的Golang实现。-Golang开发
05-26
滑动窗口算法的分布式窗口限速的Golang实现。 安装$ go get -u github.com/RussellLuo/slidingwindow设计slidewindow是t slidewindowow的一种实现，Golang是滑动窗口算法的一种实现，用于分布式速率限制。 安装$ go ...
Kafka有线协议的Golang实现。-Golang开发
05-26
软件包libkafka是一个低级库，用于从Kafka 2.3+生成和使用。 它没有外部依赖性。...它实现了单个分区Producer和Consumer。 多分区生产者和使用者建立在该库的顶部（示例：https://github.com/mkocikowski/kafkaclie
【博客714】golang使用mmap来优化gc
qq_43684922的博客
05-21 241
需要处理的对象非常多时，比如：时序数据库victoriametrics源码中，利用了mmap申请内存并自己维护，从而避免过多gc影响性能，因为频繁申请和释放堆对象会降低性能。
Go 语言中的 Viper 库来读取 YAML 配置文件
qq_28979487的博客
05-21 478
包，包含一个结构体来映射 YAML 配置文件中的数据库配置信息。然后，我们使用 Viper 读取和解析配置文件，并将配置信息保存到全局变量。安装 Viper： 首先，你需要确保已经安装了 Viper。最后，在主程序中初始化配置并使用全局变量中的数据库配置信息来连接数据库。修改为你实际的包路径，并根据需要调整代码来适应你具体的项目结构和需求。函数来初始化配置，并将数据库配置信息设置为全局变量。创建一个结构体来映射配置文件中的数据库配置信息。文件，并将配置信息加载到结构体中。在这个示例中，我们创建了一个。
Golang的基本使用
qq2904529388的博客
05-21 363
上面的程序中后台Goroutine向管道输入自然数序列，main函数中输出序列。使用 valgrind 运行 程序,发现 协程内存并没有回收。这样就避免了Goroutine的泄漏。当main函数在break跳出循环时，那么协程用什么与主协程通信呢?动态数组(array)
Golang：使用jszwec/csvutil读取csv文件
最新发布
彭世瑜的博客
05-22 315
jszwec/csvutil 高性能、惯用的CSV记录编码和解码到本机Go结构。要读取的文件 user.csv。
golang 实现aes-128-gcm
01-11
golang 提供了标准库 crypto/aes 来实现 AES 加密算法，同时也支持 gcm 模式。要实现 AES-128-GCM 加密，首先需要生成一个 128 位的密钥，并且创建一个 AES 实例来进行加密操作。接着还需要创建一个 gcm 实例来进行 gcm 模式的加密。 首先，可以使用 crypto/rand 包生成一个随机的 128 位密钥，代码如下： ``` key := make([]byte, 16) if _, err := rand.Read(key); err != nil { panic(err.Error()) } ``` 随后，可以使用 aes.NewCipher() 来创建一个 AES 实例，代码如下： ``` block, err := aes.NewCipher(key) if err != nil { panic(err.Error()) } ``` 然后，可以使用 cipher.NewGCM() 来创建一个 gcm 实例，代码如下： ``` gcm, err := cipher.NewGCM(block) if err != nil { panic(err.Error()) } ``` 最后，可以使用 gcm.Seal() 方法来进行 AES-128-GCM 加密操作，代码如下： ``` nonce := make([]byte, gcm.NonceSize()) if _, err = io.ReadFull(rand.Reader, nonce); err != nil { panic(err.Error()) } ciphertext := gcm.Seal(nonce, nonce, plaintext, nil) ``` 通过上面的步骤，就可以在 golang 中实现 AES-128-GCM 加密了。需要注意的是，在实际使用时，还需要对密钥进行妥善管理，以及对加密结果进行适当的存储和传输。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

有头发的琦玉

打点钱，我会再努力的

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

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

打赏作者

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

抵扣说明：

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

余额充值