Random Graphs and Network Models - Erdős-Rényi, Scale-Free, and Synthetic Data

Reading time: ~20 minutes | Level: Graph Theory → ML Engineering

You want to generate synthetic training data for your GNN. You want to stress-test your graph algorithm against adversarial inputs. You want to understand why your community detection algorithm works beautifully on citation networks but fails on social networks.

All of these require understanding what makes real-world graphs different from simple random graphs. Citation networks have power-law degree distributions: a few papers are cited thousands of times, most are cited once. Social networks have small-world structure: high clustering with short average path lengths. Understanding these models lets you generate realistic synthetic graphs and diagnose when your algorithms are solving the wrong problem.

What You Will Learn

• Erdős-Rényi model $G(n, p)$: the baseline random graph
• Properties: phase transitions, giant component, connectivity
• Barabási-Albert model: scale-free networks via preferential attachment
• Power-law degree distributions and why they are universal
• Watts-Strogatz model: small-world networks
• Stochastic Block Model (SBM): the canonical community structure model
• Generating synthetic graph data for GNN training and testing

Part 1 - The Erdős-Rényi Model G(n, p)

Definition

In $G(n, p)$, each of the $\binom{n}{2}$ possible edges exists independently with probability $p$.

import networkx as nx
import numpy as np
import matplotlib.pyplot as plt

def erdos_renyi_graph(n: int, p: float, seed: int = 42) -> nx.Graph:
    """Generate Erdős-Rényi random graph G(n, p)."""
    return nx.erdos_renyi_graph(n, p, seed=seed)

# Generate and analyze
n = 1000
for p in [0.001, 0.005, 0.01, 0.05]:
    G = erdos_renyi_graph(n, p)
    avg_degree = 2 * G.number_of_edges() / n
    components = nx.number_connected_components(G)
    largest_cc = max(nx.connected_components(G), key=len)

    print(f"p={p:.3f}: avg_deg={avg_degree:.2f}, "
          f"components={components}, "
          f"giant_cc_size={len(largest_cc)} ({100*len(largest_cc)/n:.1f}%)")

Phase transitions in G(n, p)

The critical threshold is $p^* = 1/n$ (average degree = 1).

Three regimes (as $n \to \infty$):

p < 1/n (subcritical): Graph is a collection of small trees
                        Largest component size = O(log n)

p = 1/n (critical):   Phase transition!
                        Largest component size = O(n^{2/3})

p > 1/n (supercritical): Giant connected component appears
                          Size = Θ(n) - constant fraction of all nodes

p > log(n)/n:           Graph becomes fully connected (a.a.s.)

import numpy as np
import networkx as nx

n = 1000
p_values = np.logspace(-4, -1, 50)  # p from 0.0001 to 0.1
giant_sizes = []

for p in p_values:
    G = nx.erdos_renyi_graph(n, p, seed=42)
    if nx.is_connected(G):
        giant_sizes.append(n)
    else:
        largest = max(nx.connected_components(G), key=len)
        giant_sizes.append(len(largest))

# Phase transition visible: giant component appears around p = 1/n = 0.001
critical_p = 1.0 / n
connectivity_p = np.log(n) / n
print(f"Critical p (phase transition): {critical_p:.4f}")
print(f"Full connectivity p: {connectivity_p:.4f}")

Degree distribution: Poisson (not power-law!)

In $G(n, p)$, the degree of each node follows approximately a Poisson distribution with mean $\mu = (n-1)p \approx np$:

$P(\deg(v) = k) \approx e^{-\mu} \frac{\mu^k}{k!}$

This is bell-shaped around the mean - very different from real-world graphs.

import numpy as np
from collections import Counter

n, p = 10000, 0.01  # Expected degree = 100
G = nx.erdos_renyi_graph(n, p, seed=42)
degrees = [d for _, d in G.degree()]

from scipy.stats import poisson
mu = (n-1) * p
expected_degrees = np.arange(max(degrees)+1)
expected_probs = poisson.pmf(expected_degrees, mu)

# Actual degree distribution should closely match Poisson(μ=100)
degree_counts = Counter(degrees)
actual_probs = [degree_counts.get(k, 0)/n for k in expected_degrees]

# Kolmogorov-Smirnov test: are they from the same distribution?
from scipy.stats import kstest
stat, p_val = kstest(degrees, 'poisson', args=(mu,))
print(f"KS test p-value: {p_val:.4f}")  # Should be large (not rejecting Poisson)

Why Erdős-Rényi does NOT model real networks

Real-world networks (social, citation, biological) have:

1. Heavy-tailed degree distributions (not Poisson): a few nodes with thousands of connections
2. High clustering: your friends are likely friends with each other
3. Community structure: dense subgroups with sparse connections between them

Erdős-Rényi has none of these properties. It is the null model - used to test whether an observed graph property is "surprising" given random structure.

Part 2 - Barabási-Albert Model: Scale-Free Networks

The preferential attachment mechanism

The Barabási-Albert (BA) model generates scale-free networks through growth with preferential attachment:

1. Start with a small initial graph
2. At each step: add a new node and connect it to $m$ existing nodes
3. Preferential attachment: node $v$ is chosen with probability $\propto \deg(v)$

"Rich get richer" - nodes with many connections attract more connections.

import networkx as nx
import numpy as np

# Generate Barabási-Albert graph
n = 5000
m = 3  # each new node connects to m existing nodes

G_ba = nx.barabasi_albert_graph(n, m, seed=42)

print(f"BA graph: {G_ba.number_of_nodes()} nodes, {G_ba.number_of_edges()} edges")
print(f"Average degree: {2*G_ba.number_of_edges()/n:.2f}")

# Degree distribution analysis
degrees = [d for _, d in G_ba.degree()]
max_degree = max(degrees)

print(f"Max degree (hub node): {max_degree}")
print(f"Mean degree: {np.mean(degrees):.2f}")
print(f"Degree std: {np.std(degrees):.2f}")

# Identify hubs
top_nodes = sorted(G_ba.degree(), key=lambda x: x[1], reverse=True)[:5]
print("\nTop 5 hub nodes:")
for node, deg in top_nodes:
    print(f"  Node {node}: degree {deg}")

Power-law degree distribution

The BA model produces a power-law (scale-free) degree distribution:

$P(\deg(v) = k) \propto k^{-\gamma}, \quad \gamma = 3$

In log-log scale, this is a straight line. Nodes with very high degree (hubs) are rare but exist - unlike the Poisson distribution which has exponentially thin tails.

import numpy as np
from scipy.stats import powerlaw

G_ba = nx.barabasi_albert_graph(5000, 3, seed=42)
degrees = [d for _, d in G_ba.degree()]

# Fit power law
from collections import Counter
degree_counts = Counter(degrees)
ks = np.array(sorted(degree_counts.keys()))
probs = np.array([degree_counts[k]/len(degrees) for k in ks])

# Log-log regression to estimate γ
log_k = np.log(ks[ks >= 3])  # Avoid log(0) and small-degree noise
log_p = np.log(probs[ks >= 3])

slope, intercept = np.polyfit(log_k, log_p, 1)
gamma_estimated = -slope
print(f"Estimated power-law exponent γ: {gamma_estimated:.2f}")  # Should be ~3

# Compare with Poisson (ER graph)
G_er = nx.erdos_renyi_graph(5000, 0.0012, seed=42)  # Same avg degree
er_degrees = [d for _, d in G_er.degree()]

print(f"\nBA graph: max_degree={max(degrees)}, std={np.std(degrees):.1f}")
print(f"ER graph: max_degree={max(er_degrees)}, std={np.std(er_degrees):.1f}")
# BA: heavy-tailed, much higher max and std

Hub resilience and fragility

Scale-free networks have a counter-intuitive property:

• Robust to random failures: most nodes have low degree - removing random nodes rarely disconnects the graph
• Fragile to targeted attacks: remove the top 5% high-degree hub nodes → graph shatters

import networkx as nx
import numpy as np

def simulate_attacks(G: nx.Graph, strategy: str, fraction: float = 0.1) -> int:
    """
    Simulate node removal and measure remaining giant component size.
    strategy: 'random' or 'targeted' (highest degree first)
    """
    G_copy = G.copy()
    n_remove = int(fraction * G.number_of_nodes())

    if strategy == 'random':
        nodes_to_remove = np.random.choice(list(G.nodes()), n_remove, replace=False)
    elif strategy == 'targeted':
        # Remove highest-degree nodes first
        nodes_to_remove = [n for n, d in sorted(G.degree(), key=lambda x: -x[1])][:n_remove]

    G_copy.remove_nodes_from(nodes_to_remove)

    if G_copy.number_of_nodes() == 0:
        return 0
    largest_cc = max(nx.connected_components(G_copy), key=len)
    return len(largest_cc)

G_ba = nx.barabasi_albert_graph(1000, 3, seed=42)
G_er = nx.erdos_renyi_graph(1000, 0.006, seed=42)  # Same edge count

for G, name in [(G_ba, "BA (scale-free)"), (G_er, "ER (random)")]:
    for strategy in ["random", "targeted"]:
        remaining = simulate_attacks(G, strategy, fraction=0.1)
        print(f"{name} + {strategy} attack: {remaining}/{G.number_of_nodes()} nodes remain in giant component")

Part 3 - Watts-Strogatz Model: Small-World Networks

Motivation: social networks are not random

Real social networks have two properties:

1. High clustering: your friends tend to know each other (transitivity)
2. Short average path length: "six degrees of separation"

Erdős-Rényi: low clustering, short paths (good) Regular lattice: high clustering, long paths (bad)

Watts-Strogatz bridges the two extremes.

The model

1. Start with a ring lattice: $n$ nodes, each connected to $k$ nearest neighbors
2. Rewire each edge with probability $\beta$: replace one endpoint with a random node

import networkx as nx
import numpy as np

n = 1000
k = 6      # nearest neighbors in initial lattice

for beta in [0, 0.01, 0.1, 1.0]:
    G = nx.watts_strogatz_graph(n, k, beta, seed=42)

    # Clustering coefficient: fraction of neighbor pairs that are connected
    avg_clustering = nx.average_clustering(G)

    # Average shortest path length (expensive for large graphs - sample)
    if nx.is_connected(G):
        avg_path = nx.average_shortest_path_length(G)
    else:
        # For disconnected graphs, use largest component
        lcc = G.subgraph(max(nx.connected_components(G), key=len))
        avg_path = nx.average_shortest_path_length(lcc)

    print(f"β={beta:.2f}: clustering={avg_clustering:.4f}, avg_path={avg_path:.2f}")

# β=0.0:  clustering=0.5 (high), avg_path=83.3 (long)  ← ring lattice
# β=0.01: clustering=0.5 (high), avg_path=12.4 (short) ← SMALL WORLD!
# β=1.0:  clustering=0.01 (low), avg_path=5.2 (short)  ← random (like ER)

Small-world ML applications

Node2Vec and DeepWalk exploit small-world structure: random walks on real-world graphs quickly reach many different parts of the graph (short paths), while maintaining local community structure (high clustering). This produces embeddings that capture both local and global structure.

Part 4 - Stochastic Block Model (SBM): Community Structure

The SBM is the canonical model for graphs with community structure - essential for evaluating community detection algorithms.

import networkx as nx
import numpy as np

def stochastic_block_model(n_per_block: list, p_in: float, p_out: float,
                            seed: int = 42) -> tuple:
    """
    Generate a stochastic block model graph.
    n_per_block: sizes of each community
    p_in: probability of edge within a community
    p_out: probability of edge between communities
    """
    np.random.seed(seed)
    n_blocks = len(n_per_block)
    n_total = sum(n_per_block)

    # Build probability matrix
    sizes = n_per_block
    probs = [[p_in if i == j else p_out
              for j in range(n_blocks)]
             for i in range(n_blocks)]

    G = nx.stochastic_block_model(sizes, probs, seed=seed)

    # True community labels
    labels = []
    for block_id, size in enumerate(n_per_block):
        labels.extend([block_id] * size)

    return G, np.array(labels)

# Generate SBM graph with 4 communities
G_sbm, true_labels = stochastic_block_model(
    n_per_block=[100, 100, 100, 100],
    p_in=0.3,     # 30% edge probability within community
    p_out=0.01    # 1% edge probability between communities
)

print(f"SBM graph: {G_sbm.number_of_nodes()} nodes, {G_sbm.number_of_edges()} edges")
print(f"True number of communities: {len(set(true_labels))}")

# Test community detection
from sklearn.metrics import adjusted_rand_score
import scipy.sparse as sp
from scipy.sparse.linalg import eigsh
from sklearn.cluster import KMeans

# Spectral clustering on SBM
L_sparse = sp.csr_matrix(nx.normalized_laplacian_matrix(G_sbm).astype(np.float64))
_, eigvecs = eigsh(L_sparse, k=4, which='SM')
kmeans = KMeans(n_clusters=4, n_init=10, random_state=42)
predicted_labels = kmeans.fit_predict(eigvecs)

ari = adjusted_rand_score(true_labels, predicted_labels)
print(f"Spectral clustering ARI: {ari:.4f}")  # Should be high (~0.9+)

# The SNR threshold for SBM detectability (Kesten-Stigum bound):
# Community detection is information-theoretically possible iff (p_in - p_out) > sqrt(c/n)
# where c = average degree
c = 2 * G_sbm.number_of_edges() / G_sbm.number_of_nodes()
kesten_stigum = np.sqrt(c / G_sbm.number_of_nodes())
signal = p_in - 0.01
print(f"\nKesten-Stigum threshold: {kesten_stigum:.4f}")
print(f"Actual signal (p_in - p_out): {signal:.4f}")
print(f"Above threshold (detectable): {signal > kesten_stigum}")

SBM for GNN benchmark generation

def generate_gnn_benchmark(
    n_nodes_per_class: int = 500,
    n_classes: int = 5,
    feature_dim: int = 32,
    p_in: float = 0.1,
    p_out: float = 0.005,
    feature_snr: float = 1.0   # Signal-to-noise ratio for node features
) -> dict:
    """
    Generate a synthetic GNN benchmark dataset.
    Combines SBM graph structure with noisy node features.
    Useful for controlled experiments.
    """
    import torch
    from torch_geometric.data import Data

    sizes = [n_nodes_per_class] * n_classes
    probs = [[p_in if i == j else p_out for j in range(n_classes)]
             for i in range(n_classes)]

    G, labels = stochastic_block_model(sizes, p_in, p_out)
    n_total = n_nodes_per_class * n_classes

    # Build edge_index
    edges = list(G.edges())
    src = [e[0] for e in edges]
    dst = [e[1] for e in edges]
    edge_index = torch.tensor([src + dst, dst + src], dtype=torch.long)

    # Node features: class-discriminative signal + noise
    class_centers = torch.randn(n_classes, feature_dim)
    x = class_centers[labels] * feature_snr + torch.randn(n_total, feature_dim)

    y = torch.tensor(labels, dtype=torch.long)

    return Data(x=x, edge_index=edge_index, y=y)

dataset = generate_gnn_benchmark(n_nodes_per_class=200, n_classes=5)
print(f"Benchmark graph: {dataset.num_nodes} nodes, {dataset.num_edges} edges")
print(f"Node feature dim: {dataset.x.shape[1]}")
print(f"Classes: {dataset.y.unique()}")

Part 5 - Degree Distribution Analysis for Real Graphs

import numpy as np
import networkx as nx
from collections import Counter

def analyze_degree_distribution(G: nx.Graph, name: str) -> dict:
    """
    Comprehensive degree distribution analysis.
    Returns statistics useful for graph characterization.
    """
    degrees = [d for _, d in G.degree()]
    n = G.number_of_nodes()
    m = G.number_of_edges()

    # Basic statistics
    stats = {
        'n': n, 'm': m,
        'avg_degree': 2*m/n,
        'max_degree': max(degrees),
        'min_degree': min(degrees),
        'degree_std': np.std(degrees),
        'clustering': nx.average_clustering(G),
    }

    # Check for power law: fit to log-log
    degree_counts = Counter(degrees)
    ks = np.array([k for k in degree_counts if k >= 3])
    probs = np.array([degree_counts[k]/n for k in ks])

    if len(ks) > 5:
        log_k = np.log(ks)
        log_p = np.log(probs)
        slope, _ = np.polyfit(log_k, log_p, 1)
        stats['power_law_exponent'] = -slope

        # Gini coefficient of degrees (inequality measure)
        sorted_d = np.sort(degrees)
        cumsum = np.cumsum(sorted_d)
        gini = 1 - 2 * cumsum[-1] * n / (cumsum.sum() * 2) if cumsum[-1] > 0 else 0
        stats['gini_coefficient'] = gini

    print(f"\n{name}:")
    for k, v in stats.items():
        print(f"  {k}: {v:.4f}" if isinstance(v, float) else f"  {k}: {v}")

    return stats

# Compare models
G_er = nx.erdos_renyi_graph(1000, 0.01, seed=42)
G_ba = nx.barabasi_albert_graph(1000, 5, seed=42)
G_ws = nx.watts_strogatz_graph(1000, 10, 0.1, seed=42)

analyze_degree_distribution(G_er, "Erdős-Rényi G(1000, 0.01)")
analyze_degree_distribution(G_ba, "Barabási-Albert (m=5)")
analyze_degree_distribution(G_ws, "Watts-Strogatz (k=10, β=0.1)")

Interview Questions

Q1: What is the phase transition in Erdős-Rényi graphs and what does it mean for ML?

In $G(n, p)$, as $p$ increases from 0 to 1, the graph undergoes a sharp phase transition at $p^* = 1/n$ (average degree = 1):

• Below critical ($p < 1/n$, avg degree $< 1$): Graph consists of isolated small components (mostly trees). Largest component has $O(\log n)$ nodes.
• At critical ($p = 1/n$): Largest component has $O(n^{2/3})$ nodes - a critical percolation state.
• Above critical ($p > 1/n$): A giant connected component appears, containing $\Theta(n)$ nodes. The fraction of nodes in the giant component grows continuously above the threshold.

ML relevance:

1. GNN reachability: If the graph is subcritical (sparse ER), most node pairs are unreachable from each other - $k$-hop GNN neighborhoods are tiny. Effective GNN depth is limited by the component structure.

2. Percolation and robustness: The phase transition models how networks degrade under node/edge removal. Understanding the threshold helps design robust communication or supply chain networks.

3. Null hypothesis testing: When evaluating whether a real graph property is "significant," compare against $G(n, p)$ with the same $n$ and edge density. Properties that appear in both ER and the real graph are likely not meaningful structure.

4. Connectivity threshold: Full connectivity requires $p > \ln(n)/n$. For $n = 10000$, this is $p \approx 0.00092$. Below this, even supercritical ER graphs have isolated nodes - important for algorithms that assume connectivity.

Q2: What is preferential attachment and why does it produce power-law degree distributions?

Preferential attachment: When a new node is added to the graph, it connects to existing nodes with probability proportional to their current degree - "rich get richer."

Why power-law results:

The growth equation for the expected degree of node $i$ over time: $\frac{d\langle k_i \rangle}{dt} = m \cdot \frac{\langle k_i \rangle}{\sum_j \langle k_j \rangle} = m \cdot \frac{\langle k_i \rangle}{2mt_{\text{current}}} = \frac{\langle k_i \rangle}{2t}$

Solution: $\langle k_i(t) \rangle = m \sqrt{t/t_i}$ where $t_i$ is the time node $i$ was added.

The probability that a node has degree $\geq k$ at time $t$: $P(\langle k_i(t) \rangle \geq k) = P\left(t_i \leq \frac{m^2 t}{k^2}\right) = \frac{m^2}{k^2}$

Differentiating: $P(k) \propto k^{-3}$ - a power law with exponent $\gamma = 3$.

Why power laws appear in real networks: Many real-world networks grew through a similar "rich get richer" process:

• Web pages: well-linked pages attract more links
• Scientific citations: well-cited papers attract more citations
• Social networks: popular users attract more followers

ML implications: Power-law degree distributions mean GNN training is dominated by hub nodes (high degree, many neighbors). Mini-batch GNN training with neighborhood sampling is biased toward these hubs. Techniques like degree-inversely-weighted sampling correct for this.

Q3: What is the Stochastic Block Model and why is it the benchmark for GNN node classification?

The Stochastic Block Model (SBM) partitions $n$ nodes into $k$ communities of sizes $n_1, \ldots, n_k$. Edges are placed independently:

• Between nodes in the same community: with probability $p_{in}$
• Between nodes in different communities: with probability $p_{out} < p_{in}$

$P(\text{edge between } u, v) = \begin{cases} p_{in} & \text{if same community} \\ p_{out} & \text{otherwise} \end{cases}$

Why it's the standard GNN benchmark:

1. Ground truth communities: Unlike real datasets (where true labels might not align with graph structure), SBM provides labels that are exactly aligned with graph topology by construction.

2. Controllable difficulty: Increasing $p_{out}/p_{in}$ makes communities less distinguishable. This allows systematic study of when GNNs succeed and fail.

3. Kesten-Stigum threshold: There is an information-theoretic threshold below which no algorithm can recover communities better than chance: $\frac{(p_{in} - p_{out})^2}{\bar{d}} > \frac{1}{n}$ where $\bar{d}$ is average degree. GNNs should perform above this threshold but often fail even when it is satisfied.

4. Controlled experiments: You can isolate the effect of: graph signal (structure) vs node feature signal, homophily ratio, class imbalance - each controlled by SBM parameters.

Beyond SBM: Real citation networks (Cora, CiteSeer) have homophily - nodes of the same class tend to connect - which mirrors SBM structure. But real graphs also have degree heterogeneity, which SBM with fixed $p_{in}/p_{out}$ does not capture. The Degree-Corrected SBM extends SBM to allow hub nodes within communities.

Q4: What distinguishes small-world networks from random and regular graphs?

Property	Regular lattice	Small-world (WS)	Erdős-Rényi
Clustering coefficient $C$	High ($\approx 0.5$)	High ($\approx 0.5$)	Low ($\approx p \approx 0$)
Average path length $L$	Long ($O(n)$)	Short ($O(\log n)$)	Short ($O(\log n)$)
Degree distribution	Regular (all same)	Peaked	Poisson

Small-world networks have both high clustering and short paths - the combination that matches real social networks.

Watts-Strogatz mechanism: Start with a ring lattice (high clustering, long paths). Rewiring a small fraction $\beta \approx 0.01$ of edges creates "shortcuts" that dramatically reduce path lengths without destroying the local clustering structure.

Real-world small-world networks:

• Social networks: 6 degrees of separation, high friend-of-friend transitivity
• Neural networks (brain): local cortical circuits + long-range projections
• Power grids: local substations + interstate transmission lines

ML implications:

• Random walk mixing time is $O(\log n)$ in small-world networks - Node2Vec/DeepWalk converge quickly to meaningful embeddings
• GNN receptive field grows quickly: 2-3 layers may see most of the relevant neighborhood
• Over-smoothing risk is higher in small-world graphs than in tree-like or sparse ER graphs

Q5: How would you generate realistic synthetic graph data for GNN training?

Strategy: Match the structural properties of your target domain.

Step 1: Profile the real graph

stats = {
    'n': n, 'm': m,
    'avg_degree': 2*m/n,
    'clustering': nx.average_clustering(G),
    'power_law_exponent': fit_power_law(G),  # ~3 for BA-like
    'n_communities': detect_communities(G),
    'homophily': compute_homophily(G, labels)
}

Step 2: Choose the appropriate generative model

Real graph type	Recommended model	Why
Citation/academic	SBM + node features	Community structure, homophily
Social network	BA + WS rewiring	Scale-free + clustering
Molecular	Random chemical graphs	Valence constraints
Sparse random	ER	Null model

Step 3: Add node features

# Homophilic node features: same-class nodes have similar features
class_centers = torch.randn(n_classes, feature_dim)
noise_level = 0.5 / homophily  # Higher homophily → less noise needed
x = class_centers[labels] + noise_level * torch.randn(n, feature_dim)

Step 4: Validate the synthetic graph

# Check that synthetic graph matches real graph's properties
def validate_synthetic(G_real, G_synthetic):
    checks = {
        'degree_distribution_ks': compare_distributions(G_real.degrees, G_synthetic.degrees),
        'clustering_match': abs(nx.average_clustering(G_real) - nx.average_clustering(G_synthetic)) < 0.05,
        'path_length_match': similar_path_lengths(G_real, G_synthetic),
        'community_structure': similar_community_detection(G_real, G_synthetic)
    }
    return checks

Quick Reference

Model	Mechanism	Degree Dist	Clustering	Paths
Erdős-Rényi G(n,p)	Random edges	Poisson	Low	Short
Barabási-Albert	Preferential attachment	Power law γ≈3	Low-med	Short
Watts-Strogatz	Rewired lattice	Peaked	High	Short
Stochastic Block Model	Block connectivity	Varies	Varies	Varies
Random Regular Graph	All nodes same degree	Delta function	Low	Short

Next: Lesson 06: Graph Theory for GNNs →

:::tip 🎮 Interactive Playground

Visualize this concept: Try the Random Graphs demo on the EngineersOfAI Playground - no code required.

:::