Exercises: Network and Graph Visualization

import networkx as nx
G = nx.Graph()
G.add_edges_from([("A", "B"), ("B", "C"), ("A", "C"), ("C", "D"), ("D", "E"), ("A", "E")])
print(G.number_of_nodes())  # 5
print(G.number_of_edges())  # 6

import networkx as nx
import matplotlib.pyplot as plt

G = nx.karate_club_graph()
nx.draw(G, with_labels=True, node_color="lightblue")
plt.show()

from networkx.algorithms.community import greedy_modularity_communities

G = nx.karate_club_graph()
pos = nx.spring_layout(G, seed=42)
communities = list(greedy_modularity_communities(G))

color_map = {}
for i, comm in enumerate(communities):
    for node in comm:
        color_map[node] = i

node_sizes = [G.degree(n) * 50 for n in G.nodes()]
node_colors = [color_map[n] for n in G.nodes()]

nx.draw(G, pos, node_size=node_sizes, node_color=node_colors, cmap="Set2",
        with_labels=True, edge_color="gray", alpha=0.7)

D = nx.DiGraph()
D.add_edges_from([("A", "B"), ("B", "C"), ("C", "A"), ("A", "D"), ("D", "E")])
pos = nx.spring_layout(D, seed=42)
nx.draw(D, pos, with_labels=True, node_color="lightcoral",
        arrows=True, arrowsize=20, edge_color="gray")

G = nx.karate_club_graph()
fig, axes = plt.subplots(1, 3, figsize=(18, 6))

for ax, layout_fn, name in zip(
    axes,
    [nx.spring_layout, nx.circular_layout, nx.shell_layout],
    ["Spring", "Circular", "Shell"],
):
    pos = layout_fn(G) if layout_fn is not nx.spring_layout else layout_fn(G, seed=42)
    nx.draw(G, pos, node_size=100, ax=ax, edge_color="gray", alpha=0.5)
    ax.set_title(name)

plt.show()

G = nx.karate_club_graph()
pos = nx.spring_layout(G, seed=42)
bet = nx.betweenness_centrality(G)
sizes = [bet[n] * 3000 + 100 for n in G.nodes()]

nx.draw(G, pos, node_size=sizes, with_labels=True, edge_color="gray")
plt.title("Karate Club — size ∝ betweenness centrality")

import plotly.graph_objects as go

G = nx.karate_club_graph()
pos = nx.spring_layout(G, seed=42)

edge_x, edge_y = [], []
for u, v in G.edges():
    edge_x.extend([pos[u][0], pos[v][0], None])
    edge_y.extend([pos[u][1], pos[v][1], None])

edge_trace = go.Scatter(x=edge_x, y=edge_y, mode="lines", line=dict(width=1, color="gray"))
node_trace = go.Scatter(
    x=[pos[n][0] for n in G.nodes()],
    y=[pos[n][1] for n in G.nodes()],
    mode="markers+text",
    text=[str(n) for n in G.nodes()],
    marker=dict(size=[G.degree(n) * 3 + 5 for n in G.nodes()], color="lightblue"),
)

fig = go.Figure([edge_trace, node_trace])
fig.update_layout(showlegend=False, xaxis_visible=False, yaxis_visible=False,
                  title="Karate Club — Interactive")
fig.show()

from pyvis.network import Network

G = nx.karate_club_graph()
net = Network(notebook=True, cdn_resources="in_line")
net.from_nx(G)
net.show("karate.html")

from networkx.algorithms.community import greedy_modularity_communities

G = nx.les_miserables_graph()
communities = list(greedy_modularity_communities(G))
print(f"Found {len(communities)} communities")

pos = nx.spring_layout(G, seed=42)
color_map = {}
for i, comm in enumerate(communities):
    for node in comm:
        color_map[node] = i

nx.draw(G, pos, node_color=[color_map[n] for n in G.nodes()], cmap="tab10",
        node_size=100, edge_color="gray", alpha=0.5, with_labels=False)

fig = go.Figure(go.Sankey(
    node=dict(label=["A", "B", "C", "D", "E", "F", "G"]),
    link=dict(
        source=[0, 1, 2, 3, 4, 3, 4],
        target=[3, 3, 4, 5, 5, 6, 6],
        value=[5, 3, 6, 8, 4, 2, 2],
    ),
))
fig.update_layout(title="3-Stage Flow")
fig.show()

import numpy as np
import seaborn as sns

G = nx.karate_club_graph()
communities = list(greedy_modularity_communities(G))
order = [node for comm in communities for node in sorted(comm)]
adj = nx.to_numpy_array(G, nodelist=order)

fig, ax = plt.subplots(figsize=(10, 10))
sns.heatmap(adj, xticklabels=order, yticklabels=order, cmap="Blues",
            square=True, cbar=False, ax=ax)
ax.set_title("Karate Club — Adjacency Matrix (ordered by community)")