def test_bipartite_density(self):
G=nx.path_graph(5)
X,Y=bipartite.sets(G)
density=float(len(G.edges()))/(len(X)*len(Y))
assert_equal(bipartite.density(G,X),density)
D = nx.DiGraph(G.edges())
assert_equal(bipartite.density(D,X),density/2.0)
assert_equal(bipartite.density(nx.Graph(),{}),0.0)
def test_bipartite_density(self):
G = nx.path_graph(5)
X, Y = bipartite.sets(G)
density = float(len(list(G.edges()))) / (len(X) * len(Y))
assert_equal(bipartite.density(G, X), density)
D = nx.DiGraph(G.edges())
assert_equal(bipartite.density(D, X), density / 2.0)
assert_equal(bipartite.density(nx.Graph(), {}), 0.0)
def main():
for path in files:
print(path)
B = nx.Graph()
G = nx.read_gml('graphs/' + path)
B.add_nodes_from(relevant_subreddits, bipartite=0)
nodeList = set([n for n in G.nodes()])
for reddit in relevant_subreddits:
if reddit in nodeList:
nodeList.remove(reddit)
B.add_nodes_from(list(nodeList), bipartite=1)
# print(nx.number_of_nodes(G))
# B.add_edges_from([e for e in G.edges()])
edgeList = []
for e in G.edges():
if e[0] not in relevant_subreddits and e[
1] not in relevant_subreddits:
continue
edgeList.append(e)
B.add_edges_from(edgeList)
# print(nx.number_of_edges(G))
# print(bipartite.is_bipartite(B))
# print(bipartite.average_clustering(B))
result = random.sample(list(nodeList), 500)
print('Clustering Coefficient')
print(bipartite.average_clustering(B, result))
print('Density')
print(bipartite.density(B, result))
def generate_random_2mode(G):
top_nodes = {n for n, d in G.nodes(data=True) if d['bipartite'] == 0}
bot_nodes = set(G) - top_nodes
size = G.size()
density = bp.density(G, top_nodes)
#return bp.gnmk_random_graph(len(top_nodes), len(bot_nodes), size)
return bp.random_graph(len(top_nodes), len(bot_nodes), density)
def summay_results(nets=None, years=None):
if years is None:
years = default_years
if nets is None:
nets = networks_by_year()
result = {}
previous_devs = None
for year, G in zip(years, nets):
result[year] = {}
devs = set(n for n, d in G.nodes(data=True) if d['bipartite']==1)
files = set(G) - devs
result[year]['guido_in'] = u'Guido van Rossum' in G
result[year]['density'] = bp.density(G, devs)
cc = sorted(nx.connected_components(G), key=len, reverse=True)
result[year]['cc'] = len(cc[0]) / float(G.order()) if cc else 0
bcc = sorted(nx.biconnected_components(G), key=len, reverse=True)
result[year]['bcc'] = len(bcc[0]) / float(G.order()) if bcc else 0
result[year]['devs'] = len(devs)
result[year]['files'] = len(files)
result[year]['py_files'] = len([f for f in files if f.endswith('.py')])
result[year]['c_files'] = len([f for f in files if f.endswith('.c')
or f.endswith('.h')])
result[year]['doc_files'] = len([f for f in files if f.lower().endswith('.txt')
or f.endswith('.rst')
or f.endswith('.tex')])
result[year]['weight'] = sum(nx.degree(G, devs, weight='weight').values())
result[year]['added'] = sum(nx.degree(G, devs, weight='added').values())
result[year]['deleted'] = sum(nx.degree(G, devs, weight='deleted').values())
result[year]['edits'] = sum(nx.degree(G, devs, weight='edits').values())
result[year]['sq_clustering'] = (sum(nx.square_clustering(G, devs).values())
/ float(len(devs)))
if previous_devs is None:
# First year
result[year]['new_devs'] = len(devs)
result[year]['continue_devs'] = 0
result[year]['lost_devs'] = 0
else:
result[year]['new_devs'] = len(devs - previous_devs)
result[year]['continue_devs'] = len(devs & previous_devs)
result[year]['lost_devs'] = len(previous_devs - devs)
previous_devs = devs
return result
GP = bipartite.projected_graph(G, nodes_1)
print('Calculate Global properties for projected graph ' + type_proj)
print("\n")
else:
print('Calculate Global properties for bipartite network')
print("\n")
if type_nx == 'bipartite':
print("Nodes Number : " + str(G.number_of_nodes()))
print("\n")
print("Edges Number : " + str(G.number_of_edges()))
print("\n")
print('Calculating density ...')
print("\n")
print("Density ICD Nodes (Diseases): " +
str(bipartite.density(G, nodes_0)))
print("\n")
print("Density ATC Nodes (Active Substances): " +
str(bipartite.density(G, nodes_1)))
print("\n")
print('Calculating mean degree ...')
print("\n")
G_deg = nx.degree_histogram(G)
G_deg_sum = [a * b for a, b in zip(G_deg, range(0, len(G_deg)))]
print('average degree: {}'.format(
sum(G_deg_sum) / G.number_of_nodes()))
print("\n")
print('Calculating mean clustering ...')
print("\n")
cluster_g = bipartite.clustering(G)
scg = 0
def test_bipartite_density(self):
G = nx.path_graph(5)
X, Y = bipartite.sets(G)
density = float(len(G.edges())) / (len(X) * len(Y))
assert_equal(bipartite.density(G, X), density)
def test_bipartite_density(self):
G=nx.path_graph(5)
X,Y=bipartite.sets(G)
density=float(len(G.edges()))/(len(X)*len(Y))
assert_equal(bipartite.density(G,X),density)
def bipartite_analysis(members, prods, graph):
print bipartite.density(graph, members)
print bipartite.density(graph, prods)
return bipartite.clustering(graph, members)
def bipartite_analysis(members, prods, graph):
print bipartite.density(graph, members)
print bipartite.density(graph, prods)
return bipartite.clustering(graph, members)
labels = {}
for idx, node in enumerate(B.nodes()):
labels[node] = node
nx.draw_networkx_labels(B, pos, labels=labels, font_size=11, ax=ax)
fig.set_facecolor('grey')
plt.savefig(
"/Users/jennie/Documents/urban informatics/Network/cw1/labels_and_colors.png",
facecolor=fig.get_facecolor()) # save as png
plt.show()
#--------------------------------------------------------------------------
# Calculate the density of the bipartite graph
#--------------------------------------------------------------------------
print(round(bipartite.density(B, bottom_nodes), 3))
#--------------------------------------------------------------------------
# Calculate the degree distribution of universities from the bipartite projected graph.
# We need to have a multigraph because it works for counting the mappings
#--------------------------------------------------------------------------
U = bipartite.weighted_projected_graph(B, bottom_nodes)
#--------------------------------------------------------------------------
# Calculate the degree for the top and bottom nodes of the bipartite graph
#--------------------------------------------------------------------------
import operator
degX, degY = bipartite.degrees(U, top_nodes, weight='weight')
#universites
a, b = zip(*degX)
degreeCount = collections.Counter(b)
G.node[cytokine]['type'] = 'cytokine'
G.node[cell]['bipartite'] = 0
G.node[cytokine]['bipartite'] = 1
print("============== tolapc network ============")
print(G.number_of_edges())
print(G.number_of_nodes())
#print(nx.clustering(G))
#print(nx.degree(G))
print(nx.is_connected(G))
top_nodes = set(n for n,d in G.nodes(data=True) if d['bipartite']==0)
bottom_nodes = set(G) - top_nodes
print("cells", len(top_nodes))
print("cykines", len(bottom_nodes))
#print(top_nodes, bottom_nodes)
print(bipartite.density(G, top_nodes))
print(bipartite.density(G, bottom_nodes))
#print(bipartite.maximum_matching(G))
#print(bipartite.clustering(G))
#print(bipartite.node_redundancy(G))
print(nx.info(G))
print(nx.density(G))
#print(nx.degree_histogram(G))
print(nx.diameter(G))
print(nx.radius(G))
print(nx.center(G))
print()
print()
network2_file = sys.argv[2]
def describe(self, extra=False):
"""
Provides a summary of graph statistics. Includes basic statistics like the number of nodes, edges,
denstiy, and the average degree for one mode. Prints a string that contains each of the items that make up the summary.
Density is calculated using one of the modes of the original bipartite network graph.
**Parameters** :
> *extra* : `bool`
>> Runs the low efficiency algorithms, which can be resource-intensive on large networks.
>> Recommended maximum network size for the low efficiency algorithms is around 100 nodes.
**Returns** : `string`
> Returns the descriptive string that contains information about the `MultiGraphPlus` object.
"""
mode1 = self.mode1
mode2 = self.mode2
density = bipartite.density(self, bipartite.sets(self)[0])
edges = self.number_of_edges()
nodes_mode1 = 0
nodes_mode2 = 0
for n in self.nodes():
if self.node[n]['type'] == mode1:
nodes_mode1 += 1
elif self.node[n]['type'] == mode2:
nodes_mode2 += 1
descriptives_nodes = "This is a bipartite network of types '{}' and '{}'.\n " \
"{} nodes are of the type '{}'.\n " \
"{} nodes are of the type '{}'.\n".format(str(mode1), str(mode2), str(nodes_mode1),
str(mode1), str(nodes_mode2), str(mode2))
descriptives_edges = "There are {} edges.\n".format(str(edges))
descriptives_density = "Density: {}.\n".format(str(density))
descriptives = descriptives_nodes + descriptives_edges + descriptives_density
if extra:
# Note: for each mode of the bipartite graph, degree and betweenness centrality are the same.
# Keeping them both makes it easy to compare them and make sure they are the same.
degree_mode1 = bipartite.degree_centrality(self, bipartite.sets(self)[0])
degree_mode2 = bipartite.degree_centrality(self, bipartite.sets(self)[1])
degree_mode1 = list(degree_mode1.values())
degree_mode2 = list(degree_mode2.values())
degree_mode1 = np.mean(degree_mode1)
degree_mode2 = np.mean(degree_mode2)
betweenness_mode1 = bipartite.betweenness_centrality(self, bipartite.sets(self)[0])
betweenness_mode1 = list(betweenness_mode1.values())
betweenness_mode1 = np.mean(betweenness_mode1)
betweenness_mode2 = bipartite.betweenness_centrality(self, bipartite.sets(self)[1])
betweenness_mode2 = list(betweenness_mode2.values())
betweenness_mode2 = np.mean(betweenness_mode2)
g = nx.Graph(self)
projection = bipartite.projected_graph(g, bipartite.sets(g)[0])
transitivity = nx.transitivity(projection)
descriptives_transitivity = "Transitivity: {}.\n".format(str(transitivity))
descriptives_degree_centrality = "Mean Degree Centrality for '{}': {}.\n" \
"Mean Degree Centrality for '{}': {}.\n".format(str(mode1),
str(degree_mode1),
str(mode2),
str(degree_mode2))
descriptives_btwn_centrality = "Mean Betweenness Centrality for '{}': {}.\n"\
"Mean Betweenness Centrality for '{}': {}.\n".format(str(mode1),
str(betweenness_mode1),
str(mode2),
str(betweenness_mode2))
descriptives = descriptives + descriptives_transitivity +\
descriptives_degree_centrality + descriptives_btwn_centrality
print(descriptives)
return descriptives
pd.Series(video_counts).describe()
#########################
### Build a network ###
#########################
# One group is student IDs
# The other group is video IDs
G = nx.Graph()
G.add_nodes_from(students, bipartite=0)
G.add_nodes_from(videos, bipartite=1)
G.add_edges_from(
list(zip(combined['useraccount_id'].values, combined['video_id'].values)))
cluster_all = bipartite.average_clustering(G)
density_all = bipartite.density(G)
# Get degrees for unprojected graph
student_degree = G.degree(students)
list_student_degree = [val for (node, val) in student_degree]
plt.hist(list_student_degree)
plt.xlabel('Number of Unique Videos')
plt.ylabel('Number of Students')
plt.show()
pd.Series(list_student_degree).describe()
video_degree = G.degree(videos)
list_video_degree = [val for (node, val) in video_degree]
plt.hist(list_video_degree)
plt.xlabel('Number of Unique Accessing Students')
plt.ylabel('Number of Videos')
#__________________________________________________________________
# Creates the nodes for the directors
# for dir in director:
# for tit, dire in titdir.items(): # --> returns the movies with the same director
# if dire == dir:
# g.add_edge(tit, dir)
# print(tit)
#g.add_nodes_from(director, bipartite = 1) # --> create and add nodes from the director list, with bipartite att = 1
#___________________________________________________________________
"""
Creates a bipartite graph for directors and movie titles
"""
g.remove_nodes_from(["Comforting Skin", "Way of Blue Sky"])
title_nodes, genre_nodes = bipartite.sets(g)
color_map = []
for node in g:
if node in title_nodes:
color_map.append('red')
elif node in genre_nodes:
color_map.append('green')
print(bipartite.density(g, genre_nodes))
nx.draw(g, node_color=color_map, with_labels=True)
plt.show()