Update analysis module

netrw/__init__.py

@@ -7,4 +7,5 @@
 A 2022 NetSI Collabathon Product.
 """
 
+from .analysis import *
 from .rewire import *

netrw/analysis/__init__.py

@@ -0,0 +1,5 @@
+from .confusion import *
+from .distance_trajectory import *
+from .plot_property_values_over_time import *
+from .properties_heatmap import *
+from .properties_overtime import *

netrw/analysis/confusion.py

@@ -0,0 +1,45 @@
+import numpy as np
+
+
+def rewiring_distance_confusion_matrix(
+    G, rewiring_methods, distance_measures, timesteps=100, ensemble_size=10
+):
+    """Plotting distances from start graph for different rewiring schemes and distance metrics
+
+    Parameters
+    ----------
+    G : NetworkX Graph
+        The starting graph
+    rewiring_methods : list of Rewiring classes in the rewiring module.
+        methods for rewiring graphs. each class specified must have a
+        `full_rewire` method and that method must have `timesteps` as
+        a keyword argument.
+    distance_measures : netrd Distance
+        metric for measuring the distance between the before and after graphs
+    timesteps : int, default: 100
+        the number of iterations
+    ensemble_size : int, default: 10
+        the number of rewiring trajectories to run.
+
+    Returns
+    -------
+    numpy matrix
+        a matrix where rows are rewiring methods, columns are distance metrics
+        and entries are average distances.
+
+    Notes
+    -----
+    Currently this method does not support keyword args for the rewiring methods
+    and distance metrics.
+    """
+    n = len(rewiring_methods)
+    m = len(distance_measures)
+    C = np.zeros([n, m])
+    for i in range(n):
+        rw = rewiring_methods[i]()
+        for j in range(m):
+            dist = distance_measures[i]()
+            for k in range(ensemble_size):
+                rG = rw.full_rewire(G, timesteps=timesteps)
+                C[i, j] += dist(rG, G) / ensemble_size
+    return C

netrw/analysis/distance_trajectory.py

@@ -0,0 +1,164 @@
+import copy
+import warnings
+
+import netrd
+import networkx as nx
+import numpy as np
+from matplotlib import pyplot as plt
+
+from ..rewire import NetworkXEdgeSwap
+
+
+def distanceTrajectory(
+    G,
+    distance=netrd.distance.Hamming,
+    rewire=NetworkXEdgeSwap,
+    num_steps=100,
+    num_runs=100,
+    distance_kwargs={},
+    rewire_kwargs={},
+):
+    """
+    Get some data on graph distances as a function of number of rewiring steps.
+
+    Parameters
+    ----------
+    G : networkx Graph or DiGraph
+
+    distance : netrd graph distance class
+
+    rewire : netrw rewire class
+
+    num_steps : integer or list
+       number of rewiring steps to be tracked or ordered list of rewiring
+       steps to be tracked
+
+    num_runs : integer
+       number of trajectories to be generated for evaluating the standard
+       deviation for a set of rewiring trajectories
+
+    distance_kwargs : dictionary
+       a dictionary of keyword arguments for an instantiation of the netrd
+       distance class
+
+    rewire_kwargs : dictionary
+       a dictionary of keyword arguments for an instantiation of
+       the netrw rewire class
+    """
+
+    G0 = copy.deepcopy(G)
+
+    # check whether input for num rewire in a number of rewiring steps (int)
+    # or a list of steps
+    if isinstance(num_steps, list):
+        rewire_steps = num_steps
+    else:
+        rewire_steps = range(num_steps)
+
+    # initialize data array
+    data = np.zeros((len(rewire_steps), num_runs))
+
+    # define a rewire function
+    step_rewire = rewire().step_rewire
+    rewire_function = lambda g: step_rewire(g, copy_graph=False, **rewire_kwargs)
+
+    # define a distance function
+    distfun = distance()  # get a class instantiation
+    distance_function = lambda g1, g2: distfun(g1, g2, **distance_kwargs)
+
+    for j in range(num_runs):
+        for i in range(max(rewire_steps)):
+            rewire_function(G0)
+            data[i + 1, j] = distance_function(G0, G)
+
+    return data
+
+
+def plotDistanceTrajectory(
+    G,
+    distance=netrd.distance.Hamming,
+    num_steps=100,
+    show=["mean", "median", "std-env"],
+    labels=None,
+    add_legend=True,
+    fig=None,
+    ax=None,
+    linecolors=None,
+    envcolor="cyan",
+    xlabel="Number of rewiring steps",
+    ylabel=None,
+    **kwargs
+):
+
+    # check whether input for num steps in a number of rewiring steps (int)
+    # or a list of steps
+    if hasattr(num_steps, "__iter__"):
+        rewire_steps = num_steps
+    else:
+        rewire_steps = range(num_steps)
+
+    # set ylabel
+    if ylabel is None:
+        ylabel = distance.__name__ + r" distance to $G_0$"
+
+    # set line labels
+    if labels is None:
+        labels = show
+    elif hasattr(labels, "__iter__"):
+        if len(labels) != len(show):
+            raise ValueError(
+                "List for keyword argument `show` and list for"
+                + "`keyword argument` must have the same length."
+            )
+    else:
+        raise ValueError("Keyword argument `labels` must be None or list.")
+
+    # set line colors
+    if linecolors is None:
+        tabcolors = ["tab:blue", "tab:orange", "tab:green", "tab:red", "tab:purple"]
+        linecolors = [tabcolors[i % len(tabcolors)] for i in range(len(show))]
+    elif hasattr(linecolors, "__iter__"):
+        if len(linecolors) != len(show):
+            raise ValueError(
+                "List for keyword argument `show` and list for"
+                + "`keyword argument` must have the same length."
+            )
+    else:
+        raise ValueError("Keyword argument `labels` must be None or list.")
+
+    # get data
+    data = distanceTrajectory(G, distance=distance, num_steps=num_steps, **kwargs)
+
+    # get data for lines for plot
+    line_data = []
+    for s in show:
+        if s == "mean":
+            line_data += [np.mean(data, axis=1)]
+        elif s == "std":
+            line_data += [np.std(data, axis=1)]
+        elif s == "median":
+            line_data += [np.median(data, axis=1)]
+        elif s == "std-env":
+            mean = np.mean(data, axis=1)
+            std = np.std(data, axis=1)
+            env_data = [std - mean, std + mean]
+        else:
+            warnings.warn("Unknown summary statistic", s, "will be ignored.")
+
+    std = np.std(data, axis=1)
+
+    if fig is None:
+        fig = plt.gcf()
+    if ax is None:
+        ax = plt.subplot(111)
+    if "std-env" in show:
+        ax.fill_between(rewire_steps, env_data[0], env_data[1], color=envcolor)
+
+    for i in range(len(line_data)):
+        ax.plot(rewire_steps, line_data[i], color=linecolors[i], label=labels[i])
+
+    if add_legend:
+        plt.legend()
+
+    plt.xlabel(xlabel)
+    plt.ylabel(ylabel)

netrw/analysis/plot_property_values_over_time.py

@@ -0,0 +1,67 @@
+import matplotlib.pyplot as plt
+import networkx as nx
+import numpy as np
+
+import netrw
+
+
+def plot_property_values_over_time(propvals, ylabel=""):
+    """
+    Plot mean and standard deviation of how a network property changes over time during multiple iterations of a rewiring process.
+
+    Parameters
+    ----------
+    propvals :2d nump array
+        2d numpy array of output values from dictionary of properties_overtime.
+        The network property is calculated at each step and iteration of the rewiring process. Rows are single iteration over a rewiring process.
+        Columns show different iterations of the rewiring process from the initial graph.
+
+    ylabel: string, optional
+        Label for y axis of graph for mean and standard deviation of network property
+        Default is no label.
+
+    Returns
+    -------
+    fig: matplotlib figure
+        Figure of mean and standard deviation for a network property throughout the rewiring process.
+
+    """
+
+    alllist = []  # list of all properties for all iterations at each of the time steps
+
+    valarray = propvals
+    num_rows, num_cols = valarray.shape
+
+    for k in range(num_cols):
+        alllist.append([])
+        for l in range(num_rows):
+            alllist[k].append(valarray[l][k])
+
+    # find mean and standard deviation over different iterations of rewiring process
+    meanlist = []
+    sdlist = []
+    for k in range(num_cols):
+        meanlist.append(np.mean(alllist[k]))
+        sdlist.append(np.std(alllist[k]))
+
+    # find upper and lower bound of standard deviation interval around the mean
+    upperbd = []
+    lowerbd = []
+    for a in range(len(meanlist)):
+        upperbd.append(meanlist[a] + sdlist[a])
+        lowerbd.append(meanlist[a] - sdlist[a])
+
+    fig, (ax0) = plt.subplots(nrows=1)
+    ax0.plot(range(num_cols), meanlist, color="blue", linewidth=2)
+    ax0.plot(range(num_cols), upperbd, color="blue")
+    ax0.plot(range(num_cols), lowerbd, color="blue")
+    ax0.fill_between(
+        range(num_cols), upperbd, lowerbd, color="cornflowerblue", alpha=0.5
+    )
+
+    ax0.set_xlabel("number of rewiring steps")
+    ax0.set_ylabel(ylabel)
+
+    fig.show()
+
+    return fig

netrw/analysis/properties_overtime.py

@@ -0,0 +1,51 @@
+from copy import deepcopy
+
+import matplotlib.pyplot as plt
+import networkx as nx
+import numpy as np
+
+import netrw
+from netrw.rewire import AlgebraicConnectivity, KarrerRewirer, NetworkXEdgeSwap
+
+
+def properties_overtime(init_graph, rewire_method, property1, tmax, numit):
+    """
+    Analyze the property values of a network as a function of rewire steps.
+    Looks at how a network property changes as a rewiring process occurs.
+
+    Parameters
+    ----------
+    init_graph : NetworkX graph
+        Initial graph upon which rewiring will occur.
+    rewire_method : netrw rewire class object
+        Algorithm for rewiring a network with step_rewire option
+    property1 : NetworkX function
+        Network description property that outputs a single value for a given network. Should work with any function that
+        summarizes a NetworkX graph object into a single value. For example, nx.average_clustering, nx.average_shortest_path_length, etc.
+    tmax : int
+        Number of rewiring steps to perform for each iteration.
+    numit : int
+        Number of rewiring iterations to perform on the initial graph. The given rewiring process will be performed numit
+        times on the initial graph to look at the distribution of outcomes for this rewiring process on the initial graph.
+    Returns
+    -------
+    property_dict: dictionary
+        Dictionary of output where the keys are the property name and the values are a 2D numpy arry of the network property
+        calculated at each step and iteration of the rewiring process. Rows are single iteration over a rewiring process.
+        Columns show different iterations of the rewiring process from the initial graph.
+
+    """
+    property_dict = {}
+    property_dict[property1.__name__] = np.zeros((numit, tmax))
+    rw = rewire_method()
+
+    for i in range(numit):
+        G0 = deepcopy(init_graph)
+        propertyval = property1(G0)  # calculate property of initial network
+        property_dict[property1.__name__][i, 0] = propertyval
+        for j in range(1, tmax):
+            G0 = rw.step_rewire(G0, copy_graph=False)  # rewire
+            propertyval = property1(G0)  # calculate property of the rewired network
+            property_dict[property1.__name__][i, j] = propertyval
+
+    return property_dict