Bio Applied Ppi Networks

PPI Network Construction and Analysis

When to Use

• Querying STRING DB for a gene/protein list and building an interaction network from the results.
• Ranking genes by centrality to nominate hub genes, essential proteins, or bottleneck drug targets.
• Testing whether a network follows the scale-free (power-law) topology expected of biological PPI networks.
• Detecting functional modules/communities in a PPI or co-expression network (Louvain, greedy modularity, WGCNA-style).
• Visualizing a gene network colored by function, module, or centrality.

Version Compatibility

• Python ≥ 3.10, networkx ≥ 3.2, pandas ≥ 2.0, requests ≥ 2.31
• Optional: python-louvain (community package) for true Louvain partitioning — networkx.community.greedy_modularity_communities works without it.
• STRING DB REST API v12 (https://string-db.org/api)

Prerequisites

• pip install networkx pandas requests matplotlib python-louvain
• Familiarity with graph concepts (nodes/edges, connected components) and basic pandas.

Goal: Fetch confidence-scored protein interactions for a gene list from STRING DB.

Approach: POST/GET gene identifiers to the STRING network endpoint, filter by combined_score, and load into a pandas.DataFrame.

import requests
import pandas as pd


def query_string_network(genes: list[str], species: int = 9606,
                           required_score: int = 400,
                           caller_identity: str = "my_app") -> pd.DataFrame:
    """Query STRING DB for interactions among a list of gene symbols.

    Args:
        genes: gene symbols, e.g. ["TP53", "MDM2", "BRCA1", "EGFR"]
        species: NCBI taxonomy ID (9606 = human)
        required_score: STRING combined_score threshold (0-999)
        caller_identity: required by STRING API to identify the calling app

    Returns:
        DataFrame with columns preferredName_A, preferredName_B, combined_score, ...
    """
    url = "https://string-db.org/api/json/network"
    params = {
        "identifiers": "%0d".join(genes),
        "species": species,
        "required_score": required_score,
        "caller_identity": caller_identity,
    }
    response = requests.get(url, params=params, timeout=30)
    response.raise_for_status()
    return pd.DataFrame(response.json())


# df = query_string_network(["TP53", "MDM2", "BRCA1", "EGFR", "MYC"])

STRING score channels: neighborhood, gene fusion, co-occurrence, coexpression, experimental, database, text mining. combined_score = 1 - prod(1 - individual_scores).

Goal: Build a NetworkX graph from a STRING edge list and compute centrality metrics to find hubs and bottlenecks.

Approach: Filter by confidence, restrict to the largest connected component, then compute degree/betweenness/closeness/eigenvector centrality and classify each gene's role.

import networkx as nx
import pandas as pd


def build_ppi_graph(df_edges: pd.DataFrame, score_col: str = "combined_score",
                     threshold: int = 400) -> nx.Graph:
    """Build an undirected PPI graph from a STRING-style edge DataFrame.

    Args:
        df_edges: columns preferredName_A/protein1, preferredName_B/protein2, score_col
        threshold: minimum combined_score to keep an edge (400 = medium confidence)

    Returns:
        Graph restricted to the largest connected component.
    """
    src, dst = df_edges.columns[0], df_edges.columns[1]
    df_filtered = df_edges[df_edges[score_col] >= threshold].copy()
    G = nx.from_pandas_edgelist(df_filtered, source=src, target=dst, edge_attr=score_col)
    largest_cc = max(nx.connected_components(G), key=len)
    return G.subgraph(largest_cc).copy()


def centrality_table(G: nx.Graph) -> pd.DataFrame:
    """Compute centrality metrics and classify each node as hub/bottleneck/peripheral."""
    degree = dict(G.degree())
    betweenness = nx.betweenness_centrality(G, normalized=True)
    closeness = nx.closeness_centrality(G)
    eigenvector = nx.eigenvector_centrality(G, max_iter=500, tol=1e-6)

    df = pd.DataFrame({
        "Gene": list(G.nodes()),
        "Degree": [degree[g] for g in G.nodes()],
        "Betweenness": [betweenness[g] for g in G.nodes()],
        "Closeness": [closeness[g] for g in G.nodes()],
        "Eigenvector": [eigenvector[g] for g in G.nodes()],
    }).sort_values("Degree", ascending=False)

    deg_thresh = df["Degree"].median()
    bet_thresh = df["Betweenness"].median()

    def classify(row):
        is_hub = row.Degree > deg_thresh
        is_bottleneck = row.Betweenness > bet_thresh
        if is_hub and is_bottleneck:
            return "hub+bottleneck"
        if is_hub:
            return "hub"
        if is_bottleneck:
            return "bottleneck"
        return "peripheral"

    df["role"] = df.apply(classify, axis=1)
    return df

Hub/bottleneck classification

             High betweenness    Low betweenness
High degree  Hub + bottleneck    Hub only
Low degree   Bottleneck only     Peripheral

PPI networks are expected to be scale-free, with degree distribution P(k) ~ k^-γ: most nodes have few connections while a few hubs (e.g. TP53, EGFR, MYC) have many. Verify by plotting the degree distribution on log-log axes — it should be roughly linear.

Goal: Partition a PPI network into functional modules/communities.

Approach: Use Louvain (python-louvain) if available, else fall back to NetworkX's greedy modularity maximization; report the modularity score Q.

import networkx as nx


def detect_communities(G: nx.Graph) -> tuple[dict, float]:
    """Partition graph nodes into communities and compute modularity Q.

    Returns:
        (partition, modularity) where partition maps node -> community id.
        Q > 0.3 indicates meaningful community structure; Q > 0.5 is strong.
    """
    try:
        import community as community_louvain
        partition = community_louvain.best_partition(G, random_state=42)
    except ImportError:
        communities = nx.community.greedy_modularity_communities(G)
        partition = {node: i for i, comm in enumerate(communities) for node in comm}

    n_communities = len(set(partition.values()))
    comm_sets = [{n for n, c in partition.items() if c == i} for i in range(n_communities)]
    modularity = nx.community.modularity(G, comm_sets)
    return partition, modularity

Pitfalls

• Always filter by confidence score before building the graph — unfiltered STRING data includes many low-confidence edges that inflate connectivity.
• Use the largest connected component for centrality metrics; isolated nodes and small components distort global statistics and can make eigenvector_centrality fail to converge.
• Directed vs undirected: use nx.DiGraph for regulatory networks (TF → target), nx.Graph for PPI/co-expression networks.
• Betweenness is O(V·E) — expensive on large graphs; use nx.betweenness_centrality(G, k=500) (sampling) for approximation on graphs with thousands of nodes.
• Modularity Q depends on resolution — communities found by Louvain are non-deterministic without random_state; always fix a seed for reproducibility.

See Also

• bio-applied-network-modules — deeper community detection (Louvain/Leiden, WGCNA eigengenes)
• bio-applied-gene-regulatory-networks — directed TF-target inference (GENIE3, ARACNE)
• network-biology — broader network biology overview including Cytoscape export and GO enrichment per module