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
