NOESIS vs. NetworkX

NETWORK STATISTICS

- Nodes: 27475

- Links: 85729

Degree distributions

- Out-degrees: [n=27475 min=0.0 max=565.0 avg=3.1202547770700635 dev=9.038219683086334]

- In-degrees:  [n=27475 min=0.0 max=367.0 avg=3.1202547770700635 dev=8.99990229087909]

Node of maximum out-degree: 565.0 out-links

- id: 8436

- wikiid: 1807178

- label: List of mathematics articles (S)

Node of maximum in-degree: 367.0 in-links

- id: 10807

- wikiid: 7250299

- label: Geometry

Betweenness

[n=27475 min=2.0 max=2.1696583120297905E7 avg=79690.76047315744 dev=404883.40160651755]

Node of maximum betweenness: 2.1696583120297905E7

- id: 12533

- wikiid: 5176

- label: Calculus

# see http://networkx.lanl.gov/ for a tutorial on NetworkX

import networkx as nx

import sys

from plfit import *

# Installation: pyparsing @ http://sourceforge.net/projects/pyparsing/files/pyparsing/pyparsing-1.5.6/pyparsing-1.5.6.win32-py2.7.exe/download

# your GML file

filename = 'wikipedia.gml'

# read in the graph using networkX

G = nx.read_gml(filename,relabel=True)

# Graph size

num_nodes = G.number_of_nodes()

print 'number of nodes: ' + str(num_nodes)

num_edges = G.number_of_edges()

print 'number of edges: ' + str(num_edges)

sys.stdout.flush()

# Degree distribution

degrees = list(G.degree().values())

dmax = max(degrees)

dmin = min(degrees)

print 'Degree distribution: [' + str(dmin) + ',' + str(dmax) + ']'

sys.stdout.flush()

# Power-law

# fit the power-law distribution. If $D < 0.05, the Kolmogorov Smirnov test tells 

# us that the distribution is power-law.

# Also, look for the estimated power-law exponent $alpha and $xmin (the point at 

# which you should start fitting the distribution)

# make sure you have executed all the code in plfit.R before running this function

# an explanation is here: http://tuvalu.santafe.edu/~aaronc/powerlaws/

# you can download the file directly here: http://tuvalu.santafe.edu/~aaronc/powerlaws/plfit.r

# You will also need the VGAM R package which you can download via the installer

[alpha, xmin, L]= plfit(degrees)

print 'Power-law degree distribution: ' + str(alpha)

print ' - xmin: ', xmin

print ' - L: ', L

sys.stdout.flush()

# In-degree

# MAX: Geometry

indegree = nx.in_degree_centrality(G)

maxkey,maxvalue= max(indegree.iteritems(), key=lambda x:x[1])

print 'Max in-degree: ' + str(maxkey) + ' ' + str(maxvalue)

sys.stdout.flush()

# Out-degree

# MAX: List of mathematics articles

outdegree = nx.out_degree_centrality(G)

inverse = [(value, key) for key, value in outdegree.items()]

print 'Max out-degree: ', max(inverse)[1], max(inverse)[0]

sys.stdout.flush()

# Betweenness centrality

# MAX = "Calculus"

# WARNING! Slow... 40 minutes for a 27475-node network with 85729 links !!!

between = nx.betweenness_centrality(G)

maxkey,maxvalue= max(between.iteritems(), key=lambda x:x[1])

print 'Max betweenness: ' + str(maxkey) + ' ' + str(maxvalue)

print ' - In-degree: ', indegree[maxkey]

print ' - Out-degree: ', outdegree[maxkey]

sys.stdout.flush()

package noesis.ui.console;

import java.io.*;

import ikor.util.Benchmark;

import noesis.Network;

import noesis.algorithms.traversal.ConnectedComponents;

import noesis.Attribute;

import noesis.AttributeNetwork;

import noesis.analysis.NodeScore;

import noesis.analysis.structure.Betweenness;

import noesis.analysis.structure.InDegree;

import noesis.analysis.structure.OutDegree;

/**

 * Network statistics.

 * 

 * @author Fernando Berzal

 */

public class NetworkStats 

{

  public static void main(String[] args)

    throws IOException

  {

    if (args.length==0) {

      System.err.println("NOESIS Network Statistics:");

      System.err.println();

      System.err.println("  java noesis.ui.console.NetworkStats <file>");

    } else {

      Benchmark  crono = new Benchmark();

      crono.start();

      Network net = NetworkUtilities.read(args[0]);

      NetworkUtilities.printNetworkInformation(net);

      // Degree distributions

      OutDegree outDegrees = new OutDegree(net);

      InDegree  inDegrees = new InDegree(net);

      outDegrees.compute();

      inDegrees.compute();

      System.out.println("Degree distributions");

      System.out.println("- Out-degrees: "+outDegrees.getResult());

      System.out.println("- In-degrees:  "+inDegrees.getResult());

      if (net instanceof AttributeNetwork) {

        System.out.println("Node of maximum out-degree:");

        printNode ( (AttributeNetwork) net, outDegrees.getResult().maxIndex());        

        System.out.println("Node of maximum in-degree:");

        printNode ( (AttributeNetwork) net, inDegrees.getResult().maxIndex());

      }

      // Betweenness 

      Betweenness betweenness = new Betweenness(net);

      betweenness.compute();

      System.out.println("Betweenness");

      System.out.println(betweenness.getResult());

      if (net instanceof AttributeNetwork) {

        System.out.println("Node of maximum betweenness:");

        printNode ( (AttributeNetwork) net, betweenness.getResult().maxIndex());        

      }

      crono.stop();

      System.out.println();

      System.out.println("Time: "+crono);

    }

  }

  public static void printNode (AttributeNetwork net, int index)

  {

    if (index<net.size()) {

      //System.out.println("- index: "+index);

      System.out.println("- out-degree: "+net.outDegree(index)+" out-links");

      System.out.println("- in-degree: "+net.inDegree(index)+" in-links");

      for (int i=0; i<net.getNodeAttributeCount(); i++) {

        Attribute attribute = net.getNodeAttribute(i);

        System.out.println("- "+attribute.getID()+": "+attribute.get(index));

      }

    }    

  }

}