fg_col_df["group_mean_visit"] = fg_col_df["to_class"].map(group_means) fg_col_meta.append(fg_col_df) stashcsv(fg_col_df, f"{fg_name}-meta" + basename) # plot the super row fig, axs = plt.subplots(2, 1, figsize=(25, 15), gridspec_kw=dict(height_ratios=[0.95, 0.05])) ax = axs[0] matrixplot( np.log10(hop_hist + 1), ax=ax, col_meta=fg_col_df, col_sort_class=["to_class"], col_class_order="group_mean_visit", col_item_order=["mean_visit"], col_colors="to_class", col_palette=CLASS_COLOR_DICT, col_ticks=False, cbar_kws=dict(fraction=0.05), ) ax = axs[-1] ax.axis("off") caption = f"Figure x: Hop histogram for cascades from {fg_name}.\n" caption += "Cascade parameters were: " caption += f"p={p}, n_init={n_init}, max_hops={max_hops}, simulataneous={simultaneous}, stop_nodes={use_stop_nodes}.\n" caption += f"Columns (neurons) are sorted into classes, classes are sorted " caption += f"by mean hop, and then by the mean hop for an individual neuron." ax.invert_yaxis() ax.text(0, 0, caption, va="center")
rank_voltage_df[(source_name, sink_name)] = rankdata(v) col_meta.iloc[i, 0] = f"{source_name}" + r"$\to$ " f"{sink_name}" i += 1 vdiff = np.squeeze(v[:, np.newaxis] - v[np.newaxis, :]) curr = W * vdiff curr_node = np.sum(curr, axis=1) # current from each node fig, ax = plt.subplots(1, 1, figsize=(10, 20)) voltage = voltage_df.values log_voltage = np.log10(voltage) matrixplot( rank_voltage_df.values, ax=ax, row_meta=meta, row_sort_class=[class_key], col_meta=col_meta, col_sort_class=["in_out"], tick_rot=45, ) # %% [markdown] # # pca = PCA(n_components=5) embed = pca.fit_transform(rank_voltage_df.values) pg = pairplot(embed, labels=meta[class_key].values, palette=CLASS_COLOR_DICT) pg._legend.remove() # %% [markdown] # #
pred = predict(embed, left_inds, right_inds, model, relabel=False) # %% labels = meta["merge_class"].values uni_pred = np.unique(pred) for up in uni_pred: plt.figure() mask = pred == up temp_labels = labels[mask] uni_labels = np.unique(labels) temp_hop_hist = fwd_hop_hist.T[mask] matrixplot( temp_hop_hist.T, col_sort_class=temp_labels, col_colors=temp_labels, col_palette=CLASS_COLOR_DICT, cbar=False, col_ticks=False, ) # %% [markdown] # ## fig, ax = plt.subplots(1, 1, figsize=(20, 10)) matrixplot( full_hop_hist, col_sort_class=pred, col_colors=labels, col_palette=CLASS_COLOR_DICT, col_item_order=[labels], cbar=False, col_ticks=False,
meta["mean_visit"] = mean_visit mapper = meta.groupby("merge_class")["mean_visit"].mean() meta["group_mean_visit"] = meta["merge_class"].map(mapper) # %% [markdown] # ## fig, ax = plt.subplots(1, 1, figsize=(20, 20)) matrixplot( adj, ax=ax, row_meta=meta, row_colors="merge_class", row_palette=CLASS_COLOR_DICT, row_item_order="mean_visit", row_ticks=False, col_meta=meta, col_colors="merge_class", col_palette=CLASS_COLOR_DICT, col_ticks=False, col_item_order="mean_visit", plot_type="scattermap", sizes=(2.5, 5), ) stashfig("fwd-reverse-diff-sort") # %% [markdown] # ## fig, ax = plt.subplots(1, 1, figsize=(30, 15)) matrixplot( all_hop_hist,
figsize=(30, 20), gridspec_kw=dict(width_ratios=[0.95, 0.02], wspace=0.02)) ax = axs[0] matrixplot( path_indicator_mat, ax=ax, plot_type="scattermap", col_sort_class=["class1", "class2"], col_class_order="signal_flow", col_ticks=True, tick_rot=90, col_meta=meta, col_colors="merge_class", col_palette=CLASS_COLOR_DICT, col_item_order="dend_order", col_tick_pad=[0.5, 1.5], # col_ticks=False, row_meta=path_meta, row_sort_class="cluster", row_item_order="dend_order", row_ticks=True, gridline_kws=dict(linewidth=0.3, color="grey", linestyle="--"), sizes=(2, 2), hue="weight", palette="tab10", ) ax.set_ylabel("Cluster") # fig.suptitle("G") ax = axs[1] palplot(path_len, cmap="tab10", ax=ax)
from_class.name = "from_class" col_df = pd.concat([orders, from_idx, from_ids, from_class], axis=1) # %% [markdown] # # log_mat = np.log10(hist_mat + 1) if plot_full_mat: shape = log_mat.shape figsize = (10, 20) fig, ax = plt.subplots(1, 1, figsize=figsize) matrixplot( log_mat, ax=ax, col_meta=col_df, col_sort_class=["from_class"], row_meta=row_df, row_sort_class=["to_class"], plot_type="scattermap", sizes=(0.5, 0.5), tick_rot=45, ) stashfig("log-full-scatter" + basename) fig, ax = plt.subplots(1, 1, figsize=figsize) matrixplot( log_mat, ax=ax, col_meta=col_df, col_sort_class=["from_class"], row_colors=CLASS_COLOR_DICT, row_meta=row_df,
pred = np.empty(len(embed[0])) pred[left_inds] = pred_left pred[right_inds] = pred_right meta["joint_pred"] = pred ax, _, tax, _ = matrixplot( binarize(adj), plot_type="scattermap", sizes=(0.25, 0.5), col_colors="merge_class", col_palette=CLASS_COLOR_DICT, col_meta=meta, col_sort_class=["hemisphere", "joint_pred"], col_ticks=False, # col_class_order="block_sf", col_item_order="adj_sf", row_ticks=False, row_colors="merge_class", row_palette=CLASS_COLOR_DICT, row_meta=meta, row_sort_class=["hemisphere", "joint_pred"], # row_class_order="block_sf", row_item_order="adj_sf", ) # %% [markdown] # ## # %% [markdown] # ##
community_sizes = np.empty(2 * n_blocks, dtype=int) n_per_block = 100 community_sizes = n_blocks * [n_per_block] np.random.seed(88) adj, labels = sbm(community_sizes, block_probs, directed=True, loops=False, return_labels=True) n_verts = adj.shape[0] matrixplot( adj, row_sort_class=labels, col_sort_class=labels, cbar=False, ax=axs[1], square=True, ) axs[1].set_title("Adjacency matrix", pad=25) plt.tight_layout() stashfig("sbm" + basename) # %% [markdown] # ## Run paths print(f"Running {n_init} random walks from each source node...") transition_probs = to_markov_matrix(adj) out_inds = np.where(labels == n_blocks - 1)[0] source_inds = np.where(labels == 0)[0]
middle_df = sort_meta.groupby(sort_class, sort=False).mean() middle_inds = np.array(middle_df["sort_idx"].values) + 0.5 middle_labels = list(middle_df.index) return first_inds, middle_inds, middle_labels else: return None, None, None df = pd.DataFrame(data=labels) df["inds"] = range(len(df)) df.groupby([0]).first() _get_tick_info(df, [df.columns.values[0]]) #%% sns.set_context("talk") matrixplot(A, col_meta=labels, row_meta=labels) # %% [markdown] # ## n_rows = 100 n_cols = 200 data11 = np.random.normal(0, 1, size=(n_rows, n_cols)) data21 = np.random.normal(0, 2, size=(n_rows, n_cols)) data12 = np.random.normal(1, 1, size=(n_rows, n_cols)) data22 = np.random.normal(1, 2, size=(n_rows, n_cols)) data = np.block([[data11, data12], [data21, data22]]) # %% [markdown] # ## fig, ax = plt.subplots(1, 1, figsize=(10, 5)) matrixplot(data, ax=ax)
graph_sfs = [] for mg, graph_type in zip(graphs, graph_types): meta = mg.meta sf = signal_flow(mg.adj) meta["signal_flow"] = -sf graph_sfs.append(sf) fig, ax = plt.subplots(1, 1, figsize=(20, 20)) matrixplot( mg.adj, ax=ax, col_meta=meta, row_meta=meta, col_item_order="signal_flow", row_item_order="signal_flow", col_colors="Merge Class", row_colors="Merge Class", col_palette=CLASS_COLOR_DICT, row_palette=CLASS_COLOR_DICT, plot_type="scattermap", sizes=(2.5, 5), ) fig.suptitle(f"{graph_type}, signal flow sorted", y=0.91) stashfig(f"sf-sort-scattermap-{graph_type}") # %% [markdown] # ## plot the rank orders for each from scipy.stats import rankdata sfs = []
if axis == 0: sum_vec = adj[np.ix_(other_inds, this_inds)].sum(axis=axis) elif axis == 1: sum_vec = adj[np.ix_(this_inds, other_inds)].sum(axis=axis) connect_mat.append(sum_vec) return np.array(connect_mat) input_mat = calc_ego_connectivity(adj, meta, label, axis=0) _, _, top, _ = matrixplot( pass_to_ranks(input_mat[::-1]), col_meta=temp_meta, col_item_order=["merge_class", "sf"], col_sort_class=["merge_class"], col_ticks=False, col_colors="merge_class", col_palette=CLASS_COLOR_DICT, cbar=False, row_ticks=False, ax=ax, ) # ax.invert_yaxis() ax.set_yticks([]) top.set_title("Input", color="dimgrey") # ax.set_yticklabels(other_class) # ax.set_yticks(np.arange(len(other_class)) + 0.5) # ax.set_xlim((0, max_bar)) # get the indices in the adjacency corresponding to each predicted leaf node # sum up input or output
# %% [markdown] # ## sorter = "diff" for mg, graph_type in zip(graphs, graph_types): print(graph_type) # get out the graph and relevant nodes meta = mg.meta fig, ax = plt.subplots(1, 1, figsize=(20, 20)) matrixplot( mg.adj, ax=ax, col_meta=meta, row_meta=meta, col_item_order=sorter, row_item_order=sorter, col_colors="merge_class", row_colors="merge_class", col_palette=CLASS_COLOR_DICT, row_palette=CLASS_COLOR_DICT, plot_type="scattermap", sizes=(2.5, 5), ) fig.suptitle(f"{graph_type}, {sorter} sorted", y=0.91) stashfig(f"sort-{sorter}-scattermap-{graph_type}") # %% [markdown] # ## plot the rank orders for each from scipy.stats import rankdata sfs = []
sf = signal_flow(adj) meta["signal_flow"] = -sf meta["pred"] = pred meta["group_signal_flow"] = meta["pred"].map( meta.groupby("pred")["signal_flow"].mean()) fig, ax = plt.subplots(1, 1, figsize=(20, 20)) matrixplot( adj, ax=ax, row_meta=meta, col_meta=meta, row_sort_class="pred", col_sort_class="pred", row_class_order="group_signal_flow", col_class_order="group_signal_flow", row_colors="merge_class", col_colors="merge_class", row_palette=CLASS_COLOR_DICT, col_palette=CLASS_COLOR_DICT, row_item_order=["merge_class", "signal_flow"], col_item_order=["merge_class", "signal_flow"], plot_type="scattermap", sizes=(0.5, 1), ) stashfig(f"adj-k={k}-n_components={n_components}") # %% [markdown] # ## SUBCLUSTER with reembedding! pred = composite_predict(X, left_inds,
community_sizes = np.empty(2 * n_blocks, dtype=int) n_feedforward = 100 community_sizes = n_blocks * [n_feedforward] np.random.seed(88) adj, labels = sbm(community_sizes, block_probs, directed=True, loops=False, return_labels=True) n_verts = adj.shape[0] matrixplot( adj, row_sort_class=labels, col_sort_class=labels, cbar=False, ax=axs[1], square=True, ) axs[1].set_title("Adjacency matrix", pad=25) plt.tight_layout() stashfig("sbm" + basename) # %% [markdown] # ## Set up the SIR class from src.traverse import Cascade from math import ceil class SIRCascades: def __init__(self, transition_probs, n_samples=100):
community_sizes = np.empty(2 * n_blocks, dtype=int) n_per_block = 100 community_sizes = n_blocks * [n_per_block] np.random.seed(88) adj, labels = sbm(community_sizes, block_probs, directed=True, loops=False, return_labels=True) n_verts = adj.shape[0] matrixplot( adj, row_sort_class=labels, col_sort_class=labels, cbar=False, ax=axs[1], square=True, ) axs[1].set_title("Adjacency matrix", pad=25) plt.tight_layout() stashfig("sbm" + basename) # %% [markdown] # ## n_blocks = 15 B = np.zeros((n_blocks, n_blocks)) B[0, 6] = 0.3 B[1, 4] = 0.3 B[2, 7] = 0.3
A, labels = sbm(community_sizes, block_probs, directed=True, loops=False, return_labels=True) n_verts = A.shape[0] sns.heatmap(block_probs, square=True, cmap="RdBu_r", center=0, annot=True, cbar=False) stashfig("sbm-B") matrixplot(A, row_sort_class=labels, col_sort_class=labels, cbar=False) stashfig("sbm") # %% [markdown] # ## p = 0.05 max_hops = 10 n_init = 100 simultaneous = True transition_probs = to_transmission_matrix(A, p) start_nodes = np.arange(n_feedforward) cdispatch = TraverseDispatcher( Cascade, transition_probs, allow_loops=False,
sf = signal_flow(adj) meta["signal_flow"] = -sf meta["pred"] = pred meta["pred_side"] = pred_side meta["group_signal_flow"] = meta["pred"].map( meta.groupby("pred")["signal_flow"].mean()) fig, ax = plt.subplots(1, 1, figsize=(20, 20)) matrixplot( adj, ax=ax, row_meta=meta, col_meta=meta, row_sort_class="pred_side", col_sort_class="pred_side", row_class_order="group_signal_flow", col_class_order="group_signal_flow", row_colors="merge_class", col_colors="merge_class", row_palette=CLASS_COLOR_DICT, col_palette=CLASS_COLOR_DICT, row_item_order=["merge_class", "signal_flow"], col_item_order=["merge_class", "signal_flow"], plot_type="scattermap", sizes=(0.5, 1), ) fig.suptitle(basetitle, y=0.94) stashfig(f"adj-sf" + basename) meta["te"] = -meta["Total edgesum"] fig, ax = plt.subplots(1, 1, figsize=(20, 20)) matrixplot( adj,
blues = colors[:max_hops] reds = colors[max_hops:] colors = blues[::-1] + reds[::-1] color_dict = dict(zip(hops, colors)) # %% [markdown] # ## fig, ax = plt.subplots(1, 1, figsize=(20, 20)) matrixplot( adj, ax=ax, row_meta=meta, row_colors="merge_class", row_palette=CLASS_COLOR_DICT, row_item_order="diff_visit", row_ticks=False, col_meta=meta, col_colors="merge_class", col_palette=CLASS_COLOR_DICT, col_ticks=False, col_item_order="diff_visit", plot_type="scattermap", sizes=(2.5, 5), ) stashfig(f"adj-diff-sort" + basename) # %% [markdown] # ## fig, ax = plt.subplots(1, 1, figsize=(30, 15)) matrixplot( full_hop_hist,
n_rows = 100 n_cols = 200 data11 = np.random.normal(0, 1, size=(n_rows, n_cols)) data21 = np.random.normal(0, 2, size=(n_rows, n_cols)) data13 = np.random.normal(0, 0.5, size=(n_rows, n_cols)) data12 = np.random.normal(1, 1, size=(n_rows, n_cols)) data22 = np.random.normal(1, 2, size=(n_rows, n_cols)) data23 = np.random.normal(1, 0.5, size=(n_rows, n_cols)) data = np.block([[data11, data12, data13], [data21, data22, data23]]) # %% [markdown] # ## fig, ax = plt.subplots(1, 1, figsize=(10, 5)) matrixplot(data, ax=ax) # %% [markdown] # ## Add row and column metadata means = np.zeros(data.shape[0]) means[n_rows:] = 1 variances = np.ones(data.shape[1]) variances[n_cols:2 * n_cols] = 2 variances[2 * n_cols:] = 0.5 fig, ax = plt.subplots(1, 1, figsize=(10, 5)) matrixplot(data, ax=ax, row_sort_class=means, col_sort_class=variances) ax.set_xlabel("Variance") ax.set_ylabel("Mean")
# %% [markdown] # ## meta["signal_flow"] = -signal_flow(adj) fig, ax = plt.subplots(1, 1, figsize=(20, 20)) meta["class2"].fillna(" ", inplace=True) matrixplot( path_indicator_mat, ax=ax, plot_type="scattermap", col_sort_class=["class1", "class2"], col_class_order="signal_flow", col_ticks=False, col_meta=meta, col_colors="merge_class", col_palette=CLASS_COLOR_DICT, # col_ticks=False, row_sort_class=pred, row_ticks=False, sizes=(1, 1), hue="weight", palette="tab10", gridline_kws=dict(linewidth=0.3, color="grey", linestyle="--"), ) # %% [markdown] # ## from sklearn.manifold import MDS n_components = 8 metric = True