social-network-analysis

name	social-network-analysis
description	Build, analyze, and visualize social networks with NetworkX: centrality, community detection, small-world metrics, bipartite networks, and Gephi export from edge lists or adjacency matrices.
tags	["sociology","network-analysis","networkx","community-detection","graph-theory","visualization"]
version	1.0.0
authors	[{"name":"awesome-rosetta-skills contributors","github":"@awesome-rosetta-skills"}]
license	MIT
platforms	["claude-code","codex","gemini-cli","cursor"]
dependencies	["networkx>=3.1.0","pandas>=2.0.0","numpy>=1.24.0","matplotlib>=3.7.0","python-louvain>=0.16","scipy>=1.10.0","requests>=2.31.0"]
last_updated	2026-03-17

Social Network Analysis with NetworkX

Overview

Social network analysis (SNA) treats actors (people, organizations, papers) as nodes and their relationships as edges. This skill covers the full pipeline from raw edge-list data to publication-ready network visualizations, covering:

• Building networks from edge lists and adjacency matrices
• Centrality measures (degree, betweenness, closeness, eigenvector, PageRank)
• Community detection (Louvain, Girvan-Newman)
• Small-world analysis
• Bipartite network projection
• Ego networks
• Export to Gephi (.gexf, .graphml)

---

Setup

pip install networkx pandas numpy matplotlib python-louvain scipy requests

For Louvain community detection the package is installed as python-louvain but imported as community. Verify with:

import community as community_louvain
print(community_louvain.__version__)

---

Core Functions

import os
import json
import itertools
import numpy as np
import pandas as pd
import networkx as nx
import matplotlib.pyplot as plt
import matplotlib.cm as cm
from collections import defaultdict
from typing import Any

# python-louvain
try:
    import community as community_louvain
    HAS_LOUVAIN = True
except ImportError:
    HAS_LOUVAIN = False
    ()







 () -> nx.Graph | nx.DiGraph:
    
    G = nx.DiGraph()  directed  nx.Graph()

     _, row  df.iterrows():
        w = (row[weight_col])  weight_col  weight_col  df.columns  
        G.add_edge(row[source_col], row[target_col], weight=w)

     node_attr_df   :
        attr_dict = node_attr_df.set_index(node_id_col).to_dict(orient=)
        nx.set_node_attributes(G, attr_dict)

    (
        
        
    )
     G


 () -> nx.Graph:
    
     (matrix, pd.DataFrame):
        node_labels = (matrix.index)
        matrix = matrix.values
     node_labels  :
        node_labels = [(i)  i  ((matrix))]

    G = nx.DiGraph()  directed  nx.Graph()
    G.add_nodes_from(node_labels)
    n = (node_labels)
     i  (n):
         j  (i +    directed  , n):
             directed  i == j:
                
            w = matrix[i, j]
             w > threshold:
                G.add_edge(node_labels[i], node_labels[j], weight=(w))
     G







 () -> pd.DataFrame:
    
    undirected = G.to_undirected()  G.is_directed()  G

    degree_c = (G.degree(weight=weight))
    degree_c_norm = {n: v / (G.number_of_nodes() - )  n, v  degree_c.items()}

    bet_c = nx.betweenness_centrality(G, weight=weight, normalized=, k=k_betweenness)
    close_c = nx.closeness_centrality(undirected)

    :
        eig_c = nx.eigenvector_centrality_numpy(undirected, weight=weight)
     nx.PowerIterationFailedConvergence:
        eig_c = {n: ()  n  G.nodes()}

    pr = nx.pagerank(G  G.is_directed()  undirected, weight=weight)

    records = []
     node  G.nodes():
        records.append({
            : node,
            : degree_c.get(node, ),
            : degree_c_norm.get(node, ),
            : bet_c.get(node, ),
            : close_c.get(node, ),
            : eig_c.get(node, ),
            : pr.get(node, ),
            **{k: v  k, v  G.nodes[node].items()},
        })

    df = pd.DataFrame(records).sort_values(, ascending=).reset_index(drop=)
     df







 () -> [, ]:
    
      HAS_LOUVAIN:
         ImportError()
    undirected = G.to_undirected()  G.is_directed()  G
    partition = community_louvain.best_partition(
        undirected,
        weight=weight,
        resolution=resolution,
        random_state=random_state,
    )
    nx.set_node_attributes(undirected, partition, )
    n_communities = ((partition.values()))
    modularity = community_louvain.modularity(partition, undirected, weight=weight)
    ()
     partition


 () -> []:
    
    comp = nx.community.girvan_newman(G)
     communities  itertools.islice(comp, n_communities - ):
        
    result = (communities, key=, reverse=)
    ()
     result







 () -> plt.Figure:
    
    layout_funcs = {
        :  g: nx.spring_layout(g, seed=seed, k= / np.sqrt(g.number_of_nodes())),
        : nx.circular_layout,
        : nx.kamada_kawai_layout,
        :  g: nx.random_layout(g, seed=seed),
    }
    pos = layout_funcs.get(layout, layout_funcs[])(G)

    
     node_color_attr  nx.get_node_attributes(G, node_color_attr):
        raw_colors = [G.nodes[n].get(node_color_attr, )  n  G.nodes()]
        unique_vals = ((raw_colors))
        palette = cm.get_cmap(, (unique_vals))
        color_map = {v: palette(i)  i, v  (unique_vals)}
        node_colors = [color_map[c]  c  raw_colors]
    :
        node_colors = [] * G.number_of_nodes()

    
     node_size_attr  nx.get_node_attributes(G, node_size_attr):
        sizes_raw = np.array([G.nodes[n].get(node_size_attr, )  n  G.nodes()], dtype=)
        sizes =  +  * (sizes_raw - sizes_raw.()) / (sizes_raw.ptp() + )
    :
        sizes = [] * G.number_of_nodes()

    fig, ax = plt.subplots(figsize=figsize)
    nx.draw_networkx_nodes(G, pos, node_color=node_colors, node_size=sizes, alpha=, ax=ax)
    nx.draw_networkx_edges(G, pos, alpha=, edge_color=, ax=ax, width=)

    
    top_nodes = (G.degree(), key= x: x[], reverse=)[: (, G.number_of_nodes())]
    labels = {n: (n)  n, _  top_nodes}
    nx.draw_networkx_labels(G, pos, labels=labels, font_size=, ax=ax)

    ax.set_title(title, fontsize=)
    ax.axis()
    fig.tight_layout()
     save_path:
        fig.savefig(save_path, dpi=, bbox_inches=)
     fig







 () -> :
    
    path = 
      == :
        nx.write_gexf(G, path)
      == :
        nx.write_graphml(G, path)
    :
         ValueError()
    ()







 () -> :
    
    
    lcc = G.subgraph((nx.connected_components(G), key=)).copy()
    n, m = lcc.number_of_nodes(), lcc.number_of_edges()
    p = m / (n * (n - ) / )

    C = nx.average_clustering(lcc, weight=)
    L = nx.average_shortest_path_length(lcc)

    rng = np.random.default_rng(seed)
    C_rand_list, L_rand_list = [], []
     s  rng.integers(, , n_random):
        G_rand = nx.erdos_renyi_graph(n, p, seed=(s))
        cc = nx.connected_components(G_rand)
        lcc_rand = G_rand.subgraph((cc, key=)).copy()
        C_rand_list.append(nx.average_clustering(lcc_rand))
        L_rand_list.append(nx.average_shortest_path_length(lcc_rand))

    C_rand = np.mean(C_rand_list)
    L_rand = np.mean(L_rand_list)

    sigma = (C / C_rand) / (L / L_rand)  

     {
        : n,
        : m,
        : C,
        : L,
        : C_rand,
        : L_rand,
        : sigma,
        : sigma > ,
    }