public static int[] KmeansClustering(Dictionary <int, double>[] docVectors, int clusterNumber)
{
KmeansDoc[] docs = new KmeansDoc[docVectors.Length];
for (int idoc = 0; idoc < docVectors.Length; idoc++)
{
docs[idoc] = new KmeansDoc(docVectors[idoc]);
}
return(KMeans.Cluster(docs.ToList(), clusterNumber));
}
private void Start()
{
data = new Vector3[sampleSize];
for (int i = 0; i < data.Length; i++)
{
float x = Random.Range(-1f, 1f);
float y = Random.Range(-1f, 1f);
float z = Random.Range(-1f, 1f);
data[i] = new Vector3(x, y, z) * spaceSize;
}
result = KMeans.Cluster(data, clustersCount, iterations, 0);
}
private void Start()
{
data = new Bounds[sampleSize];
for (int i = 0; i < data.Length; i++)
{
float x = Random.Range(-1f, 1f);
float y = Random.Range(-1f, 1f);
float z = Random.Range(-1f, 1f);
float sx = Random.Range(0.1f, boxMaxSize);
float sy = Random.Range(0.1f, boxMaxSize);
float sz = Random.Range(0.1f, boxMaxSize);
data[i] = new Bounds(new Vector3(x, y, z) * spaceSize, new Vector3(sx, sy, sz));
}
result = KMeans.Cluster(data, clustersCount, iterations, 0);
}
private void Calculate()
{
KMeans kMeans = new KMeans(Points, Clusters);
var finish = true;
while (finish)
{
var distance = kMeans.Cluster();
var clusters = kMeans.GetClusters();
Thread.Sleep(2000);
UpdateGraphData(clusters);
if (distance == 0)
{
finish = false;
}
}
MessageBox.Show(@"Done");
}
private static void clusterSC()
{
int s = 100, K = 100;
string[] templatefiles = Directory.GetFiles(@"D:\Play Data\my_template_data\sc\", "*.sc")
.Take(180).ToArray();
int templatecount = templatefiles.Length;
#region 读取模板
Debug("打开{0}个模板--------------------------------------------", templatecount);
double[][] templates = new double[templatecount * s][];
MyTimer timer = new MyTimer();
timer.Restart();
for (int i = 0; i < templatefiles.Length; ++i) {
string file = templatefiles[i];
string filename = Path.GetFileNameWithoutExtension(file);
using (var fs = new FileStream(file, FileMode.Open)) {
using (var br = new BinaryReader(fs)) {
for (int j = 0; j < s; ++j) {
templates[i * s + j] = new double[60];
for (int k = 0; k < 60; ++k) {
templates[i * s + j][k] = br.ReadDouble();
}
}
}
}
if (i % 100 == 0)
Debug("已完成{0}个", i);
}
Debug("模板读取完成，用时{0}ms.", timer.Stop());
#endregion
#region 聚类
timer.Restart();
KMeans<double[]> kmeans = new KMeans<double[]>(templates, K,
Jim.OCR.ShapeContext2D.ShapeContext.HistCost,
scs => {
double[] scnew = new double[60];
for (int k = 0; k < 60; ++k) {
scnew[k] = scs.Average(sc => sc[k]);
}
return scnew;
}
);
kmeans.MaxIterate = 100;
var cluster = kmeans.Cluster();
Debug("聚类完成，用时{0}ms.", timer.Stop());
#endregion
using (var fs = new FileStream(Path.Combine(@"D:\Play Data\my_template_data\sm-" + K, templatecount + ".sm"), FileMode.Create))
{
using (var bw = new BinaryWriter(fs)) {
for (int i = 0; i < K; ++i) {
for (int k = 0; k < 60; ++k) {
bw.Write(cluster[i].Center[k]);
}
}
}
}
}
void Update()
{
if (Input.GetKeyDown(KeyCode.F))
{
ServiceContainers.Explode(ForceScale);
return;
}
if (Input.GetKeyDown(KeyCode.C))
{
var itemsTmp = ServiceContainers.Select(c => c.transform.position).ToArray();
var resultTmp = KMeans.Cluster(itemsTmp, ClusterCount, Iterations, 0);
foreach (var cluster in resultTmp.clusters)
{
var force = Random.onUnitSphere * ForceScale;
cluster.Select(i => ServiceContainers[i]).AddForce(force);
}
return;
}
if (Input.GetKeyDown(KeyCode.A))
{
foreach (var spring in ServiceContainers.SelectMany(s => s.gameObject.GetComponents <SpringJoint>()))
{
spring.maxDistance = 3.0f;
spring.damper = 1.0f;
}
}
if (Input.GetKeyDown(KeyCode.Space))
{
if (running)
{
timeScaleBackup = Time.timeScale;
Time.timeScale = 0;
running = false;
}
else
{
Time.timeScale = timeScaleBackup;
running = true;
clusterized = false;
}
}
if (running || clusterized)
{
return;
}
var items = ServiceContainers.Select(c => c.transform.position).ToArray();
var result = KMeans.Cluster(items, ClusterCount, Iterations, 0);
for (var i = 0; i < result.clusters.Length; i++)
{
var color = Color.HSVToRGB(1f * i / result.clusters.Length, 1f, 1f);
for (var j = 0; j < result.clusters[i].Length; j++)
{
var index = result.clusters[i][j];
ServiceContainers[index].GetComponent <MeshRenderer>().material.color = color;
}
}
clusterized = true;
}
public List <Cluster> Cluster(List <InputData> dataToCluster, int numberOfClusters)
{
Dictionary <KohonenLayerNeuron, List <InputData> > neuronsInputData = new Dictionary <KohonenLayerNeuron, List <InputData> >();
foreach (var inputData in dataToCluster)
{
for (int i = 0; i < inputData.Inputs.Count; i++)
{
_layers[0].Neurons[i].InputSignals[0].Value = inputData.Inputs[i];
_layers[0].Neurons[i].FeedForward();
}
double minDistance = double.MaxValue;
int indexOfMinDistanceNeuron = 0;
for (int i = 0; i < _layers[1].Neurons.Count; i++)
{
double distanceToNeuron = _layers[1].Neurons[i].DistanceToWeightVector(inputData.Inputs);
if (distanceToNeuron < minDistance)
{
minDistance = distanceToNeuron;
indexOfMinDistanceNeuron = i;
}
}
KohonenLayerNeuron winner = _layers[1].Neurons[indexOfMinDistanceNeuron] as KohonenLayerNeuron;
if (!neuronsInputData.ContainsKey(winner))
{
neuronsInputData[winner] = new List <InputData>();
}
neuronsInputData[winner].Add(inputData);
}
var kMeansResult = KMeans.Cluster(neuronsInputData.Keys.Select(k => k.Position).ToArray(), numberOfClusters, 30,
delegate(double[] point, double[] centroid)
{
// calculating Euclidean distance
double res = 0;
for (int i = 0; i < point.Length; i++)
{
res += Math.Pow(point[i] - centroid[i], 2);
}
res = Math.Sqrt(res);
return(res);
});
var result = new List <Cluster>();
foreach (var positions in kMeansResult.Clusters)
{
var res = new List <InputDataResult>();
foreach (var position in positions)
{
KohonenLayerNeuron kohonenLayerNeuron =
neuronsInputData.Keys.FirstOrDefault(k => k.Position == position);
res.AddRange(neuronsInputData[kohonenLayerNeuron].Select(e => new InputDataResult(e, kohonenLayerNeuron)));
}
result.Add(new Cluster {
InputDataResults = res
});
}
return(result);
}
public void compute()
{
result = KMeans.Cluster(data, clustersCount, iterations, 0);
}
