public void Trivial() { var objs = new object[] { 'A', 'B', 'C', 'D', 'E', 'F', 'G' }; var c = objs.Length; var w = new int[c][]; var gr1 = new[] { 'A', 'B', 'C' }; var gr2 = new[] { 'D', 'E', 'F', 'G' }; for (int i = 0; i < c; i++) { w[i] = new int[c]; for (int j = 0; j < c; j++) { if (i == j) w[i][j] = 200; else if (gr1.Contains((char)objs[i]) && gr1.Contains((char)objs[j])) w[i][j] = 100; else if (gr2.Contains((char)objs[i]) && gr2.Contains((char)objs[j])) w[i][j] = 100; else w[i][j] = 0; } } var m = new Modularity(objs, w); Console.WriteLine("Start:" + m.CalcTotalModularity()); int iter = 1; while (m.Iterate(true)) Console.WriteLine("Iter[" + iter++ + "]:" + m.CalcTotalModularity() + ", nodes=" + m.NodesCount); Console.WriteLine("Result:" + m.CalcTotalModularity()); Console.WriteLine("fin"); Debug.Assert(m.NodesCount == 2); }
public void NegativeModularity() { var N = NetworkHelper.InitBarabasi(); var A = N.Actors; var C = A.Select(a => new Community(a)).ToList(); var M = Modularity.Compute(N, C); Assert.Equal(-0.12, Math.Round(M, 2)); }
public void SingleCommunity() { var N = NetworkHelper.InitBarabasi(); var A = N.Actors; var C = new List <Community> { new Community(A), }; var M = Modularity.Compute(N, C); Assert.Equal(0.0, M); }
public void SuboptimalParition() { var N = NetworkHelper.InitBarabasi(); var A = N.Actors; var C = new List <Community> { new Community(A[0], A[1], A[2]), new Community(A[3], A[4], A[5], A[6], A[7], A[8]) }; var M = Modularity.Compute(N, C); Assert.Equal(0.22, Math.Round(M, 2)); }
public void Zero() { for (var i = 0; i < 10; i++) { var network = new MNCD.Generators.CompleteGraphGenerator().Generate(2 + i); var communities = new List <Community> { new Community(network.Actors) }; var modularity = Modularity.Compute(network, communities); Assert.Equal(0.0, modularity); } }
/// <summary> /// Initializes a new instance of the AttributeSimilarityPanelViewModel class /// </summary> public AttributeSimilarityPanelViewModel(string _attributeName, Modularity.ToolPanel.ClusteringToolPanelItemExtensionViewModel _parent) { this.parent = _parent; this.previousValue = this.currentValue; this.attributeWeight = this.currentValue; AttributeName = _attributeName; UseExactSimilarity = true; SimilarityToolTip = Clustering.AttributeSimilarityManager.Instance.GetDefaultSimilarityMeasure(AttributeName).Name; // Wire up event handlers this.parent.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(parent_PropertyChanged); this.parent.ClusteringFinished += new EventHandler<ClusteringEventArgs>(parent_ClusteringFinished); // TODO: REMOVE HANDLER WHEN THIS CONTROL IS REMOVED FROM PARENT }
/// <summary> /// Computes communities hierarchy. /// </summary> /// <param name="inputNetwork">Input network.</param> /// <returns>Hierarchy of communities and it's modularities.</returns> public List <(double modularity, List <Community> communities)> GetHierarchy(Network inputNetwork) { if (inputNetwork.LayerCount > 1) { throw new ArgumentException("Louvain works only on single layered networks."); } var network = inputNetwork; List <Community> communities; Dictionary <Actor, Community> actorToCommunity; Dictionary <Actor, List <Actor> > actorToActors = null; var hierarchy = new List <(double modularity, List <Community> communities)>(); while (true) { (communities, actorToCommunity) = PhaseOne(network); var com = communities; if (actorToActors != null) { var original = new List <Community>(); foreach (var c in communities) { var actors = c.Actors.SelectMany(a => actorToActors[a]); original.Add(new Community(actors)); } com = original; } com = com.Where(c => c.Size > 0).ToList(); hierarchy.Add((Modularity.Compute(inputNetwork, com), com)); (network, actorToActors) = PhaseTwo(network, communities, actorToCommunity); var edges = network.FirstLayer.Edges; if (network.ActorCount == 1 || edges.Count == 0 || (edges.Count == 1 && edges.Any(e => e.From == e.To))) { break; } } return(hierarchy); }
public List<Cluster> Work3(int cut = 3, int seed = 1, bool setCoreWeights = false) { InitEdges(); Console.WriteLine("Запущена кластеризация второго типа для " + _nodes.Length + " узлов"); var sw = Stopwatch.StartNew(); var weights = new int[_nodes.Length][]; for (int i = 0; i < weights.Length; i++) { weights[i] = new int[_nodes.Length]; for (int j = 0; j < _nodes.Length; j++) weights[i][j] = i != j ? GetEdge(i, j).Weight - cut : (setCoreWeights ? _nodes[i].Count : 0);//_nodes[i].Chain.Length; } var m = new Modularity(_nodes, weights, seed); Console.WriteLine("Start with:" + m.CalcTotalModularity()); var iter = 1; while (m.Iterate()) Console.WriteLine("Iter[" + iter++ + "]:" + m.CalcTotalModularity()); Console.WriteLine("Result:" + m.CalcTotalModularity()); sw.Stop(); Console.WriteLine("Кластеризация завершена за " + sw.Elapsed); var clusterIds = m.ClasterIds; var ret = new List<Cluster>(); for (int i = 0; i < m.NodesCount; i++) { // переобозначим элементы каждого кластера int id = 0; var dic = new Dictionary<int, int>(); for (int j = 0; j < clusterIds.Length; j++) { if(clusterIds[j] != i) continue; dic.Add(id++,j); } var nodes = new ElementGroup[dic.Count]; var edges = new AlignmentResult[dic.Count][]; for (int j = 0; j < dic.Count; j++) { nodes[j] = _nodes[dic[j]]; edges[j] = new AlignmentResult[j]; for (int k = 0; k < j; k++) { edges[j][k] = _edges[dic[j]][dic[k]]; if (k == 0) { var tt = Alignment.Align(nodes[j].NucleoChain, nodes[k].NucleoChain, 0, 0); Debug.Assert(tt.Mask == edges[j][k].Mask); } } } ret.Add(new Cluster(ret.Count, nodes, edges)); } return ret; }
/// <summary> /// Phase one of louvain. /// </summary> /// <param name="network">Network.</param> /// <returns>list of communities and mapping of actor to community.</returns> internal (List <Community>, Dictionary <Actor, Community>) PhaseOne(Network network) { var actorToCommunity = network.Actors .ToDictionary(a => a, a => new Community(a)); var communities = actorToCommunity.Values.ToList(); var actorToNeighbours = network.FirstLayer.GetNeighboursDict(); // First Phase - Local Optimum var change = true; var iterations = 0; while (change && iterations < 1000) { iterations++; change = false; foreach (var actor in network.Actors) { if (!actorToNeighbours.ContainsKey(actor)) { continue; } var ac = actorToCommunity[actor]; var mc = Modularity.Compute(network, communities); var maxModularity = mc; var com = ac; foreach (var neighbour in actorToNeighbours[actor]) { var nc = actorToCommunity[neighbour]; if (ac == nc) { continue; } ac.Actors.Remove(actor); nc.Actors.Add(actor); var comms = communities.Where(c => c.Size > 0).ToList(); var nm = Modularity.Compute(network, comms); if (nm > maxModularity) { maxModularity = nm; com = nc; } ac.Actors.Add(actor); nc.Actors.Remove(actor); } if (maxModularity > mc) { change = true; ac.Actors.Remove(actor); com.Actors.Add(actor); actorToCommunity[actor] = com; } } } return(communities, actorToCommunity); }