Go语言机器学习实战：聚类算法与无监督学习

左手厨刀右手茼蒿

164人浏览 · 2026-05-29 11:49:38

左手厨刀右手茼蒿 · 2026-05-29 11:49:38 发布

Go语言机器学习实战：聚类算法与无监督学习

无监督学习是机器学习的重要分支，它从无标签数据中发现模式和结构。聚类算法是无监督学习的核心，本文将深入探讨如何使用Go语言实现常见的聚类算法。

文章总体概览信息图

一、聚类算法概述

聚类是将数据点分组的过程，使得同一组内的数据点相似度较高，而不同组之间的数据点相似度较低。常见的聚类算法包括：

K-Means：基于距离的划分方法，简单高效
层次聚类：构建层次化的聚类树
DBSCAN：基于密度的聚类，能发现任意形状的簇
高斯混合模型：概率模型，考虑数据的分布

二、K-Means聚类实现

2.1 算法原理

K-Means算法的核心思想是：

随机选择K个初始质心
将每个数据点分配到最近的质心
重新计算每个簇的质心
重复步骤2-3直到收敛

2.2 Go语言实现

package main

import (
    "fmt"
    "math"
    "math/rand"
    "time"
)

type Point struct {
    Features []float64
}

type KMeans struct {
    K         int
    Centroids []Point
    MaxIter   int
}

func NewKMeans(k, maxIter int) *KMeans {
    return &KMeans{
        K:       k,
        MaxIter: maxIter,
    }
}

func (km *KMeans) distance(p1, p2 Point) float64 {
    var sum float64
    for i := 0; i < len(p1.Features); i++ {
        sum += math.Pow(p1.Features[i]-p2.Features[i], 2)
    }
    return math.Sqrt(sum)
}

func (km *KMeans) fit(points []Point) {
    rand.Seed(time.Now().UnixNano())
    
    // 随机初始化质心
    km.Centroids = make([]Point, km.K)
    for i := 0; i < km.K; i++ {
        idx := rand.Intn(len(points))
        km.Centroids[i] = points[idx]
    }
    
    for iter := 0; iter < km.MaxIter; iter++ {
        // 分配数据点到簇
        clusters := make([][]Point, km.K)
        for _, point := range points {
            minDist := math.MaxFloat64
            clusterIdx := 0
            for i, centroid := range km.Centroids {
                dist := km.distance(point, centroid)
                if dist < minDist {
                    minDist = dist
                    clusterIdx = i
                }
            }
            clusters[clusterIdx] = append(clusters[clusterIdx], point)
        }
        
        // 更新质心
        prevCentroids := make([]Point, km.K)
        copy(prevCentroids, km.Centroids)
        
        for i, cluster := range clusters {
            if len(cluster) == 0 {
                continue
            }
            newCentroid := Point{Features: make([]float64, len(cluster[0].Features))}
            for _, point := range cluster {
                for j := 0; j < len(point.Features); j++ {
                    newCentroid.Features[j] += point.Features[j]
                }
            }
            for j := 0; j < len(newCentroid.Features); j++ {
                newCentroid.Features[j] /= float64(len(cluster))
            }
            km.Centroids[i] = newCentroid
        }
        
        // 检查收敛
        converged := true
        for i := 0; i < km.K; i++ {
            if km.distance(km.Centroids[i], prevCentroids[i]) > 1e-6 {
                converged = false
                break
            }
        }
        if converged {
            fmt.Printf("算法在第%d次迭代收敛\n", iter+1)
            break
        }
    }
}

func (km *KMeans) predict(point Point) int {
    minDist := math.MaxFloat64
    clusterIdx := 0
    for i, centroid := range km.Centroids {
        dist := km.distance(point, centroid)
        if dist < minDist {
            minDist = dist
            clusterIdx = i
        }
    }
    return clusterIdx
}

2.3 使用示例

func main() {
    // 生成模拟数据
    points := []Point{
        {Features: []float64{1, 2}},
        {Features: []float64{2, 1}},
        {Features: []float64{2, 3}},
        {Features: []float64{8, 7}},
        {Features: []float64{9, 8}},
        {Features: []float64{7, 9}},
        {Features: []float64{15, 16}},
        {Features: []float64{16, 15}},
        {Features: []float64{17, 17}},
    }
    
    kmeans := NewKMeans(3, 100)
    kmeans.fit(points)
    
    fmt.Println("质心坐标:")
    for i, centroid := range kmeans.Centroids {
        fmt.Printf("簇%d: %v\n", i, centroid.Features)
    }
    
    // 预测新数据点
    testPoint := Point{Features: []float64{10, 10}}
    cluster := kmeans.predict(testPoint)
    fmt.Printf("数据点(10, 10)属于簇%d\n", cluster)
}

三、DBSCAN聚类实现

3.1 算法原理

DBSCAN（Density-Based Spatial Clustering of Applications with Noise）是一种基于密度的聚类算法：

核心点：在指定半径ε内有至少MinPts个邻居
边界点：在ε内邻居数少于MinPts，但属于某个核心点的邻域
噪声点：既不是核心点也不是边界点

3.2 Go语言实现

type DBSCAN struct {
    Epsilon   float64
    MinPts    int
    labels    []int
}

func NewDBSCAN(epsilon float64, minPts int) *DBSCAN {
    return &DBSCAN{
        Epsilon: epsilon,
        MinPts:  minPts,
    }
}

func (d *DBSCAN) fit(points []Point) {
    n := len(points)
    d.labels = make([]int, n)
    for i := range d.labels {
        d.labels[i] = -1 // -1表示未访问
    }
    
    clusterID := 0
    for i := 0; i < n; i++ {
        if d.labels[i] != -1 {
            continue
        }
        
        neighbors := d.rangeQuery(points, i)
        
        if len(neighbors) < d.MinPts {
            d.labels[i] = 0 // 标记为噪声
            continue
        }
        
        // 扩展簇
        d.expandCluster(points, i, neighbors, clusterID)
        clusterID++
    }
}

func (d *DBSCAN) rangeQuery(points []Point, idx int) []int {
    neighbors := []int{}
    for i := 0; i < len(points); i++ {
        if i == idx {
            continue
        }
        dist := d.distance(points[idx], points[i])
        if dist <= d.Epsilon {
            neighbors = append(neighbors, i)
        }
    }
    return neighbors
}

func (d *DBSCAN) expandCluster(points []Point, idx int, neighbors []int, clusterID int) {
    d.labels[idx] = clusterID
    queue := neighbors
    
    for len(queue) > 0 {
        current := queue[0]
        queue = queue[1:]
        
        if d.labels[current] == 0 {
            d.labels[current] = clusterID
        }
        
        if d.labels[current] != -1 {
            continue
        }
        
        d.labels[current] = clusterID
        currentNeighbors := d.rangeQuery(points, current)
        
        if len(currentNeighbors) >= d.MinPts {
            queue = append(queue, currentNeighbors...)
        }
    }
}

func (d *DBSCAN) distance(p1, p2 Point) float64 {
    var sum float64
    for i := 0; i < len(p1.Features); i++ {
        sum += math.Pow(p1.Features[i]-p2.Features[i], 2)
    }
    return math.Sqrt(sum)
}

四、层次聚类

4.1 算法原理

层次聚类有两种策略：

凝聚式：从单个点开始，逐步合并相似的簇
分裂式：从整个数据集开始，逐步分裂

4.2 Go语言实现

type HierarchicalClustering struct {
    linkage string // "single", "complete", "average"
}

func NewHierarchicalClustering(linkage string) *HierarchicalClustering {
    return &HierarchicalClustering{linkage: linkage}
}

func (hc *HierarchicalClustering) fit(points []Point) [][]Point {
    // 初始化每个点为一个簇
    clusters := make([][]Point, len(points))
    for i, point := range points {
        clusters[i] = []Point{point}
    }
    
    for len(clusters) > 1 {
        minDist := math.MaxFloat64
        mergeI, mergeJ := 0, 1
        
        // 找到距离最近的两个簇
        for i := 0; i < len(clusters); i++ {
            for j := i + 1; j < len(clusters); j++ {
                dist := hc.clusterDistance(clusters[i], clusters[j])
                if dist < minDist {
                    minDist = dist
                    mergeI, mergeJ = i, j
                }
            }
        }
        
        // 合并两个簇
        merged := append(clusters[mergeI], clusters[mergeJ]...)
        clusters = append(clusters[:mergeJ], clusters[mergeJ+1:]...)
        clusters[mergeI] = merged
    }
    
    return clusters
}

func (hc *HierarchicalClustering) clusterDistance(c1, c2 []Point) float64 {
    switch hc.linkage {
    case "single":
        return hc.singleLinkage(c1, c2)
    case "complete":
        return hc.completeLinkage(c1, c2)
    case "average":
        return hc.averageLinkage(c1, c2)
    default:
        return hc.singleLinkage(c1, c2)
    }
}

func (hc *HierarchicalClustering) singleLinkage(c1, c2 []Point) float64 {
    minDist := math.MaxFloat64
    for _, p1 := range c1 {
        for _, p2 := range c2 {
            dist := hc.pointDistance(p1, p2)
            if dist < minDist {
                minDist = dist
            }
        }
    }
    return minDist
}

func (hc *HierarchicalClustering) completeLinkage(c1, c2 []Point) float64 {
    maxDist := 0.0
    for _, p1 := range c1 {
        for _, p2 := range c2 {
            dist := hc.pointDistance(p1, p2)
            if dist > maxDist {
                maxDist = dist
            }
        }
    }
    return maxDist
}

func (hc *HierarchicalClustering) averageLinkage(c1, c2 []Point) float64 {
    var sumDist float64
    count := 0
    for _, p1 := range c1 {
        for _, p2 := range c2 {
            sumDist += hc.pointDistance(p1, p2)
            count++
        }
    }
    return sumDist / float64(count)
}

func (hc *HierarchicalClustering) pointDistance(p1, p2 Point) float64 {
    var sum float64
    for i := 0; i < len(p1.Features); i++ {
        sum += math.Pow(p1.Features[i]-p2.Features[i], 2)
    }
    return math.Sqrt(sum)
}

五、高斯混合模型（GMM）

5.1 算法原理

GMM假设数据来自多个高斯分布的混合，使用EM算法进行参数估计。

5.2 Go语言实现

type Gaussian struct {
    Mean   float64
    StdDev float64
}

func (g *Gaussian) pdf(x float64) float64 {
    return math.Exp(-math.Pow(x-g.Mean, 2)/(2*math.Pow(g.StdDev, 2))) / (g.StdDev * math.Sqrt(2*math.Pi))
}

type GMM struct {
    Gaussians []Gaussian
    Weights   []float64
}

func NewGMM(k int) *GMM {
    return &GMM{
        Gaussians: make([]Gaussian, k),
        Weights:   make([]float64, k),
    }
}

func (gmm *GMM) fit(data []float64, maxIter int) {
    n := len(data)
    k := len(gmm.Gaussians)
    
    // 初始化
    for i := 0; i < k; i++ {
        gmm.Gaussians[i] = Gaussian{
            Mean:   data[i*n/k],
            StdDev: 1.0,
        }
        gmm.Weights[i] = 1.0 / float64(k)
    }
    
    for iter := 0; iter < maxIter; iter++ {
        // E步：计算后验概率
        responsibilities := make([][]float64, k)
        for i := range responsibilities {
            responsibilities[i] = make([]float64, n)
        }
        
        for j := 0; j < n; j++ {
            var sum float64
            for i := 0; i < k; i++ {
                responsibilities[i][j] = gmm.Weights[i] * gmm.Gaussians[i].pdf(data[j])
                sum += responsibilities[i][j]
            }
            for i := 0; i < k; i++ {
                responsibilities[i][j] /= sum
            }
        }
        
        // M步：更新参数
        for i := 0; i < k; i++ {
            var weightSum, meanSum, varSum float64
            for j := 0; j < n; j++ {
                weightSum += responsibilities[i][j]
                meanSum += responsibilities[i][j] * data[j]
            }
            
            gmm.Weights[i] = weightSum / float64(n)
            gmm.Gaussians[i].Mean = meanSum / weightSum
            
            for j := 0; j < n; j++ {
                varSum += responsibilities[i][j] * math.Pow(data[j]-gmm.Gaussians[i].Mean, 2)
            }
            gmm.Gaussians[i].StdDev = math.Sqrt(varSum / weightSum)
        }
    }
}

六、聚类评估指标

func SilhouetteScore(points []Point, labels []int) float64 {
    n := len(points)
    silhouette := make([]float64, n)
    
    for i := 0; i < n; i++ {
        // 计算a(i)：同一簇内其他点的平均距离
        var a float64
        sameCluster := []Point{}
        for j := 0; j < n; j++ {
            if i != j && labels[j] == labels[i] {
                sameCluster = append(sameCluster, points[j])
            }
        }
        if len(sameCluster) > 0 {
            for _, p := range sameCluster {
                a += distance(points[i], p)
            }
            a /= float64(len(sameCluster))
        }
        
        // 计算b(i)：最近簇的平均距离
        b := math.MaxFloat64
        clusters := make(map[int][]Point)
        for j := 0; j < n; j++ {
            if j != i {
                clusters[labels[j]] = append(clusters[labels[j]], points[j])
            }
        }
        for _, cluster := range clusters {
            if len(cluster) > 0 {
                var distSum float64
                for _, p := range cluster {
                    distSum += distance(points[i], p)
                }
                avgDist := distSum / float64(len(cluster))
                if avgDist < b {
                    b = avgDist
                }
            }
        }
        
        silhouette[i] = (b - a) / math.Max(a, b)
    }
    
    var score float64
    for _, s := range silhouette {
        score += s
    }
    return score / float64(n)
}

func distance(p1, p2 Point) float64 {
    var sum float64
    for i := 0; i < len(p1.Features); i++ {
        sum += math.Pow(p1.Features[i]-p2.Features[i], 2)
    }
    return math.Sqrt(sum)
}