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);
}
