def double_adj_plot(left_perm, right_perm, axs=None, titles=True): if axs is None: fig, axs = plt.subplots(1, 2, figsize=(20, 10)) left_perm_adj = left_adj[np.ix_(left_perm, left_perm)] left_perm_meta = left_meta.iloc[left_perm] ax = axs[0] _, _, top, _ = adjplot( left_perm_adj, meta=left_perm_meta, plot_type="scattermap", sizes=(1, 10), ax=ax, colors="merge_class", palette=CLASS_COLOR_DICT, ) if titles: top.set_title(r"Left $\to$ left") right_perm_adj = right_adj[np.ix_(right_perm, right_perm)] right_perm_meta = right_meta.iloc[right_perm] ax = axs[1] _, _, top, _ = adjplot( right_perm_adj, meta=right_perm_meta, plot_type="scattermap", sizes=(1, 10), ax=ax, colors="merge_class", palette=CLASS_COLOR_DICT, ) if titles: top.set_title(r"Right $\to$ right") return axs
def plot_adjacencies(full_mg, axs): pal = sns.color_palette("deep", 1) model = DCSBMEstimator for level in np.arange(lowest_level + 1): ax = axs[0, level] adj = binarize(full_mg.adj) _, _, top, _ = adjplot( adj, ax=ax, plot_type="scattermap", sizes=(0.5, 0.5), sort_class=["hemisphere"] + level_names[: level + 1], item_order=["merge_class_sf_order", "merge_class", "sf"], class_order="sf", meta=full_mg.meta, palette=CLASS_COLOR_DICT, colors="merge_class", ticks=False, gridline_kws=dict(linewidth=0.2, color="grey", linestyle="--"), color=pal[0], ) top.set_title(f"Level {level} - Data") labels = full_mg.meta[f"lvl{level}_labels_side"] estimator = model(directed=True, loops=True) uni_labels, inv = np.unique(labels, return_inverse=True) estimator.fit(adj, inv) sample_adj = np.squeeze(estimator.sample()) ax = axs[1, level] _, _, top, _ = adjplot( sample_adj, ax=ax, plot_type="scattermap", sizes=(0.5, 0.5), sort_class=["hemisphere"] + level_names[: level + 1], item_order=["merge_class_sf_order", "merge_class", "sf"], class_order="sf", meta=full_mg.meta, palette=CLASS_COLOR_DICT, colors="merge_class", ticks=False, gridline_kws=dict(linewidth=0.2, color="grey", linestyle="--"), color=pal[0], ) top.set_title(f"Level {level} - DCSBM sample")
def plot_adjs(left, right, title=""): fig, axs = plt.subplots(1, 2, figsize=(15, 7)) adjplot( left, plot_type="scattermap", sizes=(2, 2), ax=axs[0], title=r"Left $\to$ left", color=palette["Left"], ) adjplot( right, plot_type="scattermap", sizes=(2, 2), ax=axs[1], title=r"Right $\to$ right", color=palette["Right"], ) fig.suptitle(title, ha="center", x=0.51) return fig, axs
def plot_sorted_adj(graph_type, ax): mg = mg_dict[graph_type] adj = mg.adj meta = mg.meta _, _, top, _, = adjplot( adj, meta=meta, item_order=f"{graph_type}_flow", colors="merge_class", palette=CLASS_COLOR_DICT, plot_type="scattermap", sizes=(0.5, 1), ax=ax, color=graph_type_colors[graph_type], ) top.set_title(graph_names[graph_type], color=graph_type_colors[graph_type]) ax.plot([0, len(adj)], [0, len(adj)], **line_kws)
labels=pred, palette=cc.glasbey_light, legend_name="Cluster", ) stashfig("pairplot-agmm-iso" + basename) # %% [markdown] # ## color_dict = dict(zip(np.unique(pred), cc.glasbey_light)) fig, ax = plt.subplots(1, 1, figsize=(20, 20)) adjplot( path_dist_mat, sort_class=pred, cmap=None, center=None, ax=ax, gridline_kws=dict(linewidth=0.5, color="grey", linestyle="--"), ticks=False, colors=pred, palette=color_dict, cbar=False, ) stashfig("adjplot-GMMoCMDSoPathDist" + basename) # %% [markdown] # ## from scipy.cluster.hierarchy import dendrogram Z = linkage(squareform(path_dist_mat), method="average", optimal_ordering=False)
label_meta = mc.meta.copy() sub_cols = [f"0-{i}_pred_side" for i in range(6)] sub_cols.remove("0-1_pred_side") lvl_2_labels = label_meta[sub_cols].fillna("").sum(axis=1) lvl_2_labels.name = "lvl2_pred_side" label_meta = pd.concat((label_meta, lvl_2_labels), axis=1) # %% label_meta["rand"] = np.random.uniform(size=len(label_meta)) fig, ax = plt.subplots(1, 1, figsize=(20, 20)) adjplot( adj, meta=label_meta, sort_class=["0_pred_side", "lvl2_pred_side"], colors="merge_class", palette=CLASS_COLOR_DICT, item_order=["merge_class", "rand"], plot_type="scattermap", sizes=(0.5, 1), ax=ax, ) stashfig("example-hierarchy-adj") # %% [markdown] # ## sf = signal_flow(adj) label_meta["signal_flow"] = -sf label_meta["lvl2_signal_flow"] = label_meta["lvl2_pred_side"].map( label_meta.groupby("lvl2_pred_side")["signal_flow"].mean()) label_meta["lvl1_signal_flow"] = label_meta["0_pred_side"].map( label_meta.groupby("0_pred_side")["signal_flow"].mean()) # TODO fix for multilayer class_order
cmap="Reds", cbar=False, ax=axs[0], square=True) axs[0].xaxis.tick_top() axs[0].set_title("Block probability matrix", pad=25) np.random.seed(88) adj, labels = sbm(community_sizes, block_probs, directed=True, loops=False, return_labels=True) n_verts = adj.shape[0] adjplot(adj, 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] # ## currtime = time.time() n_verts = len(adj) halfs = [0.05, 0.1, 0.5, 1, 5, 10, 50, 100] alphas = [np.round(np.log(2) / (h * n_verts), decimals=7) for h in halfs]
right_meta = right_meta.iloc[lcc_inds] meta = pd.concat((left_meta, right_meta)) n_pairs = len(ll_adj) print(f"Number of pairs after taking LCC intersection: {n_pairs}") #%% [markdown] # ### Plotting the aligned adjacency matrices # At a high level, we see that the left-left and right-right induced subgraphs look # quite similar when aligned by the known neuron pairs. #%% fig, axs = plt.subplots(1, 2, figsize=(10, 5)) adjplot( ll_adj, plot_type="scattermap", sizes=(1, 2), ax=axs[0], title=r"Left $\to$ left", color=palette["Left"], ) adjplot( rr_adj, plot_type="scattermap", sizes=(1, 2), ax=axs[1], title=r"Right $\to$ right", color=palette["Right"], ) stashfig("left-right-induced-adjs") #%% [markdown] # ## Embedding the graphs
n_col = 7 scale = 10 fig, axs = plt.subplots(n_row, n_col, figsize=(n_row * scale, n_col * scale)) for level in range(8): label_name = f"lvl{level}_labels_side" sbm = SBMEstimator(directed=True, loops=True) sbm.fit(binarize(full_adj), full_meta[label_name].values) ax = axs[1, level] _, _, top, _ = adjplot( sbm.p_mat_, ax=ax, plot_type="heatmap", sort_class=["hemisphere"] + level_names[: level + 1], item_order=["merge_class_sf_order", "merge_class", "sf"], class_order="sf", meta=full_mg.meta, palette=CLASS_COLOR_DICT, colors="merge_class", ticks=False, gridline_kws=dict(linewidth=0.05, color="grey", linestyle="--"), cbar_kws=dict(shrink=0.6), ) stashfig("big-bhat-fig") # %% [markdown] # ## # Get positions for left and right simultaneously, so they'll line up ### def get_mid_map(full_meta, leaf_key=None, bilat=False): if leaf_key is None: leaf_key = f"lvl{lowest_level}_labels" # left if not bilat:
left_meta = meta.iloc[lp_inds] right_meta = meta.iloc[rp_inds] plot_kws = dict( plot_type="scattermap", sort_class="merge_class", item_order=["pair_td", "Pair ID"], colors="merge_class", palette=CLASS_COLOR_DICT, ticks=False, class_order="pair_td", sizes=(1, 1), gridline_kws=dict(linewidth=0.2, color="grey", linestyle="--"), ) fig, axs = plt.subplots(1, 2, figsize=(20, 10)) _, _, top, _ = adjplot(ll_adj, ax=axs[0], meta=left_meta, **plot_kws) top.set_title(r"L $\to$ L") _, _, top, _ = adjplot(rr_adj, ax=axs[1], meta=right_meta, **plot_kws) top.set_title(r"R $\to$ R") plt.tight_layout() stashfig("ipsilateral-adj") lr_adj = adj[np.ix_(lp_inds, rp_inds)] rl_adj = adj[np.ix_(rp_inds, lp_inds)] fig, axs = plt.subplots(1, 2, figsize=(20, 10)) _, _, top, _ = adjplot(lr_adj, ax=axs[0], meta=left_meta, **plot_kws) top.set_title(r"L $\to$ R") _, _, top, _ = adjplot(rl_adj, ax=axs[1], meta=right_meta, **plot_kws) top.set_title(r"R $\to$ L") plt.tight_layout()
basename = f"-n_blocks={n_blocks}-n_per_block={n_per_block}" block_probs = get_feedforward_B(low_p, diag_p, feedforward_p, n_blocks=n_blocks) fig, axs = plt.subplots(1, 2, figsize=(20, 10)) sns.heatmap(block_probs, annot=True, cmap="Reds", cbar=False, ax=axs[0], square=True) axs[0].xaxis.tick_top() axs[0].set_title("Block probability matrix", pad=25) np.random.seed(88) adj, labels = sbm( community_sizes, block_probs, directed=True, loops=False, return_labels=True ) n_verts = adj.shape[0] adjplot(adj, 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] # ## Create the matching matrix def diag_indices(length, k=0): return (np.arange(length - k), np.arange(k, length)) def make_flat_match(length, **kws): match_mat = np.zeros((length, length))
ax.get_legend().remove() stashfig(f"barplot-lvl{i}-prop") plt.close() # %% [markdown] # ## for i in range(n_levels): fig, ax = plt.subplots(1, 1, figsize=(20, 20)) adjplot( adj, meta=mc.meta, sort_class=f"lvl{i}_labels_side", item_order="merge_class", plot_type="scattermap", sizes=(0.5, 1), ticks=False, colors="merge_class", ax=ax, palette=CLASS_COLOR_DICT, gridline_kws=dict(linewidth=0.2, color="grey", linestyle="--"), ) stashfig(f"adj-lvl{i}") # fig, ax = plt.subplots(1, 1, figsize=(15, 25)) # stacked_barplot( # mc.meta[f"lvl{i}_labels_side"], # mc.meta["merge_class"], # category_order=np.unique(mc.meta[f"lvl{i}_labels_side"].values), # color_dict=CLASS_COLOR_DICT, # norm_bar_width=False, # ax=ax,
p_val_df = pd.DataFrame(data=p_vals, index=cluster_meta.index, columns=cluster_meta.index) stashcsv(p_val_df, "p-vals" + basename) stats_df = pd.DataFrame(data=stats, index=cluster_meta.index, columns=cluster_meta.index) stashcsv(stats_df, "test-stats" + basename) plot_p_vals = -np.log10(p_vals) plt.figure() adjplot( plot_p_vals, meta=cluster_meta, vmax=np.nanmax(plot_p_vals[~np.isinf(plot_p_vals)]), cbar_kws=dict(shrink=0.7), cbar=True, cmap="Reds", ) stashfig("p-val-plot" + basename) plt.figure(figsize=(10, 10)) sns.heatmap( stats, cmap="Reds", cbar_kws=dict(shrink=0.7), square=True, xticklabels=False, yticklabels=False, ) stashfig("stats-plot" + basename)
H = ranks[:, None] - ranks[None, :] - 1 H = np.multiply(H, H) H *= 0.5 P = np.exp(-beta * H) P /= np.mean(P) * len(P) P *= degree # TODO not sure this matches the paper exactly but makes sense to me return P P = construct_spring_rank_P(X, beta, k) A = rng.poisson(P) fig, axs = plt.subplots(1, 2, figsize=(15, 7.5)) ax = axs[0] adjplot(P, ax=ax, title=r"$P$", cbar=False) ax = axs[1] adjplot(A, ax=ax, title=r"$A$", color="darkred", plot_type="scattermap", sizes=(2, 5)) stashfig("p-and-adj") #%% [markdown] # If we change the parameters to be point masses for the 3 different groups, we get # a specific kind of feedforward SBM model. #%% n_per_group = 100 X1 = np.ones(n_per_group) X2 = np.ones(n_per_group) * 0 X3 = np.ones(n_per_group) * -1 X = np.concatenate((X1, X2, X3)) labels = np.concatenate((0 * ones, 1 * ones, 2 * ones))
ax=ax, color_dict=CLASS_COLOR_DICT, plot_names=True, text_color="dimgrey", bar_height=0.2, ) ax.get_legend().remove() subgraph_inds = temp_meta["inds"].values subgraph_adj = adj[np.ix_(subgraph_inds, subgraph_inds)] ax = fig.add_subplot(mid_gs[1:, :]) _, _, top, _ = adjplot( pass_to_ranks(subgraph_adj), plot_type="heatmap", cbar=False, ax=ax, meta=temp_meta, item_order=["merge_class", "sf"], colors="merge_class", palette=CLASS_COLOR_DICT, ) top.set_title("Intra-cluster connectivity", color="dimgrey") dend_gs = plt.GridSpec( 1, 5, figure=fig, left=margin + 5 / n_col + 2 * gap, right=1 - margin, bottom=margin, top=1 - margin, wspace=0.02,
for graph_type in graph_types: color_adj = load_adjacency(graph_type=f"G{graph_type}", nodelist=ids) graphs[graph_type] = color_adj union += color_adj graphs["union"] = union #%% mg = MaggotGraph(graphs, meta=meta) mg.adjs #%% bisected_adjs, bisected_meta = mg.bisect() #%% from src.visualization import adjplot adjplot() #%% # getting lcc # bisecting #%% #%% # # Test data # meta = [ # ["A", "cat", 2, 1.0], # ["B", "dog", 5, 8.0], # ["X", "llama", 54, 3.0],
from sklearn.linear_model import LinearRegression lr = LinearRegression(fit_intercept=False, n_jobs=-1) lr.fit(incidence, weights) lr_score = lr.coef_ mg.nodes["lr_score"] = lr_score mg.nodes.sort_values("lr_score", inplace=True) from src.visualization import adjplot, CLASS_COLOR_DICT adjplot( mg.sum.adj, meta=mg.nodes, colors="merge_class", palette=CLASS_COLOR_DICT, item_order="lr_score", plot_type="scattermap", sizes=(2, 2), ) #%% sns.histplot(lr_score) #%% adj = mg.sum.adj.copy() adj = remove_loops(adj) H = adj - adj.T
H = ranks[:, None] - ranks[None, :] - 1 H = np.multiply(H, H) H *= 0.5 P = np.exp(-beta * H) P /= np.mean(P) * len(P) P *= degree # TODO not sure this matches the paper exactly but makes sense to me return P P = construct_spring_rank_P(X, beta, k) A = rng.poisson(P) fig, axs = plt.subplots(1, 2, figsize=(15, 7.5)) ax = axs[0] adjplot(P, ax=ax, title=r"$P$", cbar=False) ax = axs[1] adjplot(A, ax=ax, title=r"$A$", color="darkred", plot_type="scattermap", sizes=(2, 5)) stashfig("p-and-adj") #%% [markdown] # If we change the parameters to be point masses for the 3 different groups, we get # a specific kind of feedforward SBM model. #%% n_per_group = 100 X1 = np.ones(n_per_group)
print(f"{len(lcc_inds)} in intersection of largest connected components.") print(f"Original number of valid pairs: {len(lp_inds)}") # left_meta = left_meta.iloc[lcc_inds] # right_meta = right_meta.iloc[lcc_inds] # meta = pd.concat((left_meta, right_meta)) n_pairs = len(ipsi_adj) print(f"Number of pairs after taking LCC intersection: {n_pairs}") #%% fig, axs = plt.subplots(1, 2, figsize=(10, 5)) ax = axs[0] adjplot(ipsi_adj, ax=ax, plot_type="scattermap", sizes=(1, 1), color=palette["Ipsi"]) ax = axs[1] adjplot(contra_adj, ax=ax, plot_type="scattermap", sizes=(1, 1), color=palette["Contra"]) #%% max_n_components = 40 from giskard.utils import careys_rule ase = AdjacencySpectralEmbed(n_components=max_n_components) ipsi_out_latent, ipsi_in_latent = ase.fit_transform(ipsi_adj)
right_meta = meta.iloc[rp_inds] plot_kws = dict( plot_type="scattermap", sort_class="merge_class", item_order=["pair_td", "Pair ID"], colors="merge_class", palette=CLASS_COLOR_DICT, ticks=False, class_order="pair_td", sizes=(1, 1), gridline_kws=dict(linewidth=0.2, color="grey", linestyle="--"), ) fig, axs = plt.subplots(1, 2, figsize=(20, 10)) _, _, top, _ = adjplot(ll_adj, ax=axs[0], meta=left_meta, **plot_kws) top.set_title(r"L $\to$ L") _, _, top, _ = adjplot(rr_adj, ax=axs[1], meta=right_meta, **plot_kws) top.set_title(r"R $\to$ R") plt.tight_layout() stashfig("ipsilateral-adj") lr_adj = adj[np.ix_(lp_inds, rp_inds)] rl_adj = adj[np.ix_(rp_inds, lp_inds)] fig, axs = plt.subplots(1, 2, figsize=(20, 10)) _, _, top, _ = adjplot(lr_adj, ax=axs[0], meta=left_meta, **plot_kws) top.set_title(r"L $\to$ R") _, _, top, _ = adjplot(rl_adj, ax=axs[1], meta=right_meta, **plot_kws) top.set_title(r"R $\to$ L") plt.tight_layout()
) ax.set_yticks([]) ax.get_legend().remove() stashfig(f"prop-barplot-lvl{i}" + basename) plt.close() for i in range(n_levels): fig, ax = plt.subplots(1, 1, figsize=(20, 20)) adjplot( mc.adj, meta=mc.meta, sort_class=f"lvl{i}_labels_side", item_order="merge_class", plot_type="scattermap", sizes=(0.5, 1), ticks=False, colors="merge_class", ax=ax, palette=CLASS_COLOR_DICT, gridline_kws=dict(linewidth=0.2, color="grey", linestyle="--"), ) stashfig(f"adj-lvl{i}" + basename) # %% [markdown] # ## uni, counts = np.unique(mc.meta["lvl6_labels"], return_counts=True) max_ind = np.argmax(counts) uni[max_ind] # %% [markdown]
return sgm.score_, sgm.perm_inds_ outs = Parallel(n_jobs=-1)(delayed(run_gmp)(seed) for seed in seeds) outs = list(zip(*outs)) scores = outs[0] perms = outs[1] max_ind = np.argmax(scores) optimal_perm = perms[max_ind] perm_df[f"a{alpha}"] = optimal_perm perm_inds = optimal_perm perm_adj = adj[np.ix_(perm_inds, perm_inds)] perm_meta = meta.iloc[perm_inds, :].copy() fig, ax = plt.subplots(1, 1, figsize=(20, 20)) adjplot( perm_adj, meta=perm_meta, plot_type="scattermap", sizes=(1, 10), ax=ax, colors="merge_class", palette=CLASS_COLOR_DICT, ) stashfig(f"adj-perm-left-alpha={alpha:.5f}") stashcsv(perm_df, "permuatations" + basename) stashcsv(meta, "meta" + basename) adj_df = pd.DataFrame(adj, index=meta.index, columns=meta.index) stashcsv(adj_df, "adj" + basename)
stashfig(f"pairs" + basename) 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)) adjplot( adj, ax=ax, meta=meta, sort_class="pred_side", class_order="group_signal_flow", colors="merge_class", palette=CLASS_COLOR_DICT, 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)) adjplot( adj, ax=ax, meta=meta, sort_class="pred_side",
names = names[::-1] palplot(len(colors), colors, ax=ax) ax.yaxis.set_major_formatter(plt.FixedFormatter(names)) # plt.tight_layout() model = DCSBMEstimator for level in np.arange(lowest_level + 1): ax = fig.add_subplot(gs[:3, level + 4]) adj = binarize(full_mg.adj) _, _, top, _ = adjplot( adj, ax=ax, plot_type="scattermap", sizes=(0.5, 0.5), sort_class=["hemisphere"] + level_names[:level + 1], item_order=["merge_class_sf_order", "merge_class", "sf"], class_order="sf", meta=full_mg.meta, palette=CLASS_COLOR_DICT, colors="merge_class", ticks=False, gridline_kws=dict(linewidth=0.2, color="grey", linestyle="--"), ) top.set_title(f"Level {level} - Data") labels = full_mg.meta[f"lvl{level}_labels_side"] estimator = model(directed=True, loops=True) uni_labels, inv = np.unique(labels, return_inverse=True) estimator.fit(adj, inv) p_hat = estimator.p_mat_ sample_adj = np.squeeze(estimator.sample()) # p_hat[p_hat == 0] = 1 / p_hat.size ax = fig.add_subplot(gs[3:, level + 4])
# adj_df = pd.DataFrame(adj, index=meta.index, columns=meta.index) adj_df = readcsv("adj" + basename, foldername=exp_name, index_col=0) adj = adj_df.values alpha = 0.00021 alpha = np.round(alpha, decimals=5) str_alpha = f"a{alpha}" perm_inds = perm_df[str_alpha] perm_adj = adj[np.ix_(perm_inds, perm_inds)] perm_meta = meta.iloc[perm_inds].copy() fig, ax = plt.subplots(1, 1, figsize=(20, 20)) adjplot( perm_adj, meta=perm_meta, colors="merge_class", palette=CLASS_COLOR_DICT, plot_type="scattermap", sizes=(1, 10), ax=ax, ) # %% [markdown] # ## from src.hierarchy import signal_flow from src.visualization import remove_axis import pandas as pd n_verts = len(adj) sf = signal_flow(adj) sf_perm = np.argsort(-sf) inds = np.arange(n_verts)
# %% meta = mb_mg.meta print("n_left") print(len(meta[meta["left"]])) print("n_right") print(len(meta[meta["right"]])) fig, ax = plt.subplots(1, 1, figsize=(10, 10)) adjplot( pass_to_ranks(mb_mg.adj), meta=mb_mg.meta, sort_class=["hemisphere", "class1"], class_order=["class1_sizes"], item_order=["class1", "Total edgesum"], cbar=False, row_tick_pad=[0.05, 0.7], col_tick_pad=[0.2, 0.7], tick_rot=90, tick_fontsize=12, gridline_kws=dict(color="grey", linestyle="--", linewidth=0.5), ax=ax, ) left_mb_mg = mb_mg.reindex(meta[meta["left"]].index, use_ids=True, inplace=False) right_mb_mg = mb_mg.reindex(meta[meta["right"]].index, use_ids=True, inplace=False) assert ( np.unique(left_mb_mg.meta["pair_id"]) == np.unique(right_mb_mg.meta["pair_id"]) ).all()
from src.visualization import adjplot fig, ax = plt.subplots(1, 1, figsize=(20, 20)) ax.plot( (0, len(mg.adj)), (0, len(mg.adj)), linewidth=2, color="red", linestyle="--", alpha=0.5, ) adjplot( mg.adj, meta=meta, item_order=["voltage", "rand"], plot_type="scattermap", ax=ax, colors="merge_class", palette=CLASS_COLOR_DICT, sizes=(1, 2), ) # %% [markdown] # ## vdiff = np.squeeze(v[:, np.newaxis] - v[np.newaxis, :]) curr = np.abs(W * vdiff) curr_node = np.sum(curr, axis=1) # current from each node meta["voltage"] = v meta["curr"] = curr_node sns.scatterplot(data=meta, x="curr", y="voltage")
P *= np.mean(A) / np.mean(P) # TODO I might be off by a constant here return P #%% for graph_type in graph_types: adj = graphs[graph_type] A, inds = get_lcc(adj, return_inds=True) ranks = sr.get_ranks(A) beta = sr.get_inverse_temperature(A, ranks) P = estimate_spring_rank_P(A, ranks, beta) sort_inds = np.argsort(-ranks) fig, axs = plt.subplots(1, 2, figsize=(10, 5)) adjplot(P[np.ix_(sort_inds, sort_inds)], ax=axs[0], cbar=False, title=r"$\hat{P}$") adjplot( A[np.ix_(sort_inds, sort_inds)], plot_type="scattermap", ax=axs[1], sizes=(1, 1), title=r"$A$", ) fig.suptitle(graph_type_names[graph_type]) #%% def swap_edges(A): swapped_A = A.copy()
# ## meta = mc.meta.copy() meta["rand"] = np.random.uniform(size=len(meta)) sf = signal_flow(adj) meta["signal_flow"] = -sf meta["te"] = -meta["Total edgesum"] # %% [markdown] # ## plot by class and randomly within class fig, ax = plt.subplots(1, 1, figsize=(20, 20)) adjplot( adj, meta=meta, sort_class=["0_pred_side"], colors="merge_class", palette=CLASS_COLOR_DICT, item_order=["merge_class", "rand"], plot_type="scattermap", sizes=(0.5, 1), ax=ax, ) stashfig("adj-lvl0") fig, ax = plt.subplots(1, 1, figsize=(20, 20)) adjplot( adj, meta=meta, sort_class=["0_pred_side", "1_pred_side"], colors="merge_class", palette=CLASS_COLOR_DICT, item_order=["merge_class", "rand"], plot_type="scattermap",
mg = load_metagraph("G") mg.calculate_degrees(inplace=True) adj = mg.adj # adjacency matrix from the "mg" object meta = mg.meta # dataframe of node metadata # %% [markdown] # ## fig, ax = plt.subplots(1, 1, figsize=(15, 15)) adjplot( adj, meta=meta, sort_class= "hemisphere", # group by hemisphere, this is a key for column in "meta" plot_type="scattermap", # plot dots instead of a heatmap sizes=(1, 1), # min and max sizes for dots, so this is effectively binarizing item_order= "Pair ID", # order by pairs (some have no pair here so don't look same) ax=ax, ) # %% [markdown] # ## fig, ax = plt.subplots(1, 1, figsize=(15, 15)) adjplot( adj, # can also try "pass_to_ranks" here, see below meta=meta, sort_class="hemisphere", plot_type="scattermap", sizes=(0.2, 10), # can try to leave some dynamic range for weights