def plot_time_after_spreading_vs_log_10_number_of_newly_infected_user(df):
title = 'time (minutes) since seed creation time vs newly infected user {}'.format(
project_name)
number_of_seeds = 5
seed_count_series = df.seed_index.value_counts()
pallttes = sns.cubehelix_palette(number_of_seeds)
for index in range(number_of_seeds):
seed_index = seed_count_series.keys()[index]
data_to_plot = df.copy()
data_to_plot = data_to_plot[data_to_plot.seed_index ==
seed_index]['time_since_seed']
data_to_plot = data_to_plot.reset_index()
data_to_plot['counter'] = np.log10(range(1, len(data_to_plot) + 1))
plt.plot(data_to_plot['time_since_seed'],
data_to_plot['counter'],
marker='',
color=pallttes[number_of_seeds - index - 1],
linewidth=1,
alpha=0.9,
label='Seed {}'.format(index + 1))
plt.title(title)
plt.xlabel('time (minutes)')
plt.ylabel('number of new infected users (log base 10)')
plt.legend()
dzcnapy.plot(title, [15, 9], save=True)
def plot_forward_bar(g, x):
title = 'Forward spreading bar for seed at index {}'.format(x)
plt.rcParams['figure.figsize'] = [15, 9]
network = pd.DataFrame(
data={
'time_lapsed': list(
nx.get_node_attributes(g, 'time_lapsed').values()),
'generation': list(
nx.get_node_attributes(g, 'generation').values())
})
depth = max(network.generation)
d = pd.DataFrame(0,
index=np.arange(int(timeframe) / window),
columns=range(depth))
for i in range(int(int(timeframe) / window)):
data = network[(network.time_lapsed >= (i) * window)
& (network.time_lapsed < (i + 1) * window)]
for generation in range(depth):
d.iloc[i, generation] = sum(data.generation == generation)
colors = get_colors(depth)
ax = d.plot.bar(stacked=True, color=colors)
ax.set_xticks(range(48))
ax.set_xticklabels([i * 0.5 for i in range(48)])
ax.set_xlabel('time lapsed (30 mins per bar)')
ax.set_ylabel('number of newly infected users')
patchList = []
for index in range(depth):
data_key = mpatches.Patch(color=colors[index],
label='Generation {}'.format(index))
patchList.append(data_key)
plt.legend(handles=patchList)
dzcnapy.plot(title, [15, 9], save=True)
def plot_time_vs_number_of_seeds(df):
title = 'Time vs Number of seeds, for event {}'.format(project_name)
seeds_dataframe = unique_users[unique_users.generation == 0].copy()
seeds_dataframe = order_and_reindex(seeds_dataframe, 'time_lapsed')
n_bins = math.floor(float(timeframe) / window)
sns.distplot(seeds_dataframe['time_lapsed'], kde=False, bins=n_bins)
plt.xlabel('time lapsed [{} minutes per bar]'.format(window))
plt.ylabel('number of seeds')
dzcnapy.plot(title, [15, 9], save=True)
def prob_dist_plot(graph):
deg = dict(nx.degree(graph))
x, y = zip(*Counter(deg.values()).items())
plt.scatter(x, y, s=10, c="navy")
plt.xscale("log")
plt.yscale("log")
plt.title("Tennis players degree distribution -- log scale")
plt.xlim(0.9, max(x) + 10)
plt.ylim(0.9, max(y) + 10)
plt.xlabel("log(Degree)")
plt.ylabel("log(Frequency)")
dzcnapy.plot("Tennis players degree distribution")
def plot_degree_frequency(network):
title = 'Degree frequency of all nodes in the spreading of event {}'.format(
project_name)
deg = nx.degree(network_all)
x, y = zip(*Counter(dict(deg).values()).items())
plt.scatter(x, y)
plt.xscale("log")
plt.yscale("log")
plt.xlim(0.9, max(x))
plt.ylim(0.9, max(y))
plt.xlabel("Degree")
plt.ylabel("Frequency")
dzcnapy.plot(title, [15, 9], save=True)
def plot_network(graph, title):
plt.axis('off')
pos = graphviz_layout(graph)
nx.draw_networkx(graph, pos=pos, with_labels=False, **dzcnapy.small_attrs)
depth = max(nx.get_node_attributes(graph, 'generation').values()) + 1
colors = get_colors(depth)
color = [colors[graph.node[n]["generation"]] for n in graph]
dzcnapy.small_attrs["node_color"] = color
patchList = []
for index in range(depth):
data_key = mpatches.Patch(color=colors[index],
label='Generation {}'.format(index))
patchList.append(data_key)
plt.legend(handles=patchList)
dzcnapy.set_extent(pos, plt)
dzcnapy.plot(title, [15, 15], save=True)
def plot_time_vs_log_seed_descedants(network):
title = 'Time vs number of seed descendants for event {}'.format(
project_name)
seed_count_series = network.seed_index.value_counts()
seeds_dataframe = unique_users[network.generation == 0].copy()
seeds_dataframe['y'] = 0
for index in seeds_dataframe.index:
seeds_dataframe.loc[index, 'y'] = seed_count_series.get(index)
# use the function regplot to make a scatterplot
sns.regplot(x=seeds_dataframe["time_lapsed"],
y=seeds_dataframe['y'],
fit_reg=False)
plt.xlabel('time lapsed (minutes)')
plt.ylabel('number of descendants')
plt.yscale("log")
dzcnapy.plot(title, [15, 9], save=True)
def centrality_correlation_plot(centralities, cent1, cent2):
X = cent1
Y = cent2
limits = pd.concat(
[centralities[[X, Y]].min(), centralities[[X, Y]].max()],
axis=1).values
centralities.plot(kind="scatter",
x=X,
y=Y,
xlim=limits[0],
ylim=limits[1],
edgecolors='black',
color='pink',
s=75,
alpha=0.6)
plt.grid()
dzcnapy.plot("centralities_comparison")
def plot_log_spreading_graph(df):
title = 'Time versus total number of new infected users of the top 5 seeds during first 24 hours, for event {}'.format(
project_name)
number_of_seeds = 5
seed_count_series = df.seed_index.value_counts()
pallttes = sns.cubehelix_palette(number_of_seeds + 1)
draw_dataframe = df.copy()
draw_dataframe = draw_dataframe.filter(items=['time_lapsed'])
draw_dataframe = draw_dataframe.reset_index()
draw_dataframe['counter'] = range(1, len(draw_dataframe) + 1)
plt.plot(draw_dataframe['time_lapsed'],
draw_dataframe['counter'],
marker='',
color=pallttes[number_of_seeds],
linewidth=1,
alpha=0.9,
label='all')
for index in range(number_of_seeds):
seed_index = seed_count_series.keys()[index]
data_to_plot = df.copy()
data_to_plot = data_to_plot[data_to_plot.seed_index ==
seed_index]['time_lapsed']
data_to_plot = data_to_plot.reset_index()
data_to_plot['counter'] = range(1, len(data_to_plot) + 1)
plt.plot(data_to_plot['time_lapsed'],
data_to_plot['counter'],
marker='',
color=pallttes[number_of_seeds - index],
linewidth=1,
alpha=0.9,
label='Seed {}'.format(index + 1))
plt.xlabel('Time lapsed (minutes)')
plt.ylabel('Total number of new infected users')
plt.yscale("log")
plt.legend()
dzcnapy.plot(title, [15, 9], save=True)
def plot_time_lapsed_vs_newly_infected_users():
title = 'time lapsed vs newly infected users for event {}'.format(
project_name)
d = pd.DataFrame(0,
index=np.arange(int(timeframe) / window),
columns=range(depth))
for i in range(int(int(timeframe) / window)):
data = unique_users[(unique_users.time_lapsed >= (i) * window)
& (unique_users.time_lapsed < (i + 1) * window)]
for generation in range(depth):
d.iloc[i, generation] = sum(data.generation == generation)
colors = get_colors(depth)
ax = d.plot.bar(stacked=True, color=colors)
ax.set_xticks(range(48))
ax.set_xticklabels([i * 0.5 for i in range(48)])
ax.set_xlabel('time lapsed (30 mins per bar)')
ax.set_ylabel('number of newly infected users')
patchList = []
for index in range(depth):
data_key = mpatches.Patch(color=colors[index],
label='Generation {}'.format(index))
patchList.append(data_key)
plt.legend(handles=patchList)
dzcnapy.plot(title, [15, 9], save=True)
generalized_network.remove_edges_from(generalized_network.selfloop_edges())
networks = {
"generalized" : generalized_network,
"pearson" : pearson_network_sign,
"cosine" : cosine_network,
"hamming" : hamming_network,
}
partitions = [community.best_partition(x) for x in networks.values()]
statistics = sorted([
(name,
community.modularity(best_part, netw),
len(set(best_part.values())),
len(nx.isolates(netw))
) for (name, netw), best_part in zip(networks.items(), partitions)],
key=lambda x: x[1], reverse=True)
print(statistics)
pos = graphviz_layout(generalized_network)
for i, (name, _, _, _) in enumerate(statistics):
net = networks[name]
ax = plt.subplot(2, 2, i + 1)
nx.draw_networkx_edges(net, pos, ax=ax, alpha=0.5, **dzcnapy.medium_attrs)
nx.draw_networkx_nodes(net, pos, ax=ax, **dzcnapy.medium_attrs)
nx.draw_networkx_labels(net, pos, ax=ax, **dzcnapy.medium_attrs)
dzcnapy.set_extent(pos, ax, name)
dzcnapy.plot("compare_traumas")
nhood = nx.subgraph(G, list(alters1.keys()) + [ego])
egonet = nx.ego_graph(G, ego)
pos = graphviz_layout(nhood)
#Locate the chord edges and remove them
chords = [(n1, n2) for n1, n2 in nhood.edges() if n1 != ego and n2 != ego]
nhood.remove_edges_from(chords)
#Draw the neighborhood and the ego-centric network
for g, ofile in zip((nhood, egonet), ("neighborhood", "egonet")):
nx.draw_networkx_edges(g, pos, alpha=0.7, **dzcnapy.attrs)
nx.draw_networkx_nodes(g, pos, **dzcnapy.attrs)
nx.draw_networkx_labels(g, pos, alpha=0.7, **dzcnapy.medium_attrs)
dzcnapy.set_extent(pos, plt)
dzcnapy.plot(ofile)
F = nx.Graph(G)
deg = pd.Series(dict(nx.degree(G)))
cc = pd.Series({e: nx.clustering(F, e) for e in F})
deg_cc = pd.contact([deg, cc], axis=1)
deg_cc.columns = ("Degree", "CC")
deg_cc.groupby("Degree").mean().reset_index().plot(kind="scatter",
x="Degree",
y="CC",
s=100)
plt.xscale("log")
plt.ylim(ymin=0)
plt.grid()
dzcnapy.plot("deg_cc")
import dzcnapy_plotlib as dzcnapy
F = nx.Graph()
for i in range(1, 9):
for j,k in zip('ABCDEFG','BCDEFGH'):
F.add_edge('{}{}'.format(j,i),'{}{}'.format(k,i))
for i in 'ABCDEFGH':
for j,k in zip(range(1,8), range(2,9)):
F.add_edge('{}{}'.format(i,j), '{}{}'.format(i,k))
pos = graphviz_layout(F)
nx.draw_networkx(F, pos, **dzcnapy.attrs)
dzcnapy.set_extent(pos, plt)
dzcnapy.plot("checkerboard")
#Tree
lincoln_list = [
("A.L.", "Edward Baker L."), ("A.L.", "Robert Todd L."),
("A.L.", "William Wallace L."), ("A.L.", "Thomas L. III"),
("Jessie Harlan L.", "Mary L. Beckwith"),
("Jessie Harlan L.", "Robert Todd L. Beckwith"),
("Mary L.", "L. Isham"), ("Robert Todd L.", "A.L. II"),
("Robert Todd L.", "Jessie Harlan L."),
("Robert Todd L.", "Mary L."), ("Thomas L.", "A.L."),
("Thomas L.", "Sarah L. Grigsby"), ("Thomas L.", "Thomas L. Jr."),
]
F = nx.DiGraph(lincoln_list)
pos = graphviz_layout(F)
import networkx as nx, community, csv
import matplotlib.style as style, matplotlib.pyplot as plt
from networkx.drawing.nx_agraph import graphviz_layout
import dzcnapy_plotlib as dzcnapy
F = nx.DiGraph()
F.add_node("C")
F.add_edges_from([("B", "b0"), ("b0", "b1"), ("b1", "B")])
F.add_edges_from([("A", "a0"), ("a0", "a1"), ("a1", "a2"), ("a1", "a3"), ("a3", "A")])
pos = graphviz_layout(F)
nx.draw_networkx(F, pos, **dzcnapy.attrs)
dzcnapy.set_extent(pos, plt)
dzcnapy.plot("abcNwtwork")
G = nx.Graph(
(("Alpha", "Bravo"), ("Bravo", "Charlie"), ("Charlie", "Delta"),
("Charlie", "Echo"), ("Charlie", "Foxtrot"), ("Delta", "Echo"),
("Delta", "Foxtrot"), ("Echo", "Foxtrot"), ("Echo", "Golf"),
("Echo", "Hotel"), ("Foxtrot", "Golf"), ("Foxtrot", "Hotel"),
("Delta", "Hotel"), ("Golf", "Hotel"), ("Delta", "India"),
("Charlie", "India"), ("India", "Juliet"), ("Golf", "Kilo"),
("Alpha", "Kilo"), ("Bravo", "Lima")))
pos = graphviz_layout(G)
core = nx.k_core(G)
crust = nx.k_crust(G)
corona3 = nx.k_corona(G, k=3).nodes()
nx.draw_networkx(G, pos, nodelist=core, **dzcnapy.attrs)
nx.draw_networkx_edges(G, pos, core.edges(), **dzcnapy.tick_attrs)
nx.draw_networkx_edges(G, pos, crust.edges(), **dzcnapy.tick_attrs)
nx.draw_networkx_nodes(G, pos, crust, node_shape='v', **dzcnapy.attrs)
(58, 60, 132, 552, 291, 180, 88, 62, 58, 36, 20, 4, 3, 16, 119, 81),
"Boston": (93, 104, 106, 101, 80, 82, 82, 110, 216, 292, 281, 205, 246,
204, 159, 86),
"Chicago": (115, 195, 122, 109, 86, 120, 157, 210, 273, 196, 139, 101, 113,
106, 107, 115),
"San Francisco":
(35, 67, 156, 616, 1208, 894, 268, 67, 2, 0, 0, 0, 2, 9, 22, 35)
}
# Draw the wind roses
angles = np.linspace(0, 2 * np.pi, 16)
ax = plt.subplot(111, polar=True)
for name, wind in winds.items():
ax.plot(angles, wind, "-o", label=name)
ax.set_theta_zero_location("N")
ax.set_theta_direction(-1)
plt.legend(loc=2)
dzcnapy.plot("windroses")
wind_cities_cosine = pd.DataFrame(
{y: [1 - dist.cosine(winds[x], winds[y]) for x in winds]
for y in winds},
index=winds.keys())
# Pearson correlation
wind_cities_pearson = pd.DataFrame(
{y: [stats.pearsonr(winds[x], winds[y])[0] for x in winds]
for y in winds},
index=winds.keys())
pd.DataFrame(winds).corr()
n_graph = bipartite.projected_graph(N, nutrients)
f_graph = bipartite.projected_graph(N, foods)
fw_graph = bipartite.weighted_projected_graph(N, foods, True)
# Edge width represents weights
dzcnapy.attrs["width"] = [d['weight'] * 75 for n1, n2, d in
fw_graph.edges(data=True)]
dzcnapy.thick_attrs["width"] = 10
pos = graphviz_layout(f_graph)
nx.draw_networkx_edges(f_graph, pos, **dzcnapy.thick_attrs)
nx.draw_networkx_nodes(f_graph, pos, **dzcnapy.attrs)
nx.draw_networkx_labels(f_graph, pos, **dzcnapy.attrs)
dzcnapy.set_extent(pos, plt)
dzcnapy.plot("projected_foods")
adj = bipartite.biadjacency_matrix(N, f_graph).toarray()
foods = pd.DataFrame([[stats.pearsonr(x, y)[0] for x in adj]
for y in adj], columns=f_graph, index=f_graph)
SLICING_THRESHOLD = 0.375
stacked = foods.stack()
edges = stacked[stacked >= SLICING_THRESHOLD].index.tolist()
f_pearson = nx.Graph(edges)
nx.draw_networkx_edges(f_pearson, pos, **dzcnapy.thick_attrs)
nx.draw_networkx_nodes(f_graph, pos, **dzcnapy.attrs)
nx.draw_networkx_labels(f_graph, pos, **dzcnapy.attrs)
dzcnapy.set_extent(pos, plt)
dzcnapy.plot("pearson_foods")
if nx.number_of_nodes(p) >= 20 or nx.number_of_edges(p) >= 20
]
panama0 = panama.subgraph(itertools.chain.from_iterable(components))
print(nx.number_of_nodes(panama0), nx.number_of_edges(panama0))
with open("panama-beneficiary.pickle", "wb") as outfile:
pickle.dump(panama0, outfile)
cdict = {"Entities": "pink", "Officers": "blue", "Intermediaries": "green"}
c = [cdict[panama0.node[n]["kind"]] for n in panama0]
dzcnapy.small_attrs["node_color"] = c
pos = graphviz_layout(panama0)
nx.draw_networkx(panama0, pos=pos, with_labels=False, **dzcnapy.small_attrs)
dzcnapy.set_extent(pos, plt)
dzcnapy.plot("panama0")
nx.attribute_assortativity_coefficient(panama0, "kind")
nx.attribute_mixing_matrix(panama0,
"kind",
mapping={
"Entities": 0,
"Officers": 1,
"Intermediaries": 2
})
nx.attribute_assortativity_coefficient(panama0, "country")
nx.degree_assortativity_coefficient(panama0)
deg = nx.degree(panama0)
x, y = zip(*Counter(deg.values()).items())
nx.set_node_attributes(G, nutrient_dict, "nutrient")
# Prepare for drawing
colors = ["yellow" if n[1]["nutrient"] else "pink" for n in
G.nodes(data=True)]
dzcnapy.medium_attrs["node_color"] = colors
# Draw four layouts in four subplots
_, plot = plt.subplots(2, 2)
subplots = plot.reshape(1, 4)[0]
layouts = (nx.random_layout, nx.circular_layout, nx.spring_layout,
nx.spectral_layout)
titles = ("Random", "Circular", "Force-Directed", "Spectral")
for plot, layout, title in zip(subplots, layouts, titles):
pos = layout(G)
nx.draw_networkx(G, pos=pos, ax=plot, with_labels=False,
**dzcnapy.medium_attrs)
plot.set_title(title)
dzcnapy.set_extent(pos, plot)
dzcnapy.plot("nutrients")
from networkx.drawing.nx_agraph import graphviz_layout
_, plot = plt.subplots()
pos = graphviz_layout(G)
nx.draw_networkx(G, pos, **dzcnapy.attrs)
dzcnapy.set_extent(pos, plot)
dzcnapy.plot("nutrients-graphviz")
def slice_network(G, T, copy=True):
"""
Remove all edges with weight<T from G or its copy.
"""
F = G.copy() if copy else G
F.remove_edges_from(
(n1, n2) for n1, n2, w in F.edges(data="weight") if w < T)
return F
# Draw different degrees of slicing for a random graph
ergraph = nx.erdos_renyi_graph(100, 0.1)
nx.set_edge_attributes(ergraph, "weight", {(n1, n2): random.random()
for n1, n2 in ergraph.edges()})
pos = graphviz_layout(ergraph)
for i, threshold in enumerate([0, 0.7, 0.8, 0.9, 0.95, 1.0]):
ax = plt.subplot(3, 2, i + 1)
slice_network(ergraph, threshold, copy=False)
nx.draw_networkx_edges(ergraph,
pos,
alpha=0.65,
ax=ax,
**dzcnapy.small_attrs)
nx.draw_networkx_nodes(ergraph, pos, ax=ax, **dzcnapy.small_attrs)
dzcnapy.set_extent(pos, ax, "Threshold={}".format(threshold))
dzcnapy.plot("slicing")
return top_label_path.split(":")[-1]
mapping = {
comm_id: "{}/{}".format(top_cat_label(subgraph), comm_id)
for comm_id, subgraph in enumerate(subgraphs)
}
induced = nx.relabel_nodes(induced, mapping, copy=True)
attrs = {
"edge_color": "gray",
"font_size": 12,
"font_weight": "bold",
"node_size": 700,
"node_color": "pink",
"width": 2,
"font_family": "Liberation Sans Narrow"
}
# Calculate best node positions
pos = graphviz_layout(induced)
# Draw the network
nx.draw_networkx(induced, pos, **dzcnapy.attrs)
# Adjust the extents
dzcnapy.set_extent(pos, plt)
# Save and show
dzcnapy.plot("ProductNetwork")
}
sim_data = [pd.DataFrame([[func(att_mtx[e1], att_mtx[e2])
for e1 in att_mtx] for e2 in att_mtx],
columns=att_mtx.columns,
index=att_mtx.columns)
for func in sim_funcs.values()]
def simm2net(simm):
stacked = simm.stack()
sliced = stacked[stacked >= 0.7]
net = nx.from_pandas_dataframe(sliced.reset_index(),
"level_0", "level_1")
net.add_nodes_from(att_mtx.columns)
return net
networks = map(simm2net, sim_data)
pos = None
for i, (g, name) \
in enumerate(zip(networks, sim_funcs.keys())):
ax = plt.subplot(2, 2, i + 1)
if pos is None:
pos = graphviz_layout(g)
nx.draw_networkx_edges(g, pos, ax=ax, **dzcnapy.thick_attrs)
nx.draw_networkx_nodes(g, pos, ax=ax, **dzcnapy.attrs)
nx.draw_networkx_labels(g, pos, ax=ax, **dzcnapy.attrs)
dzcnapy.set_extent(pos, ax, name)
dzcnapy.plot("event_networks")
migrations = pd.read_csv("migration_2015.csv",
thousands=",").set_index("Unnamed: 0")
table_migrations = migrations.stack().reset_index()\
.sort_values(0, ascending=False)\
.groupby("Unnamed: 0").head(3)
table_migrations.columns = "From", "To", "weight"
G = nx.from_pandas_dataframe(table_migrations, "From", "To",
edge_attr=["weight"],
create_using=nx.DiGraph())
nx.relabel_nodes(G, pd.read_csv("states.csv", header=None)\
.set_index(0)[2].to_dict(), copy=False)
print(sorted(nx.weakly_connected_components(G), key=len, reverse=True))
print(sorted(nx.strongly_connected_components(G), key=len, reverse=True))
attracting = sorted(nx.attracting_components(G), key=len, reverse=True)[0]
print(attracting)
pos = graphviz_layout(G)
dzcnapy.attrs["node_color"] = ["palegreen" if n in attracting
else "pink" for n in G]
nx.draw_networkx_edges(G, pos, alpha=0.5, **dzcnapy.attrs)
nx.draw_networkx_nodes(G, pos, **dzcnapy.attrs)
nx.draw_networkx_labels(G, pos, **dzcnapy.attrs)
dzcnapy.set_extent(pos, plt)
dzcnapy.plot("migration", True)
G2 = nx.balanced_tree(2, 5)
G3 = nx.grid_2d_graph(5, 4)
names = ("Linear (path)", "Ring (Cycle)", "Balanced Tree", "Mesh (Grid)",
"Star", "Complete")
graphs = G0, G1, G2, G3, G4, G5
layouts = (graphviz_layout, ) * len(graphs)
for i, (g, name, layout) in enumerate(zip(graphs, names, layouts)):
ax = plt.subplot(3, 2, i + 1)
pos = layout(g)
nx.draw_networkx_edges(g, pos, alpha=0.5, ax=ax, **dzcnapy.small_attrs)
nx.draw_networkx_nodes(g, pos, ax=ax, **dzcnapy.small_attrs)
dzcnapy.set_extent(pos, ax, name)
dzcnapy.plot("synthetic3")
#Generate and draw random networks
G0 = nx.erdors_renyi_graph(50, 0.05)
G1 = nx.connected_watts_strogatz_graph(50, 4, 0.05)
G2 = nx.barabasi_albert_graph(50, 4)
G3 = nx.powerlaw_cluster_graph(50, 4, 0.05)
names = ("Erdos-Renvi (p=0.05)", "Watts-Strogatz (k=4, p=0.5)",
"Barabasi-Albert (k=4)", "Holme-Kim (k=4, p=0.5)")
graphs = G0, G1, G2, G3
layouts = (nx.circular_layout, nx.circular_layout, graphviz_layout,
graphviz_layout)
for i, (g, name, layout) in enumerate(zip(graphs, names, layouts)):
ax = plt.subplot(2, 2, i + 1)
ranks = pd.read_csv("Adjectives_by_the_rank.csv",
header=1).set_index("ResponseID").fillna(0)
Q1 = "Rank the words from the most positive to the most negative-"
ranks = ranks.loc[:, ranks.columns.str.startswith(Q1)].astype(int)
ranks.columns = ranks.columns.str.replace(Q1, "")
dominance = pd.DataFrame([[(ranks[j] > ranks[i]).sum()
for i in ranks] for j in ranks],
columns=ranks.columns, index=ranks.columns)
QUORUM = 115
edges = sorted(dominance[dominance >= QUORUM].stack().index.tolist())
G = nx.DiGraph(edges)
# Sort in the reverse order
print(nx.topological_sort(G)[::-1])
edge_dict = {n1: set(ns) for n1, ns in nx.to_dict_of_lists(G).items()}
topo_order = list(toposort.toposort(edge_dict))
print(topo_order)
pos = graphviz_layout(G)
nx.draw_networkx_edges(G, pos, alpha=0.5, **dzcnapy.attrs)
nx.draw_networkx_nodes(G, pos, **dzcnapy.attrs)
nx.draw_networkx_labels(G, pos, **dzcnapy.attrs)
dzcnapy.set_extent(pos, plt)
dzcnapy.plot("adjectives")
