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