leonardodalinky/scider/network-graph-analysis

import numpy as np
import networkx as nx
import scipy.sparse as sp
# Dense adjacency matrix
A = np.array([[0, 1, 0],
              [1, 0, 1],
              [0, 1, 0]])
G = nx.from_numpy_array(A)                          # undirected
G_directed = nx.from_numpy_array(A, create_using=nx.DiGraph())  # directed
# SciPy sparse matrix (memory-efficient for large graphs)
A_sparse = sp.csr_matrix(A)
G_sparse = nx.from_scipy_sparse_array(A_sparse)

import pandas as pd
# CSV with columns: source, target (and optionally weight)
edges_df = pd.read_csv('edges.csv')
# Unweighted, undirected
G = nx.from_pandas_edgelist(edges_df, source='source', target='target')
# Weighted, directed
G_weighted = nx.from_pandas_edgelist(
    edges_df,
    source='source',
    target='target',
    edge_attr='weight',
    create_using=nx.DiGraph()
)

from networkx.algorithms import bipartite
# Build bipartite graph
B = nx.Graph()
B.add_nodes_from(['u1', 'u2', 'u3'], bipartite=0)  # user nodes
B.add_nodes_from(['i1', 'i2'], bipartite=1)          # item nodes
B.add_edges_from([('u1','i1'), ('u2','i1'), ('u2','i2'), ('u3','i2')])
# Project onto one set (user-user co-occurrence)
user_nodes = {n for n, d in B.nodes(data=True) if d['bipartite'] == 0}
G_projected = bipartite.weighted_projected_graph(B, user_nodes)

G = nx.karate_club_graph()  # example
print(f"Nodes:               {G.number_of_nodes()}")
print(f"Edges:               {G.number_of_edges()}")
print(f"Density:             {nx.density(G):.4f}")         # edges / possible edges
degrees = [d for _, d in G.degree()]
print(f"Average degree:      {sum(degrees)/len(degrees):.2f}")
print(f"Max degree:          {max(degrees)}")
# Connected components
components = list(nx.connected_components(G))
print(f"Connected components: {len(components)}")
print(f"Largest component:   {max(len(c) for c in components)} nodes")
# Diameter (only valid for connected graphs)
if nx.is_connected(G):
    print(f"Diameter:            {nx.diameter(G)}")
else:
    # Diameter of largest component
    largest = G.subgraph(max(components, key=len))
    print(f"Diameter (LCC):      {nx.diameter(largest)}")
# Clustering coefficient
print(f"Global clustering:   {nx.transitivity(G):.4f}")
print(f"Avg local clustering:{nx.average_clustering(G):.4f}")

degree_cent = nx.degree_centrality(G)
# For weighted graphs, use strength (sum of weights)
strength = dict(G.degree(weight='weight'))
# Top 5 nodes by degree centrality
top_degree = sorted(degree_cent.items(), key=lambda x: x[1], reverse=True)[:5]
print("Top nodes by degree centrality:", top_degree)

# Exact
between_cent = nx.betweenness_centrality(G, normalized=True, weight='weight')
# Approximate for large graphs (sample k sources)
between_approx = nx.betweenness_centrality(G, k=200, normalized=True)
top_between = sorted(between_cent.items(), key=lambda x: x[1], reverse=True)[:5]
print("Top nodes by betweenness:", top_between)

closeness_cent = nx.closeness_centrality(G)
top_close = sorted(closeness_cent.items(), key=lambda x: x[1], reverse=True)[:5]
print("Top nodes by closeness:", top_close)

eigen_cent = nx.eigenvector_centrality(G, max_iter=1000, weight='weight')
# PageRank for directed graphs
pagerank = nx.pagerank(G, alpha=0.85, weight='weight')
top_eigen = sorted(eigen_cent.items(), key=lambda x: x[1], reverse=True)[:5]
print("Top nodes by eigenvector centrality:", top_eigen)

# Using python-louvain
import community as community_louvain
partition = community_louvain.best_partition(G, weight='weight', random_state=42)
modularity = community_louvain.modularity(partition, G)
num_communities = len(set(partition.values()))
print(f"Communities: {num_communities}, Modularity: {modularity:.4f}")
# Assign as node attribute
nx.set_node_attributes(G, partition, 'community')
# Using igraph (faster on very large graphs)
import igraph as ig
G_ig = ig.Graph.from_networkx(G)
louvain_result = G_ig.community_multilevel(weights='weight')
print(f"Modularity (igraph): {louvain_result.modularity:.4f}")

from networkx.algorithms.community import girvan_newman
comp = girvan_newman(G)
# Get partitions at different resolution levels
for communities in itertools.islice(comp, 3):
    print(f"k={len(communities)}: {[len(c) for c in communities]}")

from sklearn.cluster import SpectralClustering
import numpy as np
A = nx.to_numpy_array(G)
sc = SpectralClustering(
    n_clusters=5,
    affinity='precomputed',
    assign_labels='kmeans',
    random_state=42
)
labels = sc.fit_predict(A)

from networkx.algorithms.community import label_propagation_communities
communities = list(label_propagation_communities(G))
print(f"Found {len(communities)} communities")

# PyTorch Geometric (PyG) — most popular, extensive model zoo
from torch_geometric.data import Data
from torch_geometric.nn import GCNConv, GATConv, SAGEConv
import torch
data = Data(
    x=node_features,       # [num_nodes, num_features]
    edge_index=edge_index, # [2, num_edges] — COO format
    y=labels               # [num_nodes] for node classification
)
class GCN(torch.nn.Module):
    def __init__(self, in_channels, hidden, out_channels):
        super().__init__()
        self.conv1 = GCNConv(in_channels, hidden)
        self.conv2 = GCNConv(hidden, out_channels)
    def forward(self, data):
        x, edge_index = data.x, data.edge_index
        x = self.conv1(x, edge_index).relu()
        x = torch.nn.functional.dropout(x, p=0.5, training=self.training)
        x = self.conv2(x, edge_index)
        return x
# DGL — alternative with strong support for heterogeneous graphs
import dgl
g = dgl.from_networkx(G)

import matplotlib.pyplot as plt
import networkx as nx
fig, ax = plt.subplots(figsize=(12, 8))
# Layout algorithms
pos = nx.spring_layout(G, seed=42)           # force-directed — general purpose
# pos = nx.kamada_kawai_layout(G)            # minimizes edge crossings — slower but cleaner
# pos = nx.circular_layout(G)               # nodes on a circle — good for small n
# pos = nx.spectral_layout(G)               # based on graph Laplacian eigenvectors
# Color by community
communities = community_louvain.best_partition(G)
colors = [communities[n] for n in G.nodes()]
# Size by degree
sizes = [300 * nx.degree_centrality(G)[n] + 50 for n in G.nodes()]