Link Analysis_1_Basic Elements

1. Edge Attributes

1.1 Methods of category

1.1.1 Basic three categories in terms of number of layers as edges or direction of edges:

import networkx as nx
G = nx.DiGraph() # 1.directed
G = nx.Graph() # 2.undirected
G = nx.MultiGraph() # 3.between two nodes many layers of relationships

1.1.2 Logical categories in terms of cluster characteristics, i.e., Bipartite:

from networkx.algorithms import bipartite
B = nx.Graph() # create an empty network first step, no subsets of nodes
B.add_nodes_from(['H', 'I', 'J', 'K', 'L'], bipartite = 0) # label 1 group
B.add_nodes_from([7, 8, 9, 10], bipartite = 1) # label 2

# add a list of edges at one time
B.add_edges_from([('H', 7), ('I', 7), ('J', 9),('K', 8), ('K', 10), ('L', 10)])
# Chect if bipartite or not
bipartite.is_bipartite(B)

Bipartite graph cannot contain a cycle of an odd number of nodes.

1.2 Edge can contain detailed features:

G.add_edge('A', 'B', weight = 6, relation = 'family', sign = '+')
G.remove_edge('A', 'B') # remove edge

1.3 Access edges:

G.edges() # list of all edges
G.edges(data = True) # list of all with attributes
G.edges(data = 'relation') # list with certain attribute

2. Node Attributes

2.1 Node be named as character.

G.add_node('A', name = 'Sophie')
G.add_node('B', name = 'Cumberbatch')
G.add_node('C', name = 'Miko') # pet dog

2.2 Access nodes:

G.node['A']['name']

3. Network Connectivity

3.1 Triadic Closure: Tendency for people who have shared connections to become connects, i.e., to cluster.

3.1.1 Local Clustering Coefficient

# local clustering only for multigraph type
G = nx.Graph()
G.add_edges_from([('A', 'K'),
                 ('A', 'B'),
                 ('A', 'C'),
                 ('B', 'C'),
                 ('B', 'K'),
                 ('C', 'E'),
                 ('C', 'F'),
                 ('D', 'E'),
                 ('E', 'F'),
                 ('E', 'H'),
                 ('F', 'G'),
                 ('I', 'J')])
nx.clustering(G, 'A')

0.6666666666666666

Solve: 2 / [2 × 3 ÷ 2] # actual pairs / (C32)

3.1.2 Global Clustering Coefficient

# Method 1: Take average of all local clustering coefficients.
nx.average_clustering(G)

0.28787878787878785

# Method 2: Percent of open triads that are triangles in the network
# Triange: 3 nodes connected by 3 edges
# open triads: 3 nodes connected by 2 edges
# Transitivity = (3 * number of closed triads) / number of open triads
nx.transitivity(G)

0.4090909090909091

Method 2 put a larger weight on high degree nodes.

3.2 Distances

3.2.1 Singe Pair Pattern:

Find path and length of the shortest path between two nodes.

nx.shortest_path(G, 'A', 'H')

['A', 'C', 'E', 'H']

nx.shortest_path_length(G, 'A', 'H')

3

3.2.2 One Node to Every Others Pattern:

Breadth-first Search: discover nodes in layers step by step.

T = nx.bfs_tree(G, 'A')
T.edges() # to get the tree

OutEdgeView([('A', 'K'), ('A', 'B'), ('A', 'C'), ('C', 'E'), ('C', 'F'), ('E', 'D'), ('E', 'H'), ('F', 'G')])

nx.shortest_path_length(G, 'A') # get dictionary of distances from A to others

{'A': 0, 'K': 1, 'B': 1, 'C': 1, 'E': 2, 'F': 2, 'D': 3, 'H': 3, 'G': 3}

3.2.3 Measures of Distance Patterns

# Average of all
nx.average_shortest_path_length(G)
# Maximum distance
nx.diameter(G)

Eccentricity of a node is the largest distance between A and all others.

Radius is the minimum eccentricity.

Periphery is the set of nodes that have eccentricity equal to the diameter.

Center is the set of nodes with eccentricity equal to radius.

nx.eccentricity(G)
nx.radius(G)
nx.periphery(G)
nx.center(G)

3.2.4 Application

import numpy as np
import pandas as pd
%matplotlib notebook
# Instantiate the graph
G = nx.karate_club_graph()
nx.draw_networkx(G)

4. Connectivity

4.1 Connectivity in Undirected Graphs

# find number of communities (connected componets)
nx.number_connected_componets(G)
# give list of them
sorted(nx.connected_components(G))
# find the community to which 'M' belongs
nx.node_connected_components(G, 'M')

4.2 Connectivity in Directed Graphs

# find strongly connected component (directed path to every other nodes &
# no other node has directed path to this subset)
sorted(nx_strongly_connected_components(G))

5. Network Robustness

5.1 Definition: the ability for network to maintain general structural properties (connectivity) when faced with attacks (removal of edges or nodes).

# smallest number of nodes needed to disconnect
nx.node_connectivity(G_un)
# which nodes
nx.minimum_code_cut(G_un)
# smallest number of edges needed to disconnect
nx.edge_connectivity(G_un)
# which edges
nx.minimum_edge_cut(G_un)

5.2 Node Connectivity

# ways to deliver msg from 'G' to 'L'
sorted(nx.all_simple_paths(G, 'G', 'L'))
# want to block this path, how many nodes neeed to remove
nx.node_connectivity(G, 'G', 'L')
# which nodes
nx.minimum_node_cut(G, 'G', 'L')

5.3 Edge Connectivity

# how many
nx.edge_connectivity(G, 'G', 'L')
# show in details
nx.minimum_edge_cut(G, 'G', 'L')

6. Centrality

6.1 Degree Centrality

6.1.1 Undirected Network

G = nx.karate_club_graph()
G = nx.convert_node_labels_to_integers(G, first_label = 1)
degCent = nx.degree_centrality(G)

degCent[34]

0.5151515151515151

6.1.2 Directed Network

indegCent = nx.in_degree_centrality(G)

indegCent = nx.out_degree_centrality(G)

6.2 Closeness Centrality

6.2.1 Calculation: Shorter distance away from all other nodes.

closeCent = nx.closeness_centrality(G)
closeCent[34]

0.55

sum(nx.shortest_path_length(G, 34).values())

60

# Essence is equivalent to process below
(len(G.nodes()) - 1)/61

0.5409836065573771

6.2.2 Disconnceted Nodes Measurement

Method One

# choose non-normalizing, closeness centrality would be one
nx.closeness_centrality(G, normalized = False)

1

Method Two

# choose normalising,i.e. divide by (total nodes - 1)
nx.closeness_centrality(G, normalized = True)

0.071

6.3 Betweenness Centrality (computationally expensive)

Essence: Find nodes which shows up in many shortest paths between two nodes.

6.3.1 Method One: Use all 34 nodes in karate club

btwnCent = nx.betweenness_centrality(G,normalized = True, endpoints = False)
import operator
sorted(btwnCent.items(), key = operator.itemgetter(1), reverse = True)[0:5]

[(1, 0.43763528138528146),
 (34, 0.30407497594997596),
 (33, 0.145247113997114),
 (3, 0.14365680615680618),
 (32, 0.13827561327561325)]

6.3.2 Method Two: Use 10 nodes as approximation

btwnCent_approx = nx.betweenness_centrality(G,normalized = True, endpoints = False, k = 10)
sorted(btwnCent_approx.items(), key = operator.itemgetter(1), reverse = True)[0:5]

[(1, 0.3674031986531986),
 (34, 0.3048388648388649),
 (32, 0.17290028258778256),
 (3, 0.13572044853294854),
 (33, 0.130249518999519)]

6.3.3 Method Three: Specify subsets

btwnCent_subset = nx.betweenness_centrality_subset(G,
                                                  [34, 33, 21, 30, 16, 27, 15, 23, 10],
                                                  [1, 4, 13, 11, 6, 12, 17, 7],
                                                  normalized = True)
sorted(btwnCent_subset.items(), key = operator.itemgetter(1), reverse = True)[0:5]

[(1, 0.04899515993265994),
 (34, 0.028807419432419434),
 (3, 0.018368205868205867),
 (33, 0.01664712602212602),
 (9, 0.014519450456950456)]

6.3.4 Method Four: Edges

btwnCent_edge = nx.edge_betweenness_centrality(G, normalized = True)
sorted(btwnCent_edge.items(), key = operator.itemgetter(1), reverse = True)[0:5]
# node 1 is the instructor of club

[((1, 32), 0.1272599949070537),
 ((1, 7), 0.07813428401663695),
 ((1, 6), 0.07813428401663694),
 ((1, 3), 0.0777876807288572),
 ((1, 9), 0.07423959482783014)]

btwnCent_edge_subset = nx.edge_betweenness_centrality_subset(G,
                                                            [34, 33, 21, 30, 16, 27, 15, 23, 10],
                                                              [1, 4, 13, 11, 6, 12, 17, 7],
                                                             normalized = True)
sorted(btwnCent_edge_subset.items(), key = operator.itemgetter(1), reverse = True)[0:5]

[((1, 9), 0.01366536513595337),
 ((1, 32), 0.01366536513595337),
 ((14, 34), 0.012207509266332794),
 ((1, 3), 0.01211343123107829),
 ((1, 6), 0.012032085561497326)]