private void button1_Click(object sender, EventArgs e)
{
TextReader reader = new TextReader();
List <string> fileNames;
var textContents = reader.GetFiles(out fileNames);
HierarchicalClustering clustering = new HierarchicalClustering(textContents);
int numberOfClusters = textBox1.Text != "" ? Convert.ToInt32(textBox1.Text) : 2;
var clusters = clustering.ComputeClusters(numberOfClusters);
listViewResults.Items.Clear();
int index = 1;
foreach (var cluster in clusters)
{
listViewResults.Items.Add("Cluster " + index);
foreach (var item in cluster.Value)
{
listViewResults.Items.Add(fileNames[item - 1]);
}
listViewResults.Items.Add("");
index++;
}
}
public void ClusterWithOneBlogsGivesOneCluster()
{
// Arrange
var blogs = new List <Blog>
{
new Blog
{
Name = "Blog1",
Words = new Dictionary <string, double>
{
{ "word1", 5 },
{ "word2", 0 },
{ "word3", 5 },
},
},
};
var sut = new HierarchicalClustering(new PearsonCorrelationSimilarityAlgorithm(), false);
// Act
var result = sut.Cluster(blogs);
// Assert
Assert.Equal("Blog1", result.Blog.Name);
Assert.Null(result.Left);
Assert.Null(result.Right);
}
public ActionResult <Cluster> Get(bool useCache)
{
var blogs = blogDataRepository.GetBlogData();
var pearson = new PearsonCorrelationSimilarityAlgorithm();
var hierarchicalClustering = new HierarchicalClustering(pearson, useCache);
return(hierarchicalClustering.Cluster(blogs));
}
public void Test()
{
var releaseInfos = GetTestData(@"TestData\standard.json");
var clusterAnalyser = new HierarchicalClustering <SizeInfo>((x, y) => Math.Abs(x.Size - y.Size),
Math.Max);
var clusters = clusterAnalyser.Cluster(releaseInfos);
var instances = clusters.GetClusteredInstances(d => d > 200 * 1024 * 1024).OrderByDescending(c => c.Count).ToArray();
}
public IEnumerator <Clustering <TElement> > GetEnumerator()
{
var hca = new HierarchicalClustering <TElement>(_distanceFunction, _linkageFunction);
var results = hca.Cluster(_source);
var clusters = results.GetClusteredInstances(_clusterDistanceCutPoint);
return(clusters
.Select(cluster => new Clustering <TElement>(cluster, _clusterValueFunc))
.GetEnumerator());
}
public void TestClustering()
{
var hclust = new HierarchicalClustering();
var vals = TestUtils.ReadMatrix("Examples/clustering_array_copy_error.txt.gz");
var data = new FloatMatrixIndexer(vals);
var distance = new EuclideanDistance();
hclust.TreeClusterKmeans(data, MatrixAccess.Columns, distance, HierarchicalClusterLinkage.Average, false,
false, 1, 300, 1, 10,
(i) => { });
}
public void TestKmeansClusteringPreculusteringWithManyDuplicateRows()
{
HierarchicalClustering hclust = new HierarchicalClustering();
var values = new float[, ] {
{ 1, 2, 3, 1 }, { 2, 3, 4, 2 }, { 2, 3, 4, 2 }, { 2, 3, 4, 2 }, { 2, 3, 4, 2 }, { 3, 4, 5, 2 }
};
FloatMatrixIndexer data = new FloatMatrixIndexer(values);
var clusterNodes = hclust.TreeClusterKmeans(data, MatrixAccess.Rows, new EuclideanDistance(), HierarchicalClusterLinkage.Average, false, false, 1,
5, 1, 1000, i => { });
Assert.AreEqual(5, clusterNodes.Length);
}
public void TestKmeansClusteringPreculusteringWithDuplicateRows(
[ValueSource(nameof(_data))] float[,] values,
[ValueSource(nameof(_linkages))] HierarchicalClusterLinkage linkage,
[ValueSource(nameof(_distances))] IDistance distance)
{
HierarchicalClustering hclust = new HierarchicalClustering();
FloatMatrixIndexer data = new FloatMatrixIndexer(values);
var clusterNodes = hclust.TreeClusterKmeans(data, MatrixAccess.Columns, distance, linkage, false, false, 1,
2, 1, 1000, i => { });
Assert.AreEqual(3, clusterNodes.Length);
}
public void ClusterWithZeroBlogsGivesZeroClusters()
{
// Arrange
var sut = new HierarchicalClustering(new PearsonCorrelationSimilarityAlgorithm(), false);
// Act
var result = sut.Cluster(new List <Blog>());
// Assert
Assert.Null(result);
}
public IActionResult Index()
{
var sessions = JArray.Parse(System.IO.File.ReadAllText(@"D:\User\Desktop\response_1589728162482.json"));
var results = ParserManager.ParseTestResults(sessions);
HierarchicalClustering.ComputeMultiple(0.5f, results.Clusters);
Log.Information("Tests count: {tcount}, clusters count {ccount}, cluster depth: {depth}",
results.Clusters.Count, HierarchicalClustering.Output.Count, HierarchicalClustering.Output.Max(c => c.Depth));
ViewBag.Width = HierarchicalClustering.Output.Max(c => c.Depth) * 150 + 460;
ViewBag.Height = results.Clusters.Count * 30;
ViewBag.Cluster = ClusterSerializer.Serialize(HierarchicalClustering.Output);
return(View());
}
public void Clusters(List <TestClusterCandidate> candidates, double cutPoint,
Func <double, double, double> linkageFunction, Func <TestClusterCandidate, TestClusterCandidate, double> distanceFunction,
ISet <ISet <TestClusterCandidate> > expectedClusterResults)
{
var subject = new HierarchicalClustering <TestClusterCandidate>(distanceFunction, linkageFunction);
var results = subject.Cluster(candidates);
var clustered = results.GetClusteredInstances(d => d > cutPoint);
clustered.Count.ShouldBe(expectedClusterResults.Count);
var count = expectedClusterResults
.Sum(expectedClusterResult => clustered.Count(cluster => cluster.SetEquals(expectedClusterResult)));
count.ShouldBe(expectedClusterResults.Count);
}
public void TestClusterNodeFormat()
{
var hclust = new HierarchicalClustering();
var data = new FloatMatrixIndexer(new float[, ] {
{ 1, 2, 3 }, { 2, 3, 4 }
});
var distance = new EuclideanDistance();
var rowTree = hclust.TreeCluster(data, MatrixAccess.Rows, distance, HierarchicalClusterLinkage.Maximum, false,
false, 1, i => { });
var rowTreeR = HierarchicalClusterNode.FromRFormat(new[] { -1 }, new[] { -2 }, new[] { 1.732051 });
Assert.AreEqual(rowTreeR[0], rowTree[0]);
var colTree = hclust.TreeCluster(data, MatrixAccess.Columns, distance, HierarchicalClusterLinkage.Maximum, false,
false, 1, i => { });
var colTreeR = HierarchicalClusterNode.FromRFormat(new[] { -1, -3 }, new[] { -2, 1 }, new[] { 1.414214, 2.828428 });
CollectionAssert.AreEqual(colTree, colTreeR);
}
public void ShouldClusterValueTypes()
{
var source = new List <int> {
101, 204, 203, 105, 103
};
var expectedSets = new HashSet <HashSet <int> > {
new HashSet <int> {
204, 105
}, new HashSet <int> {
101, 203, 103
}
};
double DistanceValueSelector(int c) => c % 100;
double DistanceFunction(int a, int b) => Math.Abs(DistanceValueSelector(a) - DistanceValueSelector(b));
var subject = new HierarchicalClustering <int>(DistanceFunction, TestClusterCandidate.CompleteLinkage);
var results = subject.Cluster(source);
var clusters = results.GetClusteredInstances(2);
clusters.Count.ShouldBe(2);
clusters.ShouldBe(expectedSets);
}
public HierarchicalClusteringTests()
{
_subject = new HierarchicalClustering <TestClusterCandidate>(TestClusterCandidate.DistanceFunction, Math.Max);
}
