1、任意选取K个对象作为初始聚类中心(O1,O2,…Oi…Ok)。
2)将余下的对象分到各个类中去(该对象与哪一个聚类中心最近就被分配到哪一个聚类簇中);
3)对于每个类(Oi)中,顺序选取一个Or,重复步骤2,计算用Or代替Oi后的误差E=各个点到其对应的中心点欧式距离之和。选择E最小的那个Or来代替Oi。
4)重复步骤3,直到K个medoids固定下来。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
namespace K_medoids
{
class Program
{
/// <summary>
/// 程序文本数据文件应位于同一文件夹下
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
var path = string.Empty;
int k = 0;
try
{
path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, args[0]);//数据文件路径
k = Convert.ToInt32(args[1]);
}
catch (Exception)
{
Console.Write("参数错误");
return;
}
var reader=new StreamReader(path,Encoding.Default);
var indivadulStr =reader.ReadLine().Trim();//每一行数据的字符串形式
var stanStr= System.Text.RegularExpressions.Regex.Replace(indivadulStr, @" +", " ");
var firstData=stanStr.Split(' ');//第一行数据
var realIndivadul = new Indivaduls();//数据结构体
var db = new List<Indivaduls>();//存放所有数据
foreach (var s in firstData)
{
realIndivadul.Numbers.Add(Convert.ToDouble(s));
}
db.Add(realIndivadul);
while ((indivadulStr=reader.ReadLine())!=null)
{
var stringNumber = indivadulStr.Trim().Split(' ');
var doubleNumber = stringNumber.Select(Convert.ToDouble).ToList();
db.Add(new Indivaduls(){Numbers =doubleNumber});
}
var initialCenters = new List<Indivaduls>();//聚类初始中心个体
var gap = db.Count/k + 1;
for (int i = 0; i < k; i++)
{
initialCenters.Add(db[i*gap]);
}
var result=Pam(db, initialCenters);
foreach (var crow in result)
{
foreach (var number in crow.CenterPoint.Numbers)
{
Console.Write(number+"\0");
}
Console.Write("\r\n");
foreach (var point in crow.CrowsPoint)
{
foreach (var number in point.Numbers)
{
Console.Write(number+"\0");
}
Console.Write("\r\n");
}
Console.WriteLine("========================");
}
Console.ReadKey();
}
/// <summary>
///
/// </summary>
/// <param name="indivadulses"></param>
/// <param name="centerPoints"></param>
/// <returns>聚类结果 簇</returns>
public static List<Crows> Pam(List<Indivaduls> indivadulses,List<Indivaduls> centerPoints )
{
var firstCrows = K_medoids(indivadulses, centerPoints);
var resultCenterPoints = new List<Indivaduls>();//存放结果中心点
for (int i = 0; i < firstCrows.Count; i++)//循环每一个簇
{
resultCenterPoints.Add(firstCrows[i].CenterPoint);
var oldOtherCrows =new List<Crows>();
oldOtherCrows.AddRange(firstCrows);
oldOtherCrows.RemoveAt(i);
var oldDiff = AbsoluteDiff(firstCrows[i], oldOtherCrows);
var count=firstCrows[i].CrowsPoint.Count;
for (int j = 0; j < count; j++)//循环每一个簇中的非中心点个体
{
//var otherCrowsss = new List<Crows>();//除去要替换的中心点所在的簇 其他簇
//otherCrowsss.AddRange(firstCrows);
//otherCrowsss.RemoveAt(i);
var newCenterPoints = new List<Indivaduls>();//新的中心点集合
newCenterPoints.AddRange(centerPoints);
newCenterPoints.RemoveAt(i);
newCenterPoints.Add(firstCrows[i].CrowsPoint[j]);
var newOtherCrowsCenterPoints = new List<Indivaduls>();//新的除变化点所在簇的中心 的其他中心点
newOtherCrowsCenterPoints.AddRange(centerPoints);
newOtherCrowsCenterPoints.RemoveAt(i);
var newCrows = K_medoids(indivadulses,newCenterPoints); //替换点后 新的聚类簇
var newOtherCrows = new List<Crows>();
var newCrow = new Crows();
foreach (var crow in newCrows)
{
if (newOtherCrowsCenterPoints.MyContains(crow.CenterPoint))
{
newOtherCrows.Add(crow);
}
else
{
newCrow = crow;
}
}
var newDiff = AbsoluteDiff(newCrow,newOtherCrows);
if (newDiff < oldDiff)
{
resultCenterPoints[i] = newCrow.CenterPoint;
oldDiff = newDiff;
}
}
}
var resultCrows= K_medoids(indivadulses, resultCenterPoints);
return resultCrows;
}
/// <summary>
/// 单次聚类
/// </summary>
/// <param name="indivadulses">待聚类个体,包括了中心点</param>
/// <param name="centerPoints">中心点个体</param>
/// <returns>聚类结果</returns>
public static List<Crows> K_medoids(List<Indivaduls> indivadulses,List<Indivaduls> centerPoints)
{
var resultCrows = new List<Crows>();//聚类结果 簇集合
var indivadulsCount = indivadulses.Count;//待分配个体的个数,包括了中心点
for (var i = 0; i < centerPoints.Count; i++)
{
resultCrows.Add(new Crows() { CenterPoint = centerPoints[i] });
}
for (int i = 0; i < indivadulsCount; i++)
{
if (!centerPoints.MyContains(indivadulses[i]))
{
int myNumber = 0;//要将这个点归类到 序号为0的resultCrows中
var firstDic = P2PDistance(indivadulses[i], resultCrows[0].CenterPoint);//该点与第一个中心的距离
for (int j = 1; j < resultCrows.Count; j++)
{
var otherDic = P2PDistance(indivadulses[i], resultCrows[j].CenterPoint);
if (otherDic < firstDic)
{
firstDic = otherDic;
myNumber = j;
}
}
resultCrows[myNumber].CrowsPoint.Add(indivadulses[i]);
}
}
return resultCrows;
}
/// <summary>
/// 对于已经完成一次聚类后的某一个点center计算绝对误差
/// </summary>
/// <param name="centerCrow">要计算绝对误差的中心点群簇</param>
/// <param name="otherPoints">除中心点群簇外的其他群簇</param>
public static double AbsoluteDiff(Crows centerCrow,List<Crows> otherPoints )
{
var countCrows = otherPoints.Count;
var distance = Distance(centerCrow);
for (var i = 0; i < countCrows; i++)
{
distance += Distance(otherPoints[i]);
}
return distance;
}
/// <summary>
/// 计算群簇中各个点距离中心点的欧式距离
/// </summary>
/// <param name="crow">群簇</param>
/// <returns>欧式距离</returns>
public static double Distance(Crows crow)
{
var pointCount = crow.CrowsPoint.Count;//非中心点的个数
var distance = 0.0;//总距离
for (var i = 0; i < pointCount; i++)
{
distance += P2PDistance(crow.CenterPoint, crow.CrowsPoint[i]);
}
return distance;
}
/// <summary>
/// 两点间欧式距离
/// </summary>
/// <param name="p1">点p1</param>
/// <param name="p2">点p2</param>
/// <returns></returns>
public static double P2PDistance(Indivaduls p1,Indivaduls p2)
{
if (p1.Numbers.Count != p2.Numbers.Count || p1.Numbers.Count == 0)
{
throw new Exception();
}
var dimension = p1.Numbers.Count;
var result = 0.0;
for (var i = 0; i < dimension; i++)
{
result += (p1.Numbers[i] - p2.Numbers[i])*(p1.Numbers[i] - p2.Numbers[i]);
}
return Math.Sqrt(result);
}
}
/// <summary>
/// 一个点个体
/// </summary>
public class Indivaduls
{
public List<double> Numbers;
public Indivaduls()
{
this.Numbers=new List<double>();
}
public bool MyEquals(Indivaduls obj)
{
if (obj.Numbers.Count != this.Numbers.Count)
return false;
for (int i = 0; i < Numbers.Count; i++)
{
if (this.Numbers[i] != obj.Numbers[i])
return false;
}
return true;
}
}
/// <summary>
/// 一个聚类簇
/// </summary>
public class Crows
{
public Crows()
{
this.CrowsPoint=new List<Indivaduls>();
this.CenterPoint=new Indivaduls();
}
public List<Indivaduls> CrowsPoint;//簇中除中心点外的其他个体点
public Indivaduls CenterPoint;//聚类簇中心点
}
public static class ExpandList
{
/// <summary>
/// 扩展方法、判断该集合中是否存在point个体
/// </summary>
/// <param name="indivadulses"></param>
/// <param name="point"></param>
/// <returns></returns>
public static bool MyContains(this List<Indivaduls> indivadulses,Indivaduls point)
{
foreach (var indivadulse in indivadulses)
{
if (point.MyEquals(indivadulse))
return true;
}
return false;
}
}
}