netcoloc 1.0.0__py3-none-any.whl

netcoloc/__init__.py

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+
+__author__ = 'Brin Rosenthal, Sophie Liu, Sarah Wright'
+__email__ = 'sbrosenthal@health.ucsd.edu, sol015@ucsd.edu, snwright@ucsd.edu'
+__version__ = '1.0.0'

netcoloc/cli.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+
+import click
+
+from .netprop_zscore import *
+
+
+@click.command(context_settings={"ignore_unknown_options": True})
+@click.argument('seed-gene-file', type=click.Path(exists=True, resolve_path=True))
+@click.option('--seed-gene-file-delimiter')
+@click.option('--num-reps', default=10, type=int)
+@click.option('--alpha', '-a', default=0.5, type=float)
+@click.option('--minimum-bin-size', default=10, type=int)
+@click.option('--interactome-file')
+@click.option('--interactome-uuid', default='f93f402c-86d4-11e7-a10d-0ac135e8bacf', type=click.UUID)
+@click.option('--ndex-server', default='ndexbio.org')
+@click.option('--ndex-user')
+@click.option('--ndex-password')
+@click.option('--out-name', default='out')
+@click.option('--save-z-scores/--no-save-z-scores', default=True)
+@click.option('--save-final-heat/--no-save-final-heat', default=False)
+@click.option('--save-random-final-heats/--no-save-random-final-heats', default=False)
+def main(seed_gene_file, seed_gene_file_delimiter, num_reps, alpha,
+         minimum_bin_size, interactome_file,
+         interactome_uuid, ndex_server, ndex_user, ndex_password,
+         out_name, save_z_scores, save_final_heat, save_random_final_heats):
+    """
+
+    :param seed_gene_file:
+    :param seed_gene_file_delimiter:
+    :param num_reps:
+    :param alpha:
+    :param minimum_bin_size:
+    :param interactome_file:
+    :param interactome_uuid:
+    :param ndex_server:
+    :param ndex_user:
+    :param ndex_password:
+    :param out_name:
+    :param save_z_scores:
+    :param save_final_heat:
+    :param save_random_final_heats:
+    :return:
+    """
+    netprop_zscore(seed_gene_file, seed_gene_file_delimiter=seed_gene_file_delimiter,
+                   num_reps=num_reps, alpha=alpha, minimum_bin_size=minimum_bin_size,
+                   interactome_file=interactome_file, interactome_uuid=str(interactome_uuid),
+                   ndex_server=ndex_server, ndex_user=ndex_user, ndex_password=ndex_password,
+                   out_name=out_name, save_z_scores=save_z_scores,
+                   save_final_heat=save_final_heat,
+                   save_random_final_heats=save_random_final_heats)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

netcoloc/netcoloc_utils.py

@@ -0,0 +1,87 @@
+# -*- coding: utf-8 -*-
+
+'''Utility functions useful across multiple modules.
+'''
+
+import warnings
+
+
+def get_degree_binning(node_to_degree_dict, min_bin_size, lengths=None):
+    """
+    Groups nodes by degree into similarly sized bins. This function
+    comes from
+    `network_utilities.py of emreg00/toolbox <https://github.com/emreg00/toolbox/blob/master/network_utilities.py>`__
+
+
+    Returns a tuple with following two values:
+
+    * **list of bins** where each bin contains a list of nodes of similar degree
+    * **mapping of degree to index of bin** dict mapping a degree to the index
+      of the bin in the bins list which contains nodes of that degree
+
+    :param node_to_degree_dict: Map of nodes to their degrees
+    :type node_to_degree_dict: dict
+    :param min_bin_size: minimum number of nodes each bin should contain.
+    :type min_bin_size: int
+    :param lengths: List of nodes to bin. If lengths is equal to None, then
+                    all nodes will be binned
+    :type lengths: list
+    :return: (list of bins, mapping of degree to index of bin)
+    :rtype: tuple
+    """
+    # Create dictionary mapping degrees to nodes
+    assert min_bin_size <= len(node_to_degree_dict), f'Minimum bin size must be less than number of nodes {len(node_to_degree_dict)}'
+
+    if lengths is not None:
+        if len(lengths) == 0:
+            warnings.warn("Lengths is empty. Returning empty bins and degree to bin index dictionary.")
+            return [], {}
+        missing_nodes = [x for x in lengths if x not in node_to_degree_dict]
+        if len(missing_nodes) > 0:
+            warnings.warn(f"The following nodes are not in the degree dictionary: {missing_nodes}")
+
+    degree_to_nodes = {}
+    for node, degree in node_to_degree_dict.items():
+        if lengths is not None and node not in lengths:
+            continue
+        degree_to_nodes.setdefault(degree, []).append(node)    
+    
+    # Get sorted list of degrees
+    degrees = degree_to_nodes.keys()
+    degrees = list(degrees)
+    degrees.sort()
+    
+    bins = []
+    bins_boundaries = []
+    degree_to_bin_index = {}
+
+    degree_index = 0
+    while degree_index < len(degrees):
+        # Add nodes of each degree to bin until bin reaches minimum bin size
+        low = degrees[degree_index]
+        nodes_of_certain_degree = degree_to_nodes[low]
+        while len(nodes_of_certain_degree) < min_bin_size:
+            degree_index += 1
+            if degree_index == len(degrees):
+                degree_index -= 1
+                break
+            nodes_of_certain_degree.extend(degree_to_nodes[degrees[degree_index]])
+
+        high = degrees[degree_index]
+        if len(nodes_of_certain_degree) >= min_bin_size:
+            # For each degree represented in bin, set degree to bin index
+            for deg in range(low, high + 1):
+                degree_to_bin_index[deg] = len(bins)
+            bins.append(nodes_of_certain_degree)
+            bins_boundaries.append((low, high))
+        else:
+            # Combine last bin with second last bin, if last bin is too small
+            bins[-1].extend(nodes_of_certain_degree)
+            low_of_previous_bin, high_of_previous_bin = bins_boundaries[-1]
+            bins_boundaries[-1] = (low_of_previous_bin, high)
+            for deg in range(high_of_previous_bin + 1, high + 1):
+                degree_to_bin_index[deg] = len(bins) - 1
+            
+        degree_index += 1 
+
+    return bins, degree_to_bin_index

netcoloc/netprop.py

@@ -0,0 +1,214 @@
+# -*- coding: utf-8 -*-
+
+'''Functions for performing network propagation
+'''
+
+import networkx as nx
+import numpy as np
+import pandas as pd
+import warnings
+
+
+def get_normalized_adjacency_matrix(graph, conserve_heat=True, weighted=False):
+    """
+    Returns normalized adjacency matrix (W'), as detailed in:
+
+    Vanunu, Oron, et al. 'Associating genes and protein complexes with disease
+    via network propagation.'
+
+
+    With version `0.1.6` and newer, the :py:class:`networkx.Graph`
+    can be directly passed into
+    :py:func:`~netcoloc.netprop.get_individual_heats_matrix` and
+    this method will be invoked to create the normalized adjacency matrix
+
+    .. note::
+        Resulting matrix from this function can be saved to a file with :py:func:`numpy.save`
+        and loaded later with :py:func:`numpy.load`, but resulting file can be several gigabytes
+        and take a minute or more to save/load.
+
+        .. code-block:: python
+
+            numpy.save('nam.npy', adjacency_matrix)
+            adjacency_matrix = numpy.load('nam.npy')
+
+
+    :param graph: Interactome from which to calculate normalized
+            adjacency matrix.
+    :type graph: :py:class:`networkx.Graph`
+    :param conserve_heat: If ``True``, heat will be conserved
+            (ie. the sum of the heat vector will be equal to 1),
+            and the graph will be asymmetric. Otherwise, heat will
+            not be conserved, and the graph will be symmetric.
+    :type conserve_heat: bool
+    :param weighted: If ``True``, then the graph's edge weights
+            will be taken into account. Otherwise, all edge weights
+            will be set to 1.
+    :type weighted: bool
+    :return: Square normalized adjacency matrix
+    :rtype: :py:class:`numpy.ndarray`
+    """
+    if isinstance(graph, np.ndarray):
+        graph = nx.from_numpy_array(graph)
+    
+    if isinstance(graph, nx.DiGraph) or isinstance(graph, nx.MultiGraph) or isinstance(graph, nx.MultiDiGraph):
+        raise ValueError("Input graph must be a networkx.Graph object. Directed and MultiGraphs are not supported.")
+    
+    
+    assert 0 not in dict(graph.degree).values(), "Graph cannot have nodes with degree=zero"
+    # assert graph is nx.Graph object
+
+    # Create graph
+    if conserve_heat:
+        # If conserving heat, make G_weighted a di-graph (not symmetric)
+        graph_weighted = nx.DiGraph()
+    else:
+        # If not conserving heat, make G_weighted a simple graph (symmetric)
+        graph_weighted = nx.Graph()
+
+    # Create edge weights
+    edge_weights = []
+    node_to_degree_dict = dict(graph.degree)
+    if weighted and not nx.is_weighted(G=graph):
+        warnings.warn("Input graph is not weighted. All edge weights will be set to 1.")
+
+    for e in graph.edges(data=True):
+        v1 = e[0]
+        v2 = e[1]
+        deg1 = node_to_degree_dict[v1]
+        deg2 = node_to_degree_dict[v2]
+
+        if weighted and nx.is_weighted(G=graph):
+            weight = e[2]['weight']
+        else:
+            weight = 1
+
+        if conserve_heat:
+            # created asymmetrically weighted edges - each directed edge u->v normalized by the degree of v
+            edge_weights.append((v1, v2, weight / float(deg1)))
+            edge_weights.append((v2, v1, weight / float(deg2)))
+        else:
+            # normalize single undirected edge by the degree of both endpoints as per Vanunu, Oron, et al. 2010
+            edge_weights.append((v1, v2, weight / np.sqrt(deg1 * deg2)))
+
+    # Apply edge weights to graph
+    graph_weighted.add_weighted_edges_from(edge_weights)
+
+    # Transform graph to adjacency array
+    if len(graph.nodes) != len(graph_weighted):
+        raise ValueError("Input graph has nodes with zero degrees. Please remove these nodes.")
+
+    w_prime = nx.to_numpy_array(graph_weighted, nodelist=graph.nodes())
+
+    return w_prime
+
+
+def get_individual_heats_matrix(nam_or_graph, alpha=0.5,
+                                conserve_heat=True, weighted=False):
+    """
+    Returns the pre-calculated contributions of each individual gene in the
+    interactome to the final heat of each other gene in the interactome after
+    propagation.
+
+    .. versionchanged:: 0.1.6
+        In addition, to a normalized adjacency matrix, this function
+        now also supports :py:class:`networkx.Graph` network as input
+
+
+    If a :py:class:`networkx.Graph` network is passed in as the **nam_or_graph**
+    parameter, the function :py:func:`~netcoloc.netprop.get_normalized_adjacency_matrix`
+    is called to generate the normalized adjacency matrix using **conserve_heat** and
+    **weighted** parameters
+
+    .. note::
+        Resulting matrix from this function can be saved to a file with :py:func:`numpy.save`
+        and loaded later with :py:func:`numpy.load`, but resulting file can be several gigabytes
+        and take a minute or more to save/load.
+
+        .. code-block:: python
+
+            numpy.save('heats_matrix.npy', w_double_prime)
+            w_double_prime = numpy.load('heats_matrix.npy')
+
+
+    :param nam_or_graph: square normalized
+            adjacency matrix or network
+    :type nam_or_graph: :py:class:`numpy.ndarray` or :py:class:`networkx.Graph`
+    :param alpha: heat dissipation coefficient between 1 and 0. The
+           contribution of the heat propagated from adjacent nodes in
+           determining the final heat of a node, as opposed to the contribution
+           from being a part of the gene set initially
+    :type alpha: float
+    :param conserve_heat: If ``True``, heat will be conserved
+            (ie. the sum of the heat vector will be equal to 1),
+            and the graph will be asymmetric. Otherwise, heat will
+            not be conserved, and the graph will be symmetric.
+            **NOTE:** Only applies if **nam_or_graph** is :py:class:`networkx.Graph`
+    :type conserve_heat: bool
+    :param weighted: If ``True``, then the graph's edge weights
+            will be taken into account. Otherwise, all edge weights
+            will be set to 1.
+            **NOTE:** Only applies if **nam_or_graph** is :py:class:`networkx.Graph`
+    :type weighted: bool
+    :return: square individual heats matrix
+    :rtype: :py:class:`numpy.ndarray`
+    """
+    assert 1 >= alpha >= 0, "Alpha must be between 0 and 1"
+
+    nam = nam_or_graph
+    if isinstance(nam_or_graph, nx.Graph):
+        nam = get_normalized_adjacency_matrix(nam_or_graph,
+                                              conserve_heat=conserve_heat,
+                                              weighted=weighted)
+    nam = np.transpose(nam)
+
+    d_name = np.linalg.inv(np.identity(nam.shape[0]) - alpha * nam) * (1 - alpha)
+
+    return d_name
+
+
+def network_propagation(individual_heats_matrix, nodes, seed_genes):
+    """
+    Implements network propagation, as detailed in:
+
+    Vanunu, Oron, et al. 'Associating genes and protein complexes with
+    disease via network propagation.'
+
+    Using this function, the final heat of the network is calculated directly,
+    instead of iteratively. This method is faster when many different
+    propagations need to be performed on the same network (with different seed
+    gene sets). It is slower than
+    :py:func:`~netcoloc.netprop.iterative_network_propagation` for a
+    single propagation.
+
+    :param individual_heats_matrix: Square matrix that is the
+                                    output of :py:func:`~netcoloc.netprop.get_individual_heats_matrix`
+    :type individual_heats_matrix: :py:class:`numpy.ndarray`
+    :param nodes: List of nodes in the network represented by the
+            individual_heats_matrix, in the same order in which they were
+            supplied to :py:func:`~netcoloc.netprop.get_individual_heats_matrix`
+    :type nodes: list
+    :param seed_genes: Input list of genes/nodes for intializing the heat in network propagation. 
+            Any items in `seed genes` that are not present in `nodes` will be ignored.
+    :type seed_genes: list
+    :return: Final heat of each node after propagation, with the name
+             of the nodes as the index
+    :rtype: :py:class:`pandas.Series`
+    """
+    # Remove genes that are not in network
+    seed_genes = list(np.intersect1d(nodes, seed_genes))
+
+    # Initialize results vector
+    F = np.zeros(len(nodes))
+
+    # Add up resulting heats from each gene in seed genes set
+    for gene in seed_genes:
+        # TODO check that this is the correct orientation
+        F += individual_heats_matrix[:,nodes.index(gene)]
+
+    # Normalize results by number of seed genes
+    F /= len(seed_genes)
+
+    #Return as pandas series
+    # TODO does this need to be a pandas series?
+    return pd.Series(F, index=nodes)

netcoloc/netprop_zscore.py

@@ -0,0 +1,277 @@
+# -*- coding: utf-8 -*-
+
+'''Functions for getting z-scores from network propagation.
+'''
+
+# External library imports
+
+import os
+import warnings
+from tqdm import tqdm
+import ndex2
+import pickle
+# Internal module convenience imports
+from netcoloc.netcoloc_utils import *
+from netcoloc.netprop import *
+
+
+def netprop_zscore(seed_gene_file, seed_gene_file_delimiter=None, num_reps=10, alpha=0.5, minimum_bin_size=10,
+                   interactome_file=None, interactome_uuid='f93f402c-86d4-11e7-a10d-0ac135e8bacf',
+                   ndex_server='public.ndexbio.org', ndex_user=None, ndex_password=None, out_name='out',
+                   save_z_scores=False, save_final_heat=False, save_random_final_heats=False, verbose=True):
+    """
+    Performs network heat propagation on the given interactome with the given
+    seed genes, then returns the z-scores of the final heat values of each node
+    in the interactome.
+
+    The z-scores are calculated based on a null model, which is built by running
+    the network propagation multiple times using randomly selected seed genes
+    with similar degree distributions to the original seed gene set.
+
+    This method returns a tuple containing the following:
+
+    * :py:class:`pandas.Series` containing z-scores for each gene. Gene names comprise the index column
+    * :py:class:`numpy.ndarray` containing square matrix where each row contains the final heat scores
+      for each gene from a network propagation from random seed genes
+
+    :param seed_gene_file: Location of file containing a delimited list of
+            seed genes
+    :type seed_gene_file: str
+    :param seed_gene_file_delimiter: Delimiter used to separate genes in seed
+                                     gene file. Default any whitespace
+    :type seed_gene_file_delimiter: str
+    :param num_reps: Number of times the network propagation algorithm should
+            be run using random seed genes in order to build the null model
+    :type num_reps: int
+    :param alpha: Number between 0 and 1. Denotes the importance of the
+            propagation step in the network propagation, as opposed to the step
+            where heat is added to seed genes only. Recommended to be 0.5 or
+            greater
+    :type alpha: float
+    :param minimum_bin_size: minimum number of genes that should be in
+            each degree matching bin.
+    :type minimum_bin_size: int
+    :param interactome_file: Location of file containing the interactome in
+            NetworkX gpickle format. Either the interactome_file argument or the
+            interactome_uuid argument must be defined.
+    :type interactome_file: str
+    :param interactome_uuid: UUID of the interactome on NDEx. Either the
+            interactome_file argument or the interactome_uuid argument must be
+            defined. (Default: The UUID of PCNet, the Parsimonious Composite
+            Network: f93f402c-86d4-11e7-a10d-0ac135e8bacf)
+    :type interactome_uuid: str
+    :param ndex_server: NDEx server on which the interactome is stored.
+            Only needs to be defined if interactome_uuid is defined
+    :type ndex_server: str
+    :param ndex_user: NDEx user that the interactome belongs to. Only
+            needs to be defined if interactome_uuid is defined, and the
+            interactome is private
+    :type ndex_user: str
+    :param ndex_password: password of the NDEx user's account. Only needs
+            to be defined if interactome_uuid is defined, and the interactome is
+            private
+    :type ndex_password: str
+    :param out_name: Prefix for saving output files
+    :type out_name: str
+    :param save_z_scores:
+    :param save_final_heat: If ``True``, then the raw network
+            propagation heat scores for the original seed gene set will be saved
+            in the form of a tsv file in the current directory
+    :type save_final_heat: bool
+    :param save_random_final_heats: If ``True``, then the raw
+            network propagation heat scores for every repetition of the
+            algorithm using random seed genes will be saved in the form of a tsv
+            file in the current directory. (Beware: This can be a large file if
+            num_reps is large.)
+    :type save_random_final_heats: bool
+    :param verbose: If ``True``, then progress information will
+            be logged. Otherwise, nothing will be printed
+    :return: (:py:class:`pandas.Series`, :py:class:`numpy.ndarray`)
+    :rtype: tuple
+    :raises TypeError: If neither interactome_file or interactome_uuid is provided or if
+                       **num_reps** is not an ``int``
+    """
+    # Process arguments
+
+    # seed_gene_file
+    seed_gene_file = os.path.abspath(seed_gene_file)
+    #num_reps
+    try:
+        num_reps = int(num_reps)
+    except:
+        raise TypeError("The num_reps argument should be an integer")
+    #int_file and int_uuid
+    if interactome_file is None and interactome_uuid is None:
+        raise TypeError("Either interactome_file or interactome_uuid argument must be provided")
+    
+    # Load interactome
+    if verbose:
+        print('Loading interactome')
+    if interactome_file is not None:
+        interactome_file = os.path.abspath(interactome_file)
+        with open(interactome_file, 'rb') as f:
+            interactome = pickle.load(f)
+    else:
+        interactome = ndex2.create_nice_cx_from_server(
+            ndex_server,
+            username=ndex_user,
+            password=ndex_password,
+            uuid=interactome_uuid
+        ).to_networkx()
+    if 'None' in interactome.nodes():
+        interactome.remove_node('None')
+    nodes = list(interactome.nodes)
+    
+    if len(nodes) == 0:
+        warnings.warn("Interactome is empty. Returning empty z-scores and random final heats.")
+        return pd.Series(), np.array([])
+
+    # Log interactome num nodes and edges for diagnostic purposes
+    if verbose:
+        print('Number of nodes: ' + str(len(interactome.nodes)))
+        print('Number of edges: ' + str(len(interactome.edges)))
+
+    # Load seed genes
+    with open(seed_gene_file, 'r') as seed_file:
+        seed_genes = list(np.intersect1d(nodes, seed_file.read().split(seed_gene_file_delimiter)))
+        try:
+            seed_genes = [int(x) for x in seed_genes]
+        except:
+            seed_genes = [str(x) for x in seed_genes]
+    if verbose:
+        print('\nNumber of seed genes in interactome: ' + str(len(seed_genes)))
+
+    # Calculate individual_heats_matrix from interactome
+    if verbose:
+        print('\nCalculating w_prime')
+    w_prime = get_normalized_adjacency_matrix(interactome, conserve_heat=True)
+    if verbose:
+        print('\nCalculating individual_heats_matrix')
+    individual_heats_matrix = get_individual_heats_matrix(w_prime, alpha)
+
+    # Calculate the z-score
+    if verbose:
+        print('\nCalculating z-scores: ' + seed_gene_file)
+    z_scores, final_heat, random_final_heats = calculate_heat_zscores(
+        individual_heats_matrix,
+        nodes,
+        dict(interactome.degree),
+        seed_genes,
+        num_reps=num_reps,
+        alpha=alpha,
+        minimum_bin_size=minimum_bin_size)
+
+    # Save z-score results
+    z_scores.name = 'z-scores'
+    if save_z_scores:
+        z_scores.to_csv(out_name + '_z_scores_' + str(num_reps) + '_reps.tsv', sep='\t')
+
+    # If save_final_heat is true, save out the final heat vector
+    if save_final_heat:
+        final_heat_df = pd.DataFrame(final_heat, columns=['z-scores'])
+        final_heat_df.to_csv(out_name + '_final_heat_' + str(num_reps) + '_reps.tsv', sep='\t')
+
+    # If save_random_final_heats is true, save out the vector of randoms (this can be a large file)
+    if save_random_final_heats:
+        random_final_heats_df = pd.DataFrame(
+            random_final_heats.T,
+            index=nodes,
+            columns=range(1, random_final_heats.shape[0] + 1)
+        )
+        random_final_heats_df.to_csv(out_name + '_final_heat_random_' + str(num_reps) + '_reps.tsv', sep='\t')
+
+    return z_scores, random_final_heats
+
+
+def calculate_heat_zscores(individual_heats_matrix, nodes, degrees, seed_genes, 
+                           num_reps=10, alpha=0.5, minimum_bin_size=10, random_seed=1):
+    """
+    Helper function to perform network heat propagation using the given
+    individual heats matrix with the given seed genes and return the z-scores of
+    the final heat values of each node.
+
+    The z-scores are calculated based on a null model, which is built by running
+    the network propagation multiple times using randomly selected seed genes
+    with similar degree distributions to the original seed gene set.
+
+    The returned tuple contains the following:
+
+    * :py:class:`pandas.Series` containing z-scores for each gene. Gene names comprise the index column
+    * :py:class:`pandas.Series` containing the final heat scores for each gene. Gene names comprise the index column,
+    * :py:class:`numpy.ndarray` containing square matrix in which each row contains the final heat scores for each gene from a network propagation from random seed genes)
+
+    :param individual_heats_matrix: output of the
+            netprop.get_individual_heats_matrix. A square matrix containing the
+            final heat contributions of each gene
+    :type individual_heats_matrix: :py:class:`numpy.ndarray`
+    :param nodes: nodes, in the order in which they were supplied to
+            the :py:func:`~netcoloc.netprop.get_normalized_adjacency_matrix` method
+            which returns the precursor to the individual_heats_matrix
+    :type nodes: list
+    :param degrees: Mapping of node names to node degrees
+    :type degrees: dict
+    :param seed_genes: list of genes to use for network propagation. The
+            results of this network propagation will be compared to a set of
+            random results in order to obtain z-scores
+    :type seed_genes: list
+    :param num_reps: Number of times the network propagation algorithm should
+            be run using random seed genes in order to build the null model
+    :type num_reps: int
+    :param alpha: Number between 0 and 1. Denotes the importance of the
+            propagation step in the network propagation, as opposed to the step
+            where heat is added to seed genes only. Recommended to be 0.5 or
+            greater
+    :type alpha: float
+    :param minimum_bin_size: minimum number of genes that should be in
+            each degree matching bin
+    :type minimum_bin_size: int
+    :param random_seed:
+    :return: (:py:class:`pandas.Series`, :py:class:`pandas.Series`, :py:class:`numpy.ndarray`)
+    :rtype: tuple
+    """
+    # set random seed for reproducibility
+    np.random.seed(random_seed)
+
+    # Calculate network propagation results given gene set
+    seed_genes = list(np.intersect1d(nodes, seed_genes))
+    assert len(seed_genes) > 0, "No seed genes found in the interactome. Please check your seed gene file."
+    
+    final_heat = network_propagation(individual_heats_matrix, nodes, seed_genes)
+
+    # Initialize empty matrix for results of random network propagations
+    random_final_heats = np.zeros([num_reps, len(final_heat)])
+
+    assert minimum_bin_size <= len(nodes), "Minimum bin size is larger than the number of nodes."
+    # Create bins containing genes of similar degree
+    bins, actual_degree_to_bin_index = get_degree_binning(degrees, minimum_bin_size)
+
+    # Perform network propagation many times with random seed genes
+    for repetition in tqdm(range(num_reps)):
+        # Create list of random, degree-matched seed genes
+        random_seed_genes = []
+        for gene in seed_genes:
+            # Find genes with similar degrees to focal gene degree
+            degree = degrees[gene]
+            genes_of_similar_degree = bins[actual_degree_to_bin_index[degree]]
+            # Shuffle the genes in the bin
+            np.random.shuffle(genes_of_similar_degree)
+
+            # Add genes to list that haven't already been added
+            index = 0
+            while genes_of_similar_degree[index] in random_seed_genes:
+                index += 1
+            random_seed_genes.append(genes_of_similar_degree[index])
+
+        # Perform network propagation with random seed genes
+        random_final_heat = network_propagation(individual_heats_matrix, nodes, random_seed_genes)
+        # Set seeds to NaN so they don't bias results
+        random_final_heat.loc[random_seed_genes] = np.nan
+        # Add results to random_final_heats matrix
+        random_final_heats[repetition] = random_final_heat
+
+    # Calculate z-scores
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        z_scores = (np.log(final_heat) - np.nanmean(np.log(random_final_heats), axis=0)) / np.nanstd(np.log(random_final_heats), axis=0)
+
+    return z_scores, final_heat, random_final_heats