static int[] Cluster(IEnumerable <int> integers, int bandwidth)
{
#if DEBUG
var stopwatch = new Stopwatch();
stopwatch.Start();
#endif
var kernel = new GaussianKernel(1);
var meanshift = new MeanShift(1, kernel, bandwidth);
meanshift.UseParallelProcessing = false;
var points = integers.Select(i => new[] { Convert.ToDouble(i) }).ToArray();
try
{
var labels = meanshift.Compute(points);
}
catch (Exception exception)
{
throw;
}
#if DEBUG
stopwatch.Stop();
Console.WriteLine($"Performed meanshift on {points.Length} points in {stopwatch.ElapsedMilliseconds}ms");
#endif
return(meanshift.Clusters.Modes.Select(m => Convert.ToInt32(m[0])).ToArray());
}
public void MeanShiftConstructorTest2()
{
Accord.Math.Tools.SetupGenerator(1);
// Declare some observations
double[][] observations =
{
new double[] { -5, -2, -4 },
new double[] { -5, -5, -6 },
new double[] { 2, 1, 1 },
new double[] { 1, 1, 2 },
new double[] { 1, 2, 2 },
new double[] { 3, 1, 2 },
new double[] { 11, 5, 4 },
new double[] { 15, 5, 6 },
new double[] { 10, 5, 6 },
};
double[][] orig = observations.MemberwiseClone();
// Create a uniform kernel density function
UniformKernel kernel = new UniformKernel();
// Create a new Mean-Shift algorithm for 3 dimensional samples
MeanShift meanShift = new MeanShift(dimension: 3, kernel: kernel, bandwidth: 2);
// Compute the algorithm, retrieving an integer array
// containing the labels for each of the observations
int[] labels = meanShift.Compute(observations);
// As a result, the first two observations should belong to the
// same cluster (thus having the same label). The same should
// happen to the next four observations and to the last three.
Assert.AreEqual(labels[0], labels[1]);
Assert.AreEqual(labels[2], labels[3]);
Assert.AreEqual(labels[2], labels[4]);
Assert.AreEqual(labels[2], labels[5]);
Assert.AreEqual(labels[6], labels[7]);
Assert.AreEqual(labels[6], labels[8]);
Assert.AreNotEqual(labels[0], labels[2]);
Assert.AreNotEqual(labels[2], labels[6]);
Assert.AreNotEqual(labels[0], labels[6]);
int[] labels2 = meanShift.Clusters.Decide(observations);
Assert.IsTrue(labels.IsEqual(labels2));
// the data must not have changed!
Assert.IsTrue(orig.IsEqual(observations));
Assert.AreEqual(3 / 9.0, meanShift.Clusters.Proportions[labels[6]], 1e-6);
Assert.AreEqual(2 / 9.0, meanShift.Clusters.Proportions[labels[0]], 1e-6);
Assert.AreEqual(4 / 9.0, meanShift.Clusters.Proportions[labels[2]], 1e-6);
}
public void YinYangMeanShiftTest()
{
Accord.Math.Random.Generator.Seed = 1;
double[][] inputs = yinyang.Submatrix(null, 0, 1).ToJagged();
int[] outputs = yinyang.GetColumn(2).ToInt32();
MeanShift ms = new MeanShift(2, new GaussianKernel(dimension: 2), 0.55);
int[] labels = ms.Compute(inputs);
}
public void MeanShiftConstructorTest()
{
Accord.Math.Tools.SetupGenerator(0);
// Test Samples
double[][] samples =
{
new double[] { 0, 1 },
new double[] { 1, 2 },
new double[] { 1, 1 },
new double[] { 0, 7 },
new double[] { 1, 1 },
new double[] { 6, 2 },
new double[] { 6, 5 },
new double[] { 5, 1 },
new double[] { 7, 1 },
new double[] { 5, 1 }
};
var kernel = new GaussianKernel(dimension: 2);
MeanShift meanShift = new MeanShift(2, kernel, 3);
// Compute the model (estimate)
int[] labels = meanShift.Compute(samples);
int a = 0;
int b = 1;
if (0.2358896594197982.IsRelativelyEqual(meanShift.Clusters.Modes[1][0], 1e-10))
{
a = 1;
b = 0;
}
for (int i = 0; i < 5; i++)
{
Assert.AreEqual(a, labels[i]);
}
for (int i = 5; i < samples.Length; i++)
{
Assert.AreEqual(b, labels[i]);
}
Assert.AreEqual(0.2358896594197982, meanShift.Clusters.Modes[a][0], 1e-10);
Assert.AreEqual(1.0010865560750339, meanShift.Clusters.Modes[a][1], 1e-10);
Assert.AreEqual(6.7284908155626031, meanShift.Clusters.Modes[b][0], 1e-10);
Assert.AreEqual(1.2713970467590967, meanShift.Clusters.Modes[b][1], 1e-10);
Assert.AreEqual(2, meanShift.Clusters.Count);
Assert.AreEqual(2, meanShift.Clusters.Modes.Length);
}
public void MeanShiftConstructorTest()
{
Accord.Math.Random.Generator.Seed = 0;
// Test Samples
double[][] samples =
{
new double[] { 0, 1 },
new double[] { 1, 2 },
new double[] { 1, 1 },
new double[] { 0, 7 },
new double[] { 1, 1 },
new double[] { 6, 2 },
new double[] { 6, 5 },
new double[] { 5, 1 },
new double[] { 7, 1 },
new double[] { 5, 1 }
};
var kernel = new GaussianKernel(dimension: 2);
MeanShift meanShift = new MeanShift(2, kernel, 2.0);
meanShift.UseParallelProcessing = false;
// Compute the model (estimate)
int[] labels = meanShift.Compute(samples);
int a = labels[0];
int b = (a == 0) ? 1 : 0;
for (int i = 0; i < 5; i++)
{
Assert.AreEqual(a, labels[i]);
}
for (int i = 5; i < samples.Length; i++)
{
Assert.AreEqual(b, labels[i]);
}
Assert.AreEqual(1.1922811512028066, meanShift.Clusters.Modes[a][0], 1e-3);
Assert.AreEqual(1.2567196159235963, meanShift.Clusters.Modes[a][1], 1e-3);
Assert.AreEqual(5.2696337859175868, meanShift.Clusters.Modes[b][0], 1e-3);
Assert.AreEqual(1.4380326532534968, meanShift.Clusters.Modes[b][1], 1e-3);
Assert.AreEqual(2, meanShift.Clusters.Count);
Assert.AreEqual(2, meanShift.Clusters.Modes.Length);
Assert.AreEqual(0.5, meanShift.Clusters.Proportions[0]);
Assert.AreEqual(0.5, meanShift.Clusters.Proportions[1]);
}
public override void Resolve(double[] weightedColors, int startIndex, int colorsAmount, byte componentsAmount, double k,
double[] resultColor, int resultIndex)
{
var els = componentsAmount + 1;
var offs = startIndex * els;
var colors = weightedColors
.Skip(offs)
.Take(colorsAmount * els)
.ToArray();
var observations = new double[colorsAmount][];
for (int colorIndex = 0; colorIndex < colorsAmount; colorIndex++)
{
var weightedColor = new double[els];
observations[colorIndex] = weightedColor;
for (int i = 0; i < els; i++)
{
weightedColor[i] = weightedColors[offs + colorIndex * els + i];
}
}
// Create a uniform kernel density function
UniformKernel kernel = new UniformKernel();
//calculate sigma
double sigma = CalculateSigma(colors, (byte)(componentsAmount + 1));
//calc bandwidth
double bandwidth = k * sigma;
// Create a new Mean-Shift algorithm for 4 dimensional samples
MeanShift meanShift = new MeanShift(kernel: kernel, bandwidth: bandwidth);
// Compute the algorithm, retrieving an integer array
// containing the labels for each of the observations
int[] labels = meanShift.Compute(observations);
var mostCommonColor = labels
.GroupBy(item => item)
.OrderByDescending(gg => gg.Count())
.Select(gg => gg.Key)
.First();
var labeledWeightedColors = labels
.Where(l => l == mostCommonColor)
.SelectMany((label, index) => observations[index])
.ToArray();
_colorResolver.Resolve(labeledWeightedColors, 0, labeledWeightedColors.Length / els, componentsAmount, k, resultColor, resultIndex);
}
private object calcMeanShift(IPixelBlock3 vPb, IPixelBlock3 pb3)
{
double[][] jaArr = pixelBlockToJaggedArray(vPb);
int bands = vPb.Planes;
UniformKernel kernel = new UniformKernel();
//GaussianKernel kernel = new GaussianKernel(bands);
MeanShift ms = new MeanShift(bands, kernel, radius);
int[] vls = ms.Compute(jaArr, 0.05, 10);
NumClusters = ms.Clusters.Count;
Console.WriteLine(NumClusters);
return(splitArray(vls, pb3));
}
public void MeanShiftConstructorTest()
{
Accord.Math.Tools.SetupGenerator(0);
// Test Samples
double[][] samples =
{
new double[] { 0, 1 },
new double[] { 1, 2 },
new double[] { 1, 1 },
new double[] { 0, 7 },
new double[] { 1, 1 },
new double[] { 6, 2 },
new double[] { 6, 5 },
new double[] { 5, 1 },
new double[] { 7, 1 },
new double[] { 5, 1 }
};
var kernel = new GaussianKernel(dimension: 2);
MeanShift meanShift = new MeanShift(2, kernel, 3);
// Compute the model (estimate)
int[] labels = meanShift.Compute(samples);
int a = 0;
int b = 1;
if (0.2358896594197982.IsRelativelyEqual(meanShift.Clusters.Modes[1][0], 1e-10))
{
a = 1;
b = 0;
}
for (int i = 0; i < 5; i++)
Assert.AreEqual(a, labels[i]);
for (int i = 5; i < samples.Length; i++)
Assert.AreEqual(b, labels[i]);
Assert.AreEqual(0.2358896594197982, meanShift.Clusters.Modes[a][0], 1e-10);
Assert.AreEqual(1.0010865560750339, meanShift.Clusters.Modes[a][1], 1e-10);
Assert.AreEqual(6.7284908155626031, meanShift.Clusters.Modes[b][0], 1e-10);
Assert.AreEqual(1.2713970467590967, meanShift.Clusters.Modes[b][1], 1e-10);
Assert.AreEqual(2, meanShift.Clusters.Count);
Assert.AreEqual(2, meanShift.Clusters.Modes.Length);
}
public void MeanShiftConstructorTest()
{
Accord.Math.Random.Generator.Seed = 0;
// Test Samples
double[][] samples =
{
new double[] { 0, 1 },
new double[] { 1, 2 },
new double[] { 1, 1 },
new double[] { 0, 7 },
new double[] { 1, 1 },
new double[] { 6, 2 },
new double[] { 6, 5 },
new double[] { 5, 1 },
new double[] { 7, 1 },
new double[] { 5, 1 }
};
var kernel = new GaussianKernel(dimension: 2);
MeanShift meanShift = new MeanShift(2, kernel, 2.0);
meanShift.UseParallelProcessing = false;
// Compute the model (estimate)
int[] labels = meanShift.Compute(samples);
int a = labels[0];
int b = (a == 0) ? 1 : 0;
for (int i = 0; i < 5; i++)
Assert.AreEqual(a, labels[i]);
for (int i = 5; i < samples.Length; i++)
Assert.AreEqual(b, labels[i]);
Assert.AreEqual(1.1922811512028066, meanShift.Clusters.Modes[a][0], 1e-3);
Assert.AreEqual(1.2567196159235963, meanShift.Clusters.Modes[a][1], 1e-3);
Assert.AreEqual(5.2696337859175868, meanShift.Clusters.Modes[b][0], 1e-3);
Assert.AreEqual(1.4380326532534968, meanShift.Clusters.Modes[b][1], 1e-3);
Assert.AreEqual(2, meanShift.Clusters.Count);
Assert.AreEqual(2, meanShift.Clusters.Modes.Length);
Assert.AreEqual(0.5, meanShift.Clusters.Proportions[0]);
Assert.AreEqual(0.5, meanShift.Clusters.Proportions[1]);
}
/// <summary>
/// Runs the Mean-Shift algorithm.
/// </summary>
///
private void runMeanShift()
{
int pixelSize = 3;
// Retrieve the kernel bandwidth
double sigma = (double)numBandwidth.Value;
// Load original image
Bitmap image = Properties.Resources.leaf;
// Create converters
ImageToArray imageToArray = new ImageToArray(min: -1, max: +1);
ArrayToImage arrayToImage = new ArrayToImage(image.Width, image.Height, min: -1, max: +1);
// Transform the image into an array of pixel values
double[][] pixels; imageToArray.Convert(image, out pixels);
// Create a MeanShift algorithm using the given bandwidth
// and a Gaussian density kernel as the kernel function:
IRadiallySymmetricKernel kernel = new GaussianKernel(pixelSize);
var meanShift = new MeanShift(pixelSize, kernel, sigma)
{
Tolerance = 0.05,
MaxIterations = 10
};
// Compute the mean-shift algorithm until the difference
// in shift vectors between two iterations is below 0.05
int[] idx = meanShift.Compute(pixels);
// Replace every pixel with its corresponding centroid
pixels.ApplyInPlace((x, i) => meanShift.Clusters.Modes[idx[i]]);
// Show resulting image in the picture box
Bitmap result; arrayToImage.Convert(pixels, out result);
pictureBox.Image = result;
}
public void WeightedMeanShiftConstructorTest2()
{
Accord.Math.Tools.SetupGenerator(1);
// Declare some observations
double[][] observations1 =
{
new double[] { -5, -2, -4 },
new double[] { -5, -5, -6 },
new double[] { 1, 1, 2 },
new double[] { 1, 1, 2 },
new double[] { 1, 1, 2 },
new double[] { 1, 1, 2 },
new double[] { 11, 5, 4 },
new double[] { 15, 5, 6 },
new double[] { 10, 5, 6 },
};
int[] weights1 = { 1, 1, 1, 1, 1, 1, 1, 1, 1 };
// Declare some observations
double[][] observations2 =
{
new double[] { -5, -2, -4 },
new double[] { -5, -5, -6 },
new double[] { 1, 1, 2 },
// new double[] { 1, 1, 2 },
// new double[] { 1, 1, 2 },
// new double[] { 1, 1, 2 },
new double[] { 11, 5, 4 },
new double[] { 15, 5, 6 },
new double[] { 10, 5, 6 },
};
int[] weights2 = { 1, 1, 4, 1, 1, 1 };
Accord.Math.Random.Generator.Seed = 1;
var ms1 = new MeanShift(dimension: 3, kernel: new UniformKernel(), bandwidth: 2);
ms1.UseParallelProcessing = false;
ms1.Compute(observations1);
Accord.Math.Random.Generator.Seed = 1;
var ms2 = new MeanShift(dimension: 3, kernel: new UniformKernel(), bandwidth: 2);
ms2.UseParallelProcessing = false;
ms2.Compute(observations1, weights1);
Accord.Math.Random.Generator.Seed = 1;
var ms3 = new MeanShift(dimension: 3, kernel: new UniformKernel(), bandwidth: 2);
ms3.UseParallelProcessing = false;
ms3.Compute(observations2, weights2);
int[] labels1 = ms1.Clusters.Decide(observations1);
int[] labels2 = ms2.Clusters.Decide(observations1);
int[] labels3 = ms3.Clusters.Decide(observations1);
Assert.IsTrue(Matrix.IsEqual(labels1, labels2));
Assert.IsTrue(Matrix.IsEqual(labels1, labels3));
Assert.IsTrue(Matrix.IsEqual(ms1.Clusters.Modes, ms2.Clusters.Modes, 1e-3));
Assert.IsTrue(Matrix.IsEqual(ms1.Clusters.Modes, ms3.Clusters.Modes, 1e-3));
Assert.IsTrue(Matrix.IsEqual(ms1.Clusters.Proportions, ms2.Clusters.Proportions));
Assert.IsTrue(Matrix.IsEqual(ms1.Clusters.Proportions, ms3.Clusters.Proportions));
Assert.AreEqual(3 / 9.0, ms3.Clusters.Proportions[labels1[6]], 1e-6);
Assert.AreEqual(2 / 9.0, ms3.Clusters.Proportions[labels1[0]], 1e-6);
Assert.AreEqual(4 / 9.0, ms3.Clusters.Proportions[labels1[2]], 1e-6);
}
public void WeightedMeanShiftConstructorTest()
{
MeanShift ms1, ms2, ms3;
Accord.Math.Tools.SetupGenerator(0);
double[][] samples1 =
{
new double[] { 0, 1 },
new double[] { 1, 2 },
new double[] { 1, 1 },
new double[] { 0, 1 },
new double[] { 1, 1 },
new double[] { 6, 2 },
new double[] { 6, 5 },
new double[] { 5, 1 },
new double[] { 7, 1 },
new double[] { 5, 1 }
};
int[] weights1 = Vector.Ones <int>(samples1.Length);
ms1 = new MeanShift(2, new GaussianKernel(dimension: 2), 2.0);
ms1.Compute(samples1);
Accord.Math.Tools.SetupGenerator(0);
double[][] samples2 =
{
new double[] { 0, 1 },
new double[] { 1, 2 },
new double[] { 1, 1 },
new double[] { 0, 1 },
new double[] { 6, 2 },
new double[] { 6, 5 },
new double[] { 5, 1 },
new double[] { 7, 1 },
};
int[] weights = { 1, 1, 2, 1, 1, 1, 2, 1 };
ms2 = new MeanShift(2, new GaussianKernel(dimension: 2), 2.0);
ms2.Compute(samples2, weights);
ms3 = new MeanShift(2, new GaussianKernel(dimension: 2), 2.0);
ms3.Compute(samples2);
int[] labels1 = ms1.Clusters.Decide(samples1);
int[] labels2 = ms2.Clusters.Decide(samples1);
int[] labels3 = ms3.Clusters.Decide(samples1);
Assert.IsTrue(Matrix.IsEqual(labels1, labels2));
Assert.IsTrue(Matrix.IsEqual(ms1.Clusters.Modes, ms2.Clusters.Modes, 1e-3));
Assert.IsFalse(Matrix.IsEqual(ms1.Clusters.Modes, ms3.Clusters.Modes, 1e-2));
Assert.IsFalse(Matrix.IsEqual(ms2.Clusters.Modes, ms3.Clusters.Modes, 1e-2));
Assert.IsTrue(Matrix.IsEqual(ms1.Clusters.Proportions, ms2.Clusters.Proportions));
Assert.IsTrue(Matrix.IsEqual(ms1.Clusters.Proportions, ms3.Clusters.Proportions));
Assert.AreEqual(0.5, ms1.Clusters.Proportions[0]);
Assert.AreEqual(0.5, ms1.Clusters.Proportions[1]);
}
/// <summary>
/// Runs the Mean-Shift algorithm.
/// </summary>
///
private void runMeanShift()
{
int pixelSize = 3;
// Retrieve the kernel bandwidth
double sigma = (double)numBandwidth.Value;
// Load original image
Bitmap image = Properties.Resources.leaf;
// Create converters
ImageToArray imageToArray = new ImageToArray(min: -1, max: +1);
ArrayToImage arrayToImage = new ArrayToImage(image.Width, image.Height, min: -1, max: +1);
// Transform the image into an array of pixel values
double[][] pixels; imageToArray.Convert(image, out pixels);
// Create a MeanShift algorithm using the given bandwidth
// and a Gaussian density kernel as the kernel function:
IRadiallySymmetricKernel kernel = new GaussianKernel(pixelSize);
var meanShift = new MeanShift(pixelSize, kernel, sigma)
{
Tolerance = 0.05,
MaxIterations = 10
};
// Compute the mean-shift algorithm until the difference
// in shift vectors between two iterations is below 0.05
int[] idx = meanShift.Compute(pixels);
// Replace every pixel with its corresponding centroid
pixels.ApplyInPlace((x, i) => meanShift.Clusters.Modes[idx[i]]);
// Show resulting image in the picture box
Bitmap result; arrayToImage.Convert(pixels, out result);
pictureBox.Image = result;
}
public void MeanShiftConstructorTest2()
{
Accord.Math.Tools.SetupGenerator(1);
// Declare some observations
double[][] observations =
{
new double[] { -5, -2, -1 },
new double[] { -5, -5, -6 },
new double[] { 2, 1, 1 },
new double[] { 1, 1, 2 },
new double[] { 1, 2, 2 },
new double[] { 3, 1, 2 },
new double[] { 11, 5, 4 },
new double[] { 15, 5, 6 },
new double[] { 10, 5, 6 },
};
double[][] orig = observations.MemberwiseClone();
// Create a uniform kernel density function
UniformKernel kernel = new UniformKernel();
// Create a new Mean-Shift algorithm for 3 dimensional samples
MeanShift meanShift = new MeanShift(dimension: 3, kernel: kernel, bandwidth: 1.5 );
// Compute the algorithm, retrieving an integer array
// containing the labels for each of the observations
int[] labels = meanShift.Compute(observations);
// As a result, the first two observations should belong to the
// same cluster (thus having the same label). The same should
// happen to the next four observations and to the last three.
Assert.AreEqual(labels[0], labels[1]);
Assert.AreEqual(labels[2], labels[3]);
Assert.AreEqual(labels[2], labels[4]);
Assert.AreEqual(labels[2], labels[5]);
Assert.AreEqual(labels[6], labels[7]);
Assert.AreEqual(labels[6], labels[8]);
Assert.AreNotEqual(labels[0], labels[2]);
Assert.AreNotEqual(labels[2], labels[6]);
Assert.AreNotEqual(labels[0], labels[6]);
int[] labels2 = meanShift.Clusters.Nearest(observations);
Assert.IsTrue(labels.IsEqual(labels2));
// the data must not have changed!
Assert.IsTrue(orig.IsEqual(observations));
}
private object calcMeanShift(IPixelBlock3 vPb,IPixelBlock3 pb3)
{
double[][] jaArr = pixelBlockToJaggedArray(vPb);
int bands = vPb.Planes;
UniformKernel kernel = new UniformKernel();
//GaussianKernel kernel = new GaussianKernel(bands);
MeanShift ms = new MeanShift(bands, kernel, radius);
int[] vls = ms.Compute(jaArr, 0.05, 10);
NumClusters = ms.Clusters.Count;
Console.WriteLine(NumClusters);
return splitArray(vls, pb3);
}
public void WeightedMeanShiftConstructorTest()
{
MeanShift ms1, ms2, ms3;
Accord.Math.Tools.SetupGenerator(0);
double[][] samples1 =
{
new double[] { 0, 1 },
new double[] { 1, 2 },
new double[] { 1, 1 },
new double[] { 0, 1 },
new double[] { 1, 1 },
new double[] { 6, 2 },
new double[] { 6, 5 },
new double[] { 5, 1 },
new double[] { 7, 1 },
new double[] { 5, 1 }
};
int[] weights1 = Vector.Ones<int>(samples1.Length);
ms1 = new MeanShift(2, new GaussianKernel(dimension: 2), 2.0);
ms1.Compute(samples1);
Accord.Math.Tools.SetupGenerator(0);
double[][] samples2 =
{
new double[] { 0, 1 },
new double[] { 1, 2 },
new double[] { 1, 1 },
new double[] { 0, 1 },
new double[] { 6, 2 },
new double[] { 6, 5 },
new double[] { 5, 1 },
new double[] { 7, 1 },
};
int[] weights = { 1, 1, 2, 1, 1, 1, 2, 1 };
ms2 = new MeanShift(2, new GaussianKernel(dimension: 2), 2.0);
ms2.Compute(samples2, weights);
ms3 = new MeanShift(2, new GaussianKernel(dimension: 2), 2.0);
ms3.Compute(samples2);
int[] labels1 = ms1.Clusters.Nearest(samples1);
int[] labels2 = ms2.Clusters.Nearest(samples1);
int[] labels3 = ms3.Clusters.Nearest(samples1);
Assert.IsTrue(Matrix.IsEqual(labels1, labels2));
Assert.IsTrue(Matrix.IsEqual(ms1.Clusters.Modes, ms2.Clusters.Modes, 1e-3));
Assert.IsFalse(Matrix.IsEqual(ms1.Clusters.Modes, ms3.Clusters.Modes, 1e-2));
Assert.IsFalse(Matrix.IsEqual(ms2.Clusters.Modes, ms3.Clusters.Modes, 1e-2));
Assert.IsTrue(Matrix.IsEqual(ms1.Clusters.Proportions, ms2.Clusters.Proportions));
Assert.IsTrue(Matrix.IsEqual(ms1.Clusters.Proportions, ms3.Clusters.Proportions));
Assert.AreEqual(0.5, ms1.Clusters.Proportions[0]);
Assert.AreEqual(0.5, ms1.Clusters.Proportions[1]);
}
public void Main()
{
List<string> abstracts = PullAbstracts(@"ExampleData\references.txt");
Stopwords sw = new Stopwords(@"ExampleData\Stopwords.txt");
StandardAnalyzer analyzer = new StandardAnalyzer(Net.Util.Version.LUCENE_30);
using (IndexWriter writer = new IndexWriter(FSDirectory.Open(@"ExampleData\Index"),
analyzer, IndexWriter.MaxFieldLength.LIMITED))
{
foreach (string ab in abstracts)
{
string trimmedAb = sw.TrimStopwords(ab);
if (trimmedAb.Contains("here "))
return;
Document document = new Document();
Field field = new Field("content", trimmedAb, Field.Store.YES, Field.Index.ANALYZED, Field.TermVector.WITH_POSITIONS_OFFSETS);
document.Add(field);
writer.AddDocument(document);
}
writer.Optimize();
}
List<Dictionary<string, int>> vectors = new List<Dictionary<string, int>>();
using (IndexReader reader = IndexReader.Open(FSDirectory.Open(@"ExampleData\Index"), true))
{
// get all terms.
TermEnum termsEnum = reader.Terms();
List<string> termStrings = new List<string>();
while (termsEnum.Next())
{
string term = termsEnum.Term.Text;
string processed = null;
if (!sw.IsStopWord(term, out processed))
{
termStrings.Add(processed);
}
}
// create vectors
for (int c = 0; c < reader.NumDocs(); c++)
{
Dictionary<string, int> vector = new Dictionary<string, int>();
foreach (string term in termStrings)
{
vector.Add(term, 0);
}
ITermFreqVector freqVector = reader.GetTermFreqVector(c, "content");
string[] terms = freqVector.GetTerms();
foreach (string term in terms)
{
int count = vector[term];
vector[term] = count + 1;
}
vectors.Add(vector);
}
}
double summation = 0.0;
string[] keys = vectors[0].Keys.ToArray();
for (int c = 0; c < keys.Length; c++)
{
double val = (vectors[10][keys[c]] - vectors[11][keys[c]]);
summation += val * val;
}
double distance = Math.Sqrt(summation);
double[][] arr = new double[vectors.Count][];
for(int c=0;c<vectors.Count;c++)
{
arr[c] = vectors[c].Values.Select(m=>(double)m).ToArray();
}
int dimension = vectors[0].Values.Count;
double sigma = 14.0;
MeanShift meanShiftClustering = new MeanShift(dimension, new GaussianKernel(dimension), sigma);
int[] indices = meanShiftClustering.Compute(arr, .05, 100);
MeanShiftClusterCollection clusters = meanShiftClustering.Clusters;
return;
}
public void YinYangMeanShiftTest()
{
Accord.Math.Random.Generator.Seed = 1;
double[][] inputs = yinyang.Submatrix(null, 0, 1).ToJagged();
int[] outputs = yinyang.GetColumn(2).ToInt32();
MeanShift ms = new MeanShift(2, new GaussianKernel(dimension: 2), 0.55);
int[] labels = ms.Compute(inputs);
}
public void WeightedMeanShiftConstructorTest2()
{
Accord.Math.Tools.SetupGenerator(1);
// Declare some observations
double[][] observations1 =
{
new double[] { -5, -2, -4 },
new double[] { -5, -5, -6 },
new double[] { 1, 1, 2 },
new double[] { 1, 1, 2 },
new double[] { 1, 1, 2 },
new double[] { 1, 1, 2 },
new double[] { 11, 5, 4 },
new double[] { 15, 5, 6 },
new double[] { 10, 5, 6 },
};
int[] weights1 = { 1, 1, 1, 1, 1, 1, 1, 1, 1 };
// Declare some observations
double[][] observations2 =
{
new double[] { -5, -2, -4 },
new double[] { -5, -5, -6 },
new double[] { 1, 1, 2 },
// new double[] { 1, 1, 2 },
// new double[] { 1, 1, 2 },
// new double[] { 1, 1, 2 },
new double[] { 11, 5, 4 },
new double[] { 15, 5, 6 },
new double[] { 10, 5, 6 },
};
int[] weights2 = { 1, 1, 4, 1, 1, 1 };
Accord.Math.Random.Generator.Seed = 1;
var ms1 = new MeanShift(dimension: 3, kernel: new UniformKernel(), bandwidth: 2);
ms1.UseParallelProcessing = false;
ms1.Compute(observations1);
Accord.Math.Random.Generator.Seed = 1;
var ms2 = new MeanShift(dimension: 3, kernel: new UniformKernel(), bandwidth: 2);
ms2.UseParallelProcessing = false;
ms2.Compute(observations1, weights1);
Accord.Math.Random.Generator.Seed = 1;
var ms3 = new MeanShift(dimension: 3, kernel: new UniformKernel(), bandwidth: 2);
ms3.UseParallelProcessing = false;
ms3.Compute(observations2, weights2);
int[] labels1 = ms1.Clusters.Nearest(observations1);
int[] labels2 = ms2.Clusters.Nearest(observations1);
int[] labels3 = ms3.Clusters.Nearest(observations1);
Assert.IsTrue(Matrix.IsEqual(labels1, labels2));
Assert.IsTrue(Matrix.IsEqual(labels1, labels3));
Assert.IsTrue(Matrix.IsEqual(ms1.Clusters.Modes, ms2.Clusters.Modes, 1e-3));
Assert.IsTrue(Matrix.IsEqual(ms1.Clusters.Modes, ms3.Clusters.Modes, 1e-3));
Assert.IsTrue(Matrix.IsEqual(ms1.Clusters.Proportions, ms2.Clusters.Proportions));
Assert.IsTrue(Matrix.IsEqual(ms1.Clusters.Proportions, ms3.Clusters.Proportions));
Assert.AreEqual(3 / 9.0, ms3.Clusters.Proportions[labels1[6]], 1e-6);
Assert.AreEqual(2 / 9.0, ms3.Clusters.Proportions[labels1[0]], 1e-6);
Assert.AreEqual(4 / 9.0, ms3.Clusters.Proportions[labels1[2]], 1e-6);
}
