public HashSet <Node> DFS(MultilayerNetwork multilayerNetwork, Node initialNode, Layer layer)
{
var visited = new HashSet <Node>();
//var nodes = multilayerNetwork.NodesByLayer[layer.Id];
//var initialNode = nodes.FirstOrDefault();
var stack = new Stack <Node>();
stack.Push(initialNode);
while (stack.Count > 0)
{
var node = stack.Pop();
if (visited.Contains(node))
{
continue;
}
visited.Add(node);
foreach (var neighbor in multilayerNetwork.NeighborsAll[node.Id])
{
if (!visited.Contains(neighbor))
{
stack.Push(neighbor);
}
}
}
return(visited);
}
public void CreateNewInstance_IsCorrectlyInitialised()
{
var parameters = new NetworkParameters(new int[] { 2, 8, 4 });
var network = new MultilayerNetwork(parameters);
Assert.That(network.Parameters, Is.SameAs(parameters));
Assert.That(network.LastLayer, Is.SameAs(network.Layers.Last()));
//Assert.That(network.Layers.Count(), Is.EqualTo(2));
network.ForEachLayer(l =>
{
l.ForEachNeuron((n, i) =>
{
n.Adjust((w, k) => w * 0.1);
return 0d;
});
return 1;
});
network.PruneInputs(1);
Assert.That(network.Parameters.InputVectorSize, Is.EqualTo(1));
}
public Walker(MultilayerNetwork multilayerNetwork, double jumpProbability, double[][] layerTransitions)
{
mathUtils = MathUtils.Instance;//new MathUtils();
mnet = multilayerNetwork;
jump = jumpProbability;
transitions = layerTransitions;
layerIds = new Dictionary <int, int>();
justJumped = true;
noAction = true;
var i = 0;
Layer flattened = mnet.GetLayer("flattenedNetwork");
var layers = new HashSet <Layer>(mnet.GetLayers().Except(new HashSet <Layer>()
{
flattened
}));
foreach (var layer in layers)
{
layerIds.Add(layer.Id, i);
i++;
}
}
public void Train_Multilayer_SaveThenLoad()
{
var network = new MultilayerNetwork(4, new[] { 4, 2 });
var bp = new BackPropagationLearning(network);
var input = ColumnVector1D.Create(0, 0.2, 0.66, 0.28);
var output = ColumnVector1D.Create(0, 0, 0, 0.999);
var err = bp.Train(input, output);
using (var ms = new MemoryStream())
{
network.Save(ms);
ms.Position = 0;
var network2 = MultilayerNetwork.LoadData(ms);
Assert.That(network2 != null);
var output2 = network2.Evaluate(ColumnVector1D.Create(0.1, 0.3, 0.2, 0.1));
Assert.That(output2 != null);
}
}
/// <summary>
/// Returns clustering coefficient of the given node.
/// </summary>
/// <param name="mnet">Multilayer network model.</param>
/// <param name="node">Node to calculate clustering coefficient on.</param>
/// <returns>Clustering coefficient of the given node.</returns>
public double ClusteringCoefficient(MultilayerNetwork mnet, Node node)
{
// Edges between neighbors.
// How well connected are they.
double edgesCount = 0;
// Get all neighbors of the node.
var neighbors = mnet.Neighbors(node, EdgeMode.InOut);
// Degree of the node.
var neighborsCount = neighbors.Count;
if (neighborsCount <= 1)
{
return(0);
}
// Go through all neighbors of our node.
// And check how well connected they are between each other.
foreach (var n1 in neighbors)
{
foreach (var n2 in neighbors)
{
if (n1 == n2)
{
continue;
}
if (mnet.GetEdge(n1, n2) != null)
{
edgesCount++;
}
}
}
return((edgesCount) / (neighborsCount * (neighborsCount - 1)));
}
// Old recursive implementation
#region Old
public List <List <Node> > GetConnectedComponents_(MultilayerNetwork multilayerNetwork, Layer layer)
{
var connectedComponents = new List <List <Node> >();
var visited = new Dictionary <int, bool>();
var nodes = multilayerNetwork.NodesByLayer[layer.Id];
foreach (var node in nodes)
{
visited.Add(node.Id, false);
}
var newComponent = new List <Node>();
for (int i = 0; i < visited.Count; i++)
{
var node = visited.ElementAt(i);
if (!node.Value)
{
DfsUtil(node.Key, visited, newComponent, nodes, multilayerNetwork);
connectedComponents.Add(newComponent);
newComponent = new List <Node>();
}
}
return(connectedComponents);
}
public BackPropagationLearning(MultilayerNetwork network, double momentum = 0.05)
{
network.Parameters.Validate();
Contract.Assert(momentum >= 0 && momentum <= 1);
_network = network;
_learningRate = network.Parameters.LearningRate;
_momentum = momentum;
}
/// <summary>
/// Returns exclusive neighborhood of given actor on given set of layers with specific edgemode.
/// </summary>
/// <param name="mnet">Multilayer network model.</param>
/// <param name="actor">Actor to get exclusive neighborhood of.</param>
/// <param name="layers">Layers to exclusive neighborhood on.</param>
/// <param name="edgeMode">In/Out/InOut edges.</param>
/// <returns>Exclusive neighborhood of given actor on given set of layers with specific edgemode.</returns>
public int ExclusiveNeighborhood(MultilayerNetwork mnet, Actor actor, HashSet <Layer> layers, EdgeMode edgeMode = EdgeMode.InOut)
{
// All layers except the layers in parameter.
var layerSupplement = new HashSet <Layer>(mnet.GetLayers().Except(layers));
var a = Neighbors(mnet, actor, layers, edgeMode);
var b = Neighbors(mnet, actor, layerSupplement, edgeMode);
var aMinusB = new HashSet <Actor>(a.Except(b));
return(aMinusB.Count);
}
// Do for each layer random walk for every pair of nodes on the layer.
// Average the value over all possible starting layers for the actor.
/// <summary>
/// Returns dictionary, where actors are keys and random walk betweenness centrality is their value.
/// </summary>
/// <param name="mnet">Multilayer network.</param>
/// <param name="jump">Jump probability for random walker, default value is 0.2.</param>
/// <param name="transitions">Matrix of transition probabilities between layers. Default is uniform for each pair of layers.</param>
/// <returns>Dictionary, where actors are keys and random walk betweenness centrality is their value.</returns>
public ConcurrentDictionary <Actor, int> RandomWalkBetweenness(MultilayerNetwork mnet, double jump = 0.2, double[][] transitions = null)
{
// If not set transitions, use uniform probability for every layer.
transitions = new double[mnet.Layers.Count][];
for (int i = 0; i < mnet.Layers.Count; i++)
{
transitions[i] = new double[mnet.Layers.Count];
for (int j = 0; j < transitions[i].Length; j++)
{
transitions[i][j] = 1.0 / transitions[i].Length;
}
}
var rw = new Walker(mnet, jump, transitions);
// Number of random walks passing through given actor.
var actorRandomWalkCount = new ConcurrentDictionary <Actor, int>();
//foreach (var a in mnet.GetActors())
Parallel.ForEach(mnet.GetActors(), (a) =>
{
actorRandomWalkCount.TryAdd(a, 0);
});
// Do random walk between every pair of nodes.
// Average it over the layers.
var nodes = mnet.GetNodes().ToArray();
for (int i = 0; i < nodes.Length - 1; i++)
{
//for (int j = i + 1; j < nodes.Length; j++)
Parallel.For(i + 1, nodes.Length, j =>
{
RandomWalkActors(rw, nodes[i], nodes[j], ref actorRandomWalkCount);
});
}
var temp = new ConcurrentDictionary <Actor, int>(actorRandomWalkCount);
// Average it - divide by number of nodes with the corresponding actor.
//foreach (var a in temp.Keys)
Parallel.ForEach(temp.Keys, (a) =>
{
if (mnet.NodesByActor.ContainsKey(a.Id))
{
var nodesCount = mnet.NodesByActor[a.Id].Count;
actorRandomWalkCount[a] = temp[a] / nodesCount;
}
});
return(actorRandomWalkCount);
}
/// <summary>
/// Utility method, for creating new layer in the multilayer network.
/// </summary>
/// <param name="mnet">Multilayer network.</param>
/// <param name="newLayerName">Name of the new layer.</param>
/// <param name="layers">Layers of the network.</param>
/// <param name="forceDirected">True if new edges should be directed, false if not.</param>
/// <param name="forceActors">True if all actors should be on the new layer, false if not.</param>
/// <returns>Newly created layer.</returns>
private Layer createLayer(MultilayerNetwork mnet, string newLayerName, HashSet <Layer> layers,
bool forceDirected, bool forceActors)
{
var directed = forceDirected;
// Check if there are any directed layers, if YES, then new layer will be directed as well.
if (!directed)
{
foreach (var layer1 in layers)
{
foreach (var layer2 in layers)
{
if (mnet.IsDirected(layer1, layer2))
{
directed = true;
break;
}
}
if (directed)
{
break;
}
}
}
var dir = directed ? EdgeDirectionality.Directed : EdgeDirectionality.Undirected;
var newLayer = mnet.AddLayer(newLayerName, dir);
if (newLayer == null)
{
throw new ArgumentException("Layer " + newLayerName + " already exists.");
}
if (forceActors)
{
foreach (var actor in mnet.GetActors())
{
mnet.AddNode(actor, newLayer);
}
}
else
{
foreach (var layer in layers)
{
foreach (var node in mnet.GetNodes(layer))
{
mnet.AddNode(node.Actor, newLayer);
}
}
}
return(newLayer);
}
/// <summary>
/// Returns means of degrees on the provided layers.
/// </summary>
/// <param name="mnet">Multilayer network model.</param>
/// <param name="actor">Actor.</param>
/// <param name="layers">HashSet of layers.</param>
/// <param name="edgeMode">In / Out / All, mode of edge.</param>
/// <returns>Mean of degrees.</returns>
public double DegreeMean(MultilayerNetwork mnet, Actor actor, HashSet <Layer> layers, EdgeMode edgeMode)
{
var degrees = new List <double>();
foreach (var layer in layers)
{
degrees.Add(Degree(mnet, actor, layer, edgeMode));
}
return(degrees.Average());
}
/// <summary>
/// Writes layer in csv format.
/// </summary>
/// <param name="mnet">Multilayer network.</param>
/// <param name="layer">Layer to write.</param>
/// <param name="path">Where to write the file.</param>
public void ToCsv(MultilayerNetwork mnet, Layer layer, string path)
{
var csv = new StringBuilder();
foreach (var edge in mnet.EdgesByLayerPair[layer.Id][layer.Id])
{
csv.AppendLine(edge.ToCsv());
}
File.WriteAllText(path, csv.ToString());
}
public int[] GetConnectedComponents(MultilayerNetwork multilayerNetwork, Layer layer)
{
var connectedComponents = new List <HashSet <Node> >();
var visited = new HashSet <Node>();
var nodes = multilayerNetwork.NodesByLayer[layer.Id];
var componentsCount = 0;
var largestComponent = 0;
foreach (var n in nodes)
{
if (!visited.Contains(n))
{
// DFS.
var newComponent = new HashSet <Node>();
var stack = new Stack <Node>();
stack.Push(n);
while (stack.Count > 0)
{
var node = stack.Pop();
if (newComponent.Contains(node))
{
continue;
}
newComponent.Add(node);
visited.Add(node);
foreach (var neighbor in multilayerNetwork.NeighborsAll[node.Id])
{
if (!newComponent.Contains(neighbor))
{
stack.Push(neighbor);
}
}
}
if (newComponent.Count > largestComponent)
{
largestComponent = newComponent.Count;
}
componentsCount++;
//connectedComponents.Add(newComponent);
newComponent = new HashSet <Node>();
}
}
return(new int[] { componentsCount, largestComponent });
}
/// <summary>
/// Returns average clustering coefficient on the given layer.
/// </summary>
/// <param name="mnet">Multilayer network model.</param>
/// <param name="layer">Layer to calculate average clustering coefficient on.</param>
/// <returns>Average clustering coefficient on the given layer.</returns>
public double AverageClusteringCoefficient(MultilayerNetwork mnet, Layer layer)
{
double sumCc = 0;
var nodes = mnet.NodesByLayer[layer.Id];
foreach (var n in nodes)
{
sumCc += ClusteringCoefficient(mnet, n);
}
return((1.0 / nodes.Count) * sumCc);
}
/// <summary>
/// Returns exclusive relevance of the actor on given set of layers with specific edgemode.
/// </summary>
/// <param name="mnet">Multilayer network model.</param>
/// <param name="actor">Actor to get exclusive relevance of.</param>
/// <param name="layers">Layers to calculate exclusive relevance on.</param>
/// <param name="edgeMode">In/Out/InOut edges.</param>
/// <returns>Exclusive relevance of the actor on given layer with specific edgemode.</returns>
public double ExclusiveRelevance(MultilayerNetwork mnet, Actor actor, HashSet <Layer> layers, EdgeMode edgeMode = EdgeMode.InOut)
{
double allLayers = NeighborhoodCentrality(mnet, actor, mnet.Layers, edgeMode);
double selectedLayers = ExclusiveNeighborhood(mnet, actor, layers, edgeMode);
if (allLayers == 0)
{
return(0);
}
return(selectedLayers / allLayers);
}
/// <summary>
/// Returns standard deviation of degrees on the provided layers.
/// </summary>
/// <param name="mnet">Multilayer network model.</param>
/// <param name="actor">Actor.</param>
/// <param name="layers">HashSet of layers.</param>
/// <param name="edgeMode">In / Out / All, mode of edge.</param>
/// <returns>Standard deviation of degrees.</returns>
public double DegreeDeviation(MultilayerNetwork mnet, Actor actor, HashSet <Layer> layers, EdgeMode edgeMode)
{
mathUtils = MathUtils.Instance; //new MathUtils();
var degrees = new List <double>();
foreach (var layer in layers)
{
degrees.Add(Degree(mnet, actor, layer, edgeMode));
}
return(mathUtils.Stdev(degrees));
}
public void Train_Multilayer_IsTrained()
{
var network = new MultilayerNetwork(4, new[] { 4, 2 });
var bp = new BackPropagationLearning(network);
var input = ColumnVector1D.Create(0, 0.2, 0.66, 0.28);
var output = ColumnVector1D.Create(0, 0, 0, 0.999);
var err = bp.Train(input, output);
Assert.That(err > 0);
}
public void InitialiseAndTrain_ReturnsErrorGt0(int layer1Size, int layer2Size)
{
var parameters = new NetworkParameters(new int[] { 4, layer1Size, layer2Size, 4 });
var network = new MultilayerNetwork(parameters);
var bp = new BackPropagationLearning(network);
var input = ColumnVector1D.Create(0, 0.2, 0.66, 0.28);
var output = ColumnVector1D.Create(0, 0, 0, 0.999);
var err = bp.Train(input, output);
Assert.That(err > 0);
}
/// <summary>
/// Returns exclusive relevance of the actor on given layer with specific edgemode.
/// </summary>
/// <param name="mnet">Multilayer network model.</param>
/// <param name="actor">Actor to get exclusive relevance of.</param>
/// <param name="layer">Layer to calculate exclusive relevance on.</param>
/// <param name="edgeMode">In/Out/InOut edges.</param>
/// <returns>Exclusive relevance of the actor on given layer with specific edgemode.</returns>
public double ExclusiveRelevance(MultilayerNetwork mnet, Actor actor, Layer layer, EdgeMode edgeMode = EdgeMode.InOut)
{
Layer flattened = mnet.GetLayer("flattened");
var test = new HashSet <Layer>(mnet.GetLayers().Except(new HashSet <Layer>()
{
flattened
}));
double allLayers = NeighborhoodCentrality(mnet, actor, new HashSet <Layer>(mnet.GetLayers().Except(new HashSet <Layer>()
{
flattened
})), edgeMode);
double selectedLayers = ExclusiveNeighborhood(mnet, actor, layer, edgeMode);
if (allLayers == 0)
{
return(0);
}
return(selectedLayers / allLayers);
}
private MathUtils mathUtils = MathUtils.Instance; //new MathUtils();
#region Degree
/// <summary>
/// Returns degree of the actor on provided layers.
/// </summary>
/// <param name="mnet">Multilayer network model.</param>
/// <param name="actor">Actor.</param>
/// <param name="layers">HashSet of layers.</param>
/// <param name="edgeMode">In / Out / All, mode of edge.</param>
/// <returns>Degree of the Actor.</returns>
public int Degree(MultilayerNetwork mnet, Actor actor, HashSet <Layer> layers, EdgeMode edgeMode)
{
var degree = 0;
// All nodes with this ACTOR.
foreach (var node in mnet.GetNodes(actor))
{
// All neighbors of this NODE, with the correct edgeMode (In / Out / Or both).
foreach (var neighbor in mnet.Neighbors(node, edgeMode))
{
// If there is a layer with this neighbor it means, that this NODE has this neighbor
// on this layer, so we increase his degree by 1.
if (layers.Contains(neighbor.Layer))
{
degree += 1;
}
}
}
return(degree);
}
/// <summary>
/// Returns degree on provided layer.
/// </summary>
/// <param name="mnet">Multlayer network model.</param>
/// <param name="actor">Actor.</param>
/// <param name="layer">Single Layer.</param>
/// <param name="edgeMode">In / Out / All, mode of edge.</param>
/// <returns>Degree of the Actor.</returns>
public int Degree(MultilayerNetwork mnet, Actor actor, Layer layer, EdgeMode edgeMode)
{
var degree = 0;
// All nodes with this ACTOR.
foreach (var node in mnet.GetNodes(actor))
{
// All neighbors of this NODE, with the correct edgeMode (In / Out / Or both).
foreach (var neighbor in mnet.Neighbors(node, edgeMode))
{
// We go through all his neighbors, and if the neighbor is on the provided layer
// we increase his degree by 1.
if (neighbor.Layer == layer)
{
degree += 1;
}
}
}
return(degree);
}
/// <summary>
/// Returns neighbors of given actor on given layer with specific edgemode.
/// </summary>
/// <param name="mnet">Multilayer network model.</param>
/// <param name="actor">Actor to get neighbors of.</param>
/// <param name="layer">Layer to get neighbors on.</param>
/// <param name="edgeMode">In/Out/InOut edges.</param>
/// <returns>Neighbors of given actor on given layer with specific edgemode.</returns>
private HashSet <Actor> Neighbors(MultilayerNetwork mnet, Actor actor, Layer layer, EdgeMode edgeMode = EdgeMode.InOut)
{
// Empty hashset to add checked actors.
var neighbors = new HashSet <Actor>();
// All nodes with this ACTOR.
foreach (var node in mnet.GetNodes(actor))
{
// All neighbors of this NODE, with the correct edgeMode (In / Out / Or both).
foreach (var neighbor in mnet.Neighbors(node, edgeMode))
{
// If there is a layer with this neighbor it means, that this NODE has this neighbor
// on this layer, so we increase his degree by 1 IF actor on this node is still available.
if (layer == neighbor.Layer)
{
neighbors.Add(neighbor.Actor);
}
}
}
return(neighbors);
}
// Possible to sort nodes.
// and in each loop go only through nodes with higher degree and higher id.
private double ClusteringCoefficient_TODO(MultilayerNetwork mnet, Layer layer)
{
// 3 x Number of triangles / number of connected triplets of vertices
// number of closed triplets / number of connected triplets of vertices
var triangleCount = 0;
double tripletsCount = 0;
var nodes = mnet.NodesByLayer[layer.Id];
// Count the triangles.
foreach (var v in nodes)
{
foreach (var u in nodes)
{
if (v == u || mnet.GetEdge(v, u) == null)
{
continue;
}
foreach (var w in nodes)
{
if (u == w || mnet.GetEdge(v, w) == null)
{
continue;
}
// Check for the final path.
if (mnet.GetEdge(u, w) != null)
{
triangleCount++;
}
}
}
}
var edgesCount = mnet.EdgesByLayerPair[layer.Id][layer.Id].Count;
return((3 * triangleCount) / tripletsCount);
}
public double GetAverageDistance(MultilayerNetwork mnet, Layer layer, Dictionary <int, int[][]> floydWarshallMatrixByLayerId)
{
var distanceMatrix = floydWarshallMatrixByLayerId[layer.Id];
var length = distanceMatrix.Length;
var total = 0.0;
var nodesCount = mnet.NodesByLayer[layer.Id].Count;
for (int i = 0; i < length; i++)
{
for (int j = i + 1; j < length; j++)
{
if (distanceMatrix[i][j] < unreachable)
{
total += distanceMatrix[i][j];
}
}
}
var result = (2d / (nodesCount * (nodesCount - 1))) * total;
return(result);
}
/// <summary>
/// Flatten layers into single layer.
/// </summary>
/// <param name="mnet">Multilayer network.</param>
/// <param name="newLayerName">Name of the new layer.</param>
/// <param name="layers">Layers to flatten.</param>
/// <param name="forceDirected">True if new edges should be directed, false if not.</param>
/// <param name="forceActors">True if all actors should be on the new layer, false if not.</param>
/// <returns>Flattened layer.</returns>
public Layer FlattenUnweighted(MultilayerNetwork mnet, string newLayerName, HashSet <Layer> layers,
bool forceDirected = false, bool forceActors = false)
{
var newLayer = createLayer(mnet, newLayerName, layers, forceDirected, forceActors);
var directed = mnet.IsDirected(newLayer, newLayer);
foreach (var layer1 in layers)
{
foreach (var layer2 in layers)
{
foreach (var edge in mnet.GetEdges(layer1, layer2))
{
var node1 = mnet.GetNode(edge.V1.Actor, newLayer);
var node2 = mnet.GetNode(edge.V2.Actor, newLayer);
var newEdge = mnet.GetEdge(node1, node2);
if (newEdge == null)
{
newEdge = mnet.AddEdge(node1, node2);
}
// If new layer is directed, undirected edges must be added twice in both directions.
if (directed && edge.Directionality == EdgeDirectionality.Undirected)
{
newEdge = mnet.GetEdge(node2, node1);
if (newEdge == null)
{
newEdge = mnet.AddEdge(node2, node1);
}
}
}
}
}
return(newLayer);
}
/// <summary>
/// Returns density of the layer in the network.
/// </summary>
/// <param name="mnet">Multilayer network model.</param>
/// <param name="layer">Layer to calculate density on.</param>
/// <returns>Density of the given layer.</returns>
public double Density(MultilayerNetwork mnet, Layer layer)
{
// Had to use long, because we will be calculating max. potential connections.
// And integer wasn't enough.
// Get all nodes on the layer.
long nodesCount = mnet.NodesByLayer[layer.Id].Count;
// Get all edges on the layer.
long edgesCount = 0;
// Check if there is this layer.
if (mnet.EdgesByLayerPair.ContainsKey(layer.Id) && mnet.EdgesByLayerPair[layer.Id].ContainsKey(layer.Id))
{
edgesCount = mnet.EdgesByLayerPair[layer.Id][layer.Id].Count;
}
long potentialConnections = 0;
if (mnet.IsDirected(layer, layer))
{
potentialConnections = nodesCount * (nodesCount - 1);
}
else
{
potentialConnections = (nodesCount * (nodesCount - 1)) / 2;
}
long actualConnections = edgesCount;
if (actualConnections == 0)
{
return(0);
}
return((double)actualConnections / potentialConnections);
}
public LayerDetailWindow(ConcurrentDictionary <int, ConcurrentDictionary <double, double>[]> layerDistributions, MultilayerNetwork multilayerNetwork)
{
InitializeComponent();
layerDetailViewModel = new LayerDetailViewModel(layerDistributions, multilayerNetwork);
DataContext = layerDetailViewModel;
BindControls();
}
private async Task<IRawClassifierTrainingContext<NetworkParameters>> GetOrCreateContext(DataBatch batch)
{
IRawClassifierTrainingContext<NetworkParameters> ctx;
//lock (_trainingContexts)
{
if (!_trainingContexts.TryGetValue(batch.Id, out ctx))
{
var name = batch.PropertyOrDefault("Name", batch.Id);
var layerSizes = batch.Properties["LayerSizes"].Split(',').Select(s => int.Parse(s)).ToArray();
var networkParams = new NetworkParameters(layerSizes);
try
{
var network = new MultilayerNetwork(networkParams);
await _blobStore.RestoreAsync(name, network);
_trainingContexts[batch.Id] = ctx = _trainingContextFactory.Create(network);
}
catch
{
_trainingContexts[batch.Id] = ctx = _trainingContextFactory.Create(networkParams);
}
}
}
return ctx;
}
/// <summary>
/// A handwriting recognition object.
/// </summary>
/// <param name="patternSize">The size of one input pattern.</param>
public Handwriting(int patternSize)
{
this.patternSize = patternSize;
mln = new MultilayerNetwork(10, patternSize, 26);
}
public async Task CreateClassifier_SavesOutput()
{
var bytes = BitConverter.GetBytes(0);
Assert.That(bytes.Length, Is.EqualTo(4));
var endpoint = new Uri("tcp://localhost:9212");
var data = Functions.NormalRandomDataset(3, 10).Select(x => new
{
x = x,
y = Math.Log(x)
}).AsQueryable();
using (var blobs = new InMemoryBlobStore())
using (var server = new RemoteClassifierTrainingServer(endpoint, blobs))
using (var client = new RemoteClassifierTrainingClient(endpoint))
{
#if DEBUGGING
client.Timeout = 20000;
#endif
server.Start();
var trainingSet = data.CreatePipeline().AsTrainingSet(x => x.x > 10 ? 'a' : 'b');
var keyAndclassifier = await client.CreateClassifier(trainingSet, true);
// We should be able to restore the raw blob back into a network
var nn = new MultilayerNetwork(new NetworkParameters(1, 1));
blobs.Restore(new string(keyAndclassifier.Key.PathAndQuery.Skip(1).ToArray()), nn);
// We should receive a valid classifier object back
var cls = keyAndclassifier.Value.Classify(new
{
x = 12.432,
y = Math.Log(12.432)
});
foreach (var c in cls)
{
Console.WriteLine(c);
}
Assert.That(cls.Any());
}
}
public void MeasuresTest()
{
Console.WriteLine("Measures test begin...");
var measures = new Measures.Measures();
var transform = new Transformation.Transformation();
//var filePath = @"../../../../Data/aucs.mpx";
//var networkName = "AUCS";
//var mnet = IO.ReadMultilayer(filePath, networkName);
//var f1 = transform.FlattenUnweighted(mnet, "Flattened", mnet.Layers, false, false);
//var edges = mnet.EdgesByLayerPair[f1.Id][f1.Id];
Console.WriteLine("Creating the network...");
var mnet = new MultilayerNetwork("Transformation Test");
var byactor = mnet.NodesByActor;
var a1 = mnet.AddActor("a1");
var a2 = mnet.AddActor("a2");
var a3 = mnet.AddActor("a3");
var a4 = mnet.AddActor("a4");
var a5 = mnet.AddActor("a5");
var a6 = mnet.AddActor("a6");
var i1 = mnet.AddActor("I1");
var i2 = mnet.AddActor("I2");
var i3 = mnet.AddActor("I3");
var L1 = mnet.AddLayer("People 1", EdgeDirectionality.Undirected);
var L2 = mnet.AddLayer("People 2", EdgeDirectionality.Undirected);
var people = new HashSet <Layer> {
L1, L2
};
var L3 = mnet.AddLayer("Institutions", EdgeDirectionality.Undirected);
var a1l1 = mnet.AddNode(a1, L1);
var a2l1 = mnet.AddNode(a2, L1);
var a3l1 = mnet.AddNode(a3, L1);
var a4l1 = mnet.AddNode(a4, L1);
var a5l1 = mnet.AddNode(a5, L1);
var a1l2 = mnet.AddNode(a1, L2);
var a2l2 = mnet.AddNode(a2, L2);
var a3l2 = mnet.AddNode(a3, L2);
var a4l2 = mnet.AddNode(a4, L2);
var a5l2 = mnet.AddNode(a5, L2);
var i1l3 = mnet.AddNode(i1, L3);
var i2l3 = mnet.AddNode(i2, L3);
var i3l3 = mnet.AddNode(i3, L3);
mnet.AddEdge(a1l1, a2l1);
mnet.AddEdge(a1l1, a3l1);
mnet.AddEdge(a1l2, a2l2);
mnet.AddEdge(a3l2, a4l2);
mnet.AddEdge(a1l2, i1l3);
mnet.AddEdge(a2l2, i1l3);
mnet.AddEdge(a2l2, i2l3);
mnet.AddEdge(a3l2, i2l3);
mnet.AddEdge(a4l2, i2l3);
mnet.AddEdge(a5l2, i3l3);
Console.WriteLine("Creating network end.");
Console.WriteLine("Adjaceny matrices test start...");
var adj = mnet.ToAdjacencyMatrix();
Console.WriteLine("Adjancency matrices test end.");
//foreach (var layer in mnet.Layers)
//{
// var nodes = mnet.NodesByLayer[layer.Id];
// //Console.WriteLine("{0}\t{1}\t{2}\t{3}\t", layer.Name, nodes.Count, measures.Density(mnet, layer), measures.AverageClusteringCoefficient(mnet, layer));
// Console.WriteLine("{0}\t{1}\t{2}\t{3}\t", layer.Name, nodes.Count, measures., measures.AverageClusteringCoefficient(mnet, layer));
//}
//var actor = mnet.GetActor("a1");
//var nodes = mnet.GetNodes(actor);
//Console.WriteLine("Actor: {0}\t Degree: {1},\t Neighborhood: {2},\t Connective Redundancy: {3},\t Exclusive Neighborhood: {4}", actor.Name,measures.Degree(mnet, actor, mnet.GetLayers(), EdgeMode.InOut),
// measures.NeighborhoodCentrality(mnet, actor, mnet.GetLayers(), EdgeMode.InOut),
// measures.ConnectiveRedundancy(mnet, actor, mnet.GetLayers(), EdgeMode.InOut),
// measures.ExclusiveNeighborhood(mnet, actor, mnet.GetLayers(), EdgeMode.InOut));
Console.WriteLine("Done! " + mnet.ToString());
Console.WriteLine("Measures test end.");
}
public double ClosenessCentrality(Actor actor, Layer layer, Dictionary <int, int[][]> floydWarshallMatrixByLayerId, MultilayerNetwork mnet)
{
var distanceMatrix = floydWarshallMatrixByLayerId[layer.Id];
var sumDist = 0.0;
for (int i = 0; i < distanceMatrix.Length; i++)
{
if (distanceMatrix[actor.Id][i] < 9999)
{
sumDist += distanceMatrix[actor.Id][i];
}
}
long n = mnet.NodesByLayer[layer.Id].Count;
return(1.0 / ((1.0 / (n - 1)) * sumDist));
}
/// <summary>
/// Returns dictionary, where actors are keys and their random walk closeness centrality is value.
/// </summary>
/// <param name="mnet">Multilayer network.</param>
/// <param name="jump">Jump probability, default value is 0.2.</param>
/// <param name="transitions">Matrix of transition probabilities between layers. Default is uniform for each pair of layers.</param>
/// <returns>Dictionary, where actors are keys and their random walk closeness centrality is value.</returns>
public ConcurrentDictionary <Actor, double> RandomWalkCloseness(MultilayerNetwork mnet, double jump = 0.2, double[][] transitions = null)
{
// If not set transitions, use uniform probability for every layer.
transitions = new double[mnet.Layers.Count][];
for (int i = 0; i < mnet.Layers.Count; i++)
{
transitions[i] = new double[mnet.Layers.Count];
for (int j = 0; j < transitions[i].Length; j++)
{
transitions[i][j] = 1.0 / transitions[i].Length;
}
}
var rw = new Walker(mnet, jump, transitions);
// Create adjacency matrix for actors.
// Every actor has its Id.
// First Id starts at 0.
// Last Id is actors count - 1.
var adjActors = new int[mnet.GetActors().Count][];
for (int i = 0; i < mnet.Actors.Count; i++)
{
adjActors[i] = new int[mnet.Actors.Count];
}
// Traverse the matrix for every pair of nodes.
var nodes = mnet.GetNodes().ToArray();
for (int i = 0; i < nodes.Length - 1; i++)
{
//for (int j = i + 1; j < nodes.Length; j++)
Parallel.For(i + 1, nodes.Length, (j) =>
{
//Console.WriteLine(i + ":" + j);
// Do random walk from i to j.
// And save only the first walk length.
var walkLen = RandomWalkSteps(rw, nodes[i], nodes[j]);
// Use only first walk.
if (adjActors[nodes[i].Actor.Id][nodes[j].Actor.Id] == 0)
{
adjActors[nodes[i].Actor.Id][nodes[j].Actor.Id] = walkLen;
adjActors[nodes[j].Actor.Id][nodes[i].Actor.Id] = walkLen;
}
});
}
var actorById = new ConcurrentDictionary <int, Actor>();
//foreach (var actor in mnet.GetActors())
Parallel.ForEach(mnet.GetActors(), (a) =>
{
actorById.TryAdd(a.Id, a);
});
// Actual Clonesess centrality.
// Harmonic mean distance.
var closenessByActor = new ConcurrentDictionary <Actor, double>();
for (int i = 0; i < adjActors[0].Length; i++)
{
double sum = 0;
//for (int j = 0; j < adjActors[0].Length; j++)
Parallel.For(0, adjActors[0].Length, (j) =>
{
if (i == j)
{
adjActors[i][j] = 0;
}
else
{
if (adjActors[i][j] != 0)
{
sum += 1.0 / adjActors[i][j];
}
}
});
double closeness = (1.0 / (adjActors[0].Length - 1)) * sum;
closenessByActor[actorById[i]] = closeness;
}
return(closenessByActor);
}
public void DfsUtil(int nodeId, Dictionary <int, bool> visited, List <Node> component, HashSet <Node> nodes, MultilayerNetwork multilayerNetwork)
{
visited[nodeId] = true;
var theNode = nodes.First(n => n.Id == nodeId);
component.Add(theNode);
foreach (var neighbors in multilayerNetwork.NeighborsAll[theNode.Id])
{
var node = visited.First(x => x.Key == neighbors.Id);
if (!node.Value)
{
DfsUtil(node.Key, visited, component, nodes, multilayerNetwork);
}
}
}
/// <summary>
/// Returns dictionary, where actors are keys and their occupation centrality is value.
/// </summary>
/// <param name="mnet">Multilayer network.</param>
/// <param name="jump">Jump probability for random walker, default value is 0.2.</param>
/// <param name="transitions">Matrix of transition probabilities between layers. Default is uniform for each pair of layers.</param>
/// <param name="numSteps">Maximum number of steps, if not specified it is number of edges times 100.</param>
/// <param name="initialNode">Starting node for the random walker.</param>
/// <returns>Dictionary, where actors are keys and their occupation centrality is value.</returns>
public Dictionary <Actor, int> Occupation(MultilayerNetwork mnet, double jump = 0.2, double[][] transitions = null, int numSteps = 0, Node initialNode = null)
{
// If not set number of steps, set default number of steps to 100 times number of edges.
// This was used in the R library.
if (numSteps == 0)
{
numSteps = mnet.Edges.Count * 100;
}
// If not set transitions, use uniform probability for every layer.
transitions = new double[mnet.Layers.Count][];
for (int i = 0; i < mnet.Layers.Count; i++)
{
transitions[i] = new double[mnet.Layers.Count];
for (int j = 0; j < transitions[i].Length; j++)
{
transitions[i][j] = 1.0 / transitions[i].Length;
}
}
var rw = new Walker(mnet, jump, transitions);
if (initialNode == null)
{
rw.SetInitialNode(mnet.GetNodes().FirstOrDefault());
}
else
{
rw.SetInitialNode(initialNode);
}
var occupation = new Dictionary <Actor, int>();
var node = rw.Now();
var flag = true;
while (numSteps-- > 0)
{
if (flag)
{
// Initial node.
flag = false;
}
else
{
node = rw.Next();
}
if (!rw.Action())
{
continue;
}
if (rw.Jumped())
{
// Jumped to a new node - not counting.
}
else
{
// If actor is not present yet.
if (!occupation.ContainsKey(node.Actor))
{
occupation.Add(node.Actor, 0);
}
// Then increase his occupancy.
occupation[node.Actor]++;
}
}
return(occupation);
}
public void Save_And_Load()
{
var parameters = new NetworkParameters(new int[] { 2, 8, 4 })
{
LearningRate = 0.123
};
var network = new MultilayerNetwork(parameters);
{
int li = 0;
network.ForEachLayer(l =>
{
li += 10;
l.ForEachNeuron((n, i) =>
{
n.Adjust((w, wi) => wi * li);
return 0;
}).ToList();
return 0;
}).ToList();
}
byte[] serialisedData;
using (var blobStore = new MemoryStream())
{
network.Save(blobStore);
blobStore.Flush();
serialisedData = blobStore.ToArray();
}
using (var blobStoreRead = new MemoryStream(serialisedData))
{
var network2 = MultilayerNetwork.LoadData(blobStoreRead);
Assert.That(network2.Parameters.LearningRate, Is.EqualTo(0.123));
Assert.That(network2.Parameters.InputVectorSize, Is.EqualTo(2));
Assert.That(network2.Parameters.OutputVectorSize, Is.EqualTo(4));
Assert.That(network2.Layers.Count(), Is.EqualTo(3));
int li = 0;
network2.ForEachLayer(l =>
{
li += 10;
l.ForEachNeuron((n, i) =>
{
n.Adjust((w, wi) =>
{
Assert.That(w == wi * li);
return w;
});
return 0;
}).ToList();
return 0;
}).ToList();
}
}
/// <summary>
/// Returns neighborhood centrality of given actor on given layer with specific edgemode.
/// </summary>
/// <param name="mnet">Multilayer network model.</param>
/// <param name="actor">Actor to get neighborhood of.</param>
/// <param name="layer">Layer to get neighborhood on.</param>
/// <param name="edgeMode">In/Out/InOut edges.</param>
/// <returns>Neighborhood centrality of given actor on given layer with specific edgemode.</returns>
public int NeighborhoodCentrality(MultilayerNetwork mnet, Actor actor, Layer layer, EdgeMode edgeMode = EdgeMode.InOut)
{
return(Neighbors(mnet, actor, layer, edgeMode).Count);
}
/// <summary>
/// Returns connective redundancy of given actor on given set of layers with specific edgemode.
/// </summary>
/// <param name="mnet">Multilayer network model.</param>
/// <param name="actor">Actor to get connective redundancy of.</param>
/// <param name="layers">Layers to get connective redundancy on.</param>
/// <param name="edgeMode">In/Out/InOut edges.</param>
/// <returns>Connective redundancy of given actor on given set of layers with specific edgemode.</returns>
public double ConnectiveRedundancy(MultilayerNetwork mnet, Actor actor, HashSet <Layer> layers, EdgeMode edgeMode = EdgeMode.InOut)
{
return(1 - Math.Max((NeighborhoodCentrality(mnet, actor, layers, edgeMode) / Degree(mnet, actor, layers, edgeMode)), 0));
}
