具有初始中心的 K 均值

Question

我正在对 n 个点和 k 个中心进行 K 均值聚类。

首先，这是我目前的代码：

一个点的类：

public class Point
{

    public int Id { get; set; }
    public double X { get; set; }
    public double Y { get; set; }


    public Point()
    {
        Id = -1;
        X = -1;
        Y = -1;
    }

    public Point(int id, double x, double y)
    {
        this.Id = id;
        this.X = x;
        this.Y = y;
    }

    public static double FindDistance(Point pt1, Point pt2)
    {
        double x1 = pt1.X, y1 = pt1.Y;
        double x2 = pt2.X, y2 = pt2.Y;

        double distance = Math.Sqrt(Math.Pow(x2 - x1, 2.0) + Math.Pow(y2 - y1, 2.0));
        return (distance);
    }
}

数据类：

public class PointCollection : List<Point>
{

    public Point Centroid { get; set; }

    public PointCollection()
        : base()
    {
        Centroid = new Point();
    }

    public void AddPoint(Point p)
    {
        this.Add(p);
        UpdateCentroid();
    }

    public Point RemovePoint(Point p)
    {
        Point removedPoint = new Point(p.Id, p.X, p.Y);
        this.Remove(p);
        UpdateCentroid();

        return (removedPoint);
    }

    public void UpdateCentroid()
    {
        double xSum = (from p in this select p.X).Sum();
        double ySum = (from p in this select p.Y).Sum();
        Centroid.X = (xSum / (double)this.Count);
        Centroid.Y = (ySum / (double)this.Count);
    }
}

主类：

public class KMeans
{
    public static List<PointCollection> DoKMeans(PointCollection points, int clusterCount)
    {
        List<PointCollection> allClusters = new List<PointCollection>();
        List<List<Point>> allGroups = ListUtility.SplitList<Point>(points, clusterCount);
        foreach (List<Point> group in allGroups)
        {
            PointCollection cluster = new PointCollection();
            cluster.AddRange(group);
            allClusters.Add(cluster);
        }

        int movements = 1;
        while (movements > 0)
        {
            movements = 0;

            foreach (PointCollection cluster in allClusters) 
            {
                for (int pointIndex = 0; pointIndex < cluster.Count; pointIndex++) 
                {
                    Point point = cluster[pointIndex];

                    int nearestCluster = FindNearestCluster(allClusters, point);
                    if (nearestCluster != allClusters.IndexOf(cluster)) 
                    {
                        if (cluster.Count > 1) 
                        {
                            Point removedPoint = cluster.RemovePoint(point);
                            allClusters[nearestCluster].AddPoint(removedPoint);
                            movements += 1;
                        }
                    }
                }
            }
        }

        return (allClusters);
    }

    public static int FindNearestCluster(List<PointCollection> allClusters, Point point)
    {
        double minimumDistance = 0.0;
        int nearestClusterIndex = -1;

        for (int k = 0; k < allClusters.Count; k++) 
        {
            double distance = Point.FindDistance(point, allClusters[k].Centroid);
            if (k == 0)
            {
                minimumDistance = distance;
                nearestClusterIndex = 0;
            }
            else if (minimumDistance > distance)
            {
                minimumDistance = distance;
                nearestClusterIndex = k;
            }
        }

        return (nearestClusterIndex);
    }
}

最后是列表拆分的帮助功能：

public static List<List<T>> SplitList<T>(List<T> items, int groupCount)
    {
        List<List<T>> allGroups = new List<List<T>>();

        int startIndex = 0;
        int groupLength = (int)Math.Round((double)items.Count / (double)groupCount, 0);
        while (startIndex < items.Count)
        {
            List<T> group = new List<T>();
            group.AddRange(items.GetRange(startIndex, groupLength));
            startIndex += groupLength;

            if (startIndex + groupLength > items.Count)
            {
                groupLength = items.Count - startIndex;
            }

            allGroups.Add(group);
        }

        if (allGroups.Count > groupCount && allGroups.Count > 2)
        {
            allGroups[allGroups.Count - 2].AddRange(allGroups.Last());
            allGroups.RemoveAt(allGroups.Count - 1);
        }

        return (allGroups);
    }

所以，现在我正在尝试为主类编写第二种方法，该方法将接受预定义的起始中心。不过，我很难理解这一点，因为我在互联网上找不到任何 k-means 算法会使用初始中心的东西。有人可以为我指明此类指南的方向或给我任何如何修改代码的想法吗？谢谢。

编辑：也许还有更多我为什么要这样做：我尝试使用 k-means 编写 LBG 算法，就像https://onlinecourses.science.psu.edu/stat557/node/67

我可以使用我的代码访问计算中心以拆分每个步骤，但是我需要找到一种方法将它们反馈给 k-means 类。比如，如果我计算了起始中心，我需要将这个中心和另一个 epsilon 偏移量放入 k-means 算法中。

Edit2：现在用英文编码（我希望）

Answer 1

找到了解决办法，也许有人会用：

public static List<PointCollection> DoKMeans(PointCollection points, int clusterCount, Point[] startingCentres)
{
    // code...
    int ctr = 0;
    foreach (List<Point> group in allGroups)
    {
        PointCollection cluster = new PointCollection();
        cluster.c.X = startingCentres[ctr].X;
        cluster.c.Y = startingCentres[ctr].Y;
        cluster.AddRange(group);
        allClusters.Add(cluster);
    }
    // rest of code the same
}