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
