/network-analysis

name: Network Analysis
description: Analyze network structures, identify communities, measure centrality, and visualize relationships for social networks and organizational structures

Network Analysis

Overview

This skill enables analysis of network structures to identify communities, measure centrality, detect influential nodes, and visualize complex relationships in social networks, organizational structures, and interconnected systems.

When to Use

• Analyzing social networks to identify influential users and community structures
• Mapping organizational hierarchies and identifying key connectors or bottlenecks
• Studying citation networks to find impactful research papers and collaboration patterns
• Building recommendation systems based on network relationships and similarities
• Analyzing supply chain networks to optimize logistics and identify vulnerabilities
• Detecting fraud patterns through network analysis of financial transactions

Network Concepts

• **Nodes**: Individual entities
• **Edges**: Connections/relationships
• **Degree**: Number of connections
• **Centrality**: Node importance measures
• **Community**: Densely connected groups
• **Clustering Coefficient**: Local density

Key Metrics

• **Degree Centrality**: Number of connections
• **Betweenness Centrality**: Control over paths
• **Closeness Centrality**: Average distance to others
• **Eigenvector Centrality**: Connections to important nodes
• **Modularity**: Community structure strength

Implementation with Python

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import networkx as nx
from collections import defaultdict, Counter
import seaborn as sns

# Create sample network (social network)
G = nx.Graph()

# Add nodes with attributes
nodes = [
    ('Alice', {'role': 'Manager', 'dept': 'Sales'}),
    ('Bob', {'role': 'Engineer', 'dept': 'Tech'}),
    ('Carol', {'role': 'Designer', 'dept': 'Design'}),
    ('David', {'role': 'Engineer', 'dept': 'Tech'}),
    ('Eve', {'role': 'Analyst', 'dept': 'Sales'}),
    ('Frank', {'role': 'Manager', 'dept': 'HR'}),
    ('Grace', {'role': 'Designer', 'dept': 'Design'}),
    ('Henry', {'role': 'Engineer', 'dept': 'Tech'}),
    ('Iris', {'role': 'Analyst', 'dept': 'Sales'}),
    ('Jack', {'role': 'Manager', 'dept': 'Finance'}),
]

for node, attrs in nodes:
    G.add_node(node, **attrs)

# Add edges (relationships)
edges = [
    ('Alice', 'Bob'), ('Alice', 'Carol'), ('Alice', 'Eve'),
    ('Bob', 'David'), ('Bob', 'Henry'), ('Carol', 'Grace'),
    ('David', 'Henry'), ('Eve', 'Iris'), ('Frank', 'Jack'),
    ('Grace', 'Carol'), ('Alice', 'Frank'), ('Bob', 'Carol'),
    ('Eve', 'Alice'), ('Iris', 'Eve'), ('Jack', 'Frank'),
    ('Henry', 'David'), ('Carol', 'David'),
]

G.add_edges_from(edges)

print("Network Summary:")
print(f"Nodes: {G.number_of_nodes()}")
print(f"Edges: {G.number_of_edges()}")
print(f"Density: {nx.density(G):.2%}")

# 1. Degree Centrality
degree_centrality = nx.degree_centrality(G)
print("\n1. Degree Centrality (Top 5):")
for node, score in sorted(degree_centrality.items(), key=lambda x: x[1], reverse=True)[:5]:
    print(f"  {node}: {score:.3f}")

# 2. Betweenness Centrality (control over network)
betweenness_centrality = nx.betweenness_centrality(G)
print("\n2. Betweenness Centrality (Top 5):")
for node, score in sorted(betweenness_centrality.items(), key=lambda x: x[1], reverse=True)[:5]:
    print(f"  {node}: {score:.3f}")

# 3. Closeness Centrality (average distance to others)
closeness_centrality = nx.closeness_centrality(G)
print("\n3. Closeness Centrality (Top 5):")
for node, score in sorted(closeness_centrality.items(), key=lambda x: x[1], reverse=True)[:5]:
    print(f"  {node}: {score:.3f}")

# 4. Eigenvector Centrality
try:
    eigenvector_centrality = nx.eigenvector_centrality(G, max_iter=100)
    print("\n4. Eigenvector Centrality (Top 5):")
    for node, score in sorted(eigenvector_centrality.items(), key=lambda x: x[1], reverse=True)[:5]:
        print(f"  {node}: {score:.3f}")
except:
    print("\n4. Eigenvector Centrality: Not converged")

# 5. Community Detection (using modularity)
from networkx.algorithms import community

communities = list(community.greedy_modularity_communities(G))
print(f"\n5. Community Detection:")
print(f"Number of communities: {len(communities)}")
for i, comm in enumerate(communities):
    print(f"  Community {i+1}: {list(comm)}")

# 6. Network Statistics
degrees = [G.degree(n) for n in G.nodes()]
print(f"\n6. Network Statistics:")
print(f"Average Degree: {np.mean(degrees):.2f}")
print(f"Max Degree: {max(degrees)}")
print(f"Min Degree: {min(degrees)}")
print(f"Clustering Coefficient: {nx.average_clustering(G):.3f}")
print(f"Number of Triangles: {sum(nx.triangles(G).values()) // 3}")

# Visualization
fig, axes = plt.subplots(2, 2, figsize=(15, 12))

# Network layout
pos = nx.spring_layout(G, k=0.5, iterations=50, seed=42)

# 1. Network Graph (colored by degree)
ax = axes[0, 0]
node_colors = [degree_centrality[node] for node in G.nodes()]
nx.draw_networkx_nodes(G, pos, node_color=node_colors, node_size=1000, cmap='YlOrRd', ax=ax)
nx.draw_networkx_edges(G, pos, alpha=0.5, ax=ax)
nx.draw_networkx_labels(G, pos, font_size=8, ax=ax)
ax.set_title('Network Graph (Colored by Degree Centrality)')
ax.axis('off')

# 2. Network Graph (colored by communities)
ax = axes[0, 1]
color_map = []
colors = plt.cm.Set3(np.linspace(0, 1, len(communities)))
node_to_color = {}
for i, comm in enumerate(communities):
    for node in comm:
        node_to_color[node] = colors[i]
color_map = [node_to_color[node] for node in G.nodes()]

nx.draw_networkx_nodes(G, pos, node_color=color_map, node_size=1000, ax=ax)
nx.draw_networkx_edges(G, pos, alpha=0.5, ax=ax)
nx.draw_networkx_labels(G, pos, font_size=8, ax=ax)
ax.set_title('Network Graph (Colored by Community)')
ax.axis('off')

# 3. Centrality Comparison
ax = axes[1, 0]
centrality_df = pd.DataFrame({
    'Degree': degree_centrality,
    'Betwee