def plot_latent_sweep(latent, n_pairs):
for d in range(latent.shape[1]):
dim = latent[:, d]
fig, ax = plt.subplots(1, 1, figsize=(10, 10))
data_df = pd.DataFrame()
data_df["Label"] = n_pairs * ["Left"] + n_pairs * ["Right"]
data_df["Latent"] = dim[:2 * n_pairs]
data_df["Index"] = list(range(n_pairs)) + list(range(n_pairs))
ax = sns.scatterplot(data=data_df,
x="Index",
y="Latent",
hue="Label",
ax=ax,
s=15)
add_connections(
range(n_pairs),
range(n_pairs),
dim[:n_pairs],
dim[n_pairs:2 * n_pairs],
ax=ax,
color="grey",
)
remove_spines(ax)
ax.xaxis.set_major_locator(plt.FixedLocator([0]))
ax.yaxis.set_major_locator(plt.FixedLocator([0]))
ax.set_title(f"Dimension {d}")
def plot_connectors(data, Z, x, y, ax, mins, maxs):
sns.scatterplot(
data=data,
y=plot_vars[y],
x=plot_vars[x],
s=3,
alpha=0.05,
ax=ax,
linewidth=0,
color="black",
)
unused = np.setdiff1d([0, 1, 2], [x, y])[0]
projection = Z.sum(axis=unused)
if x > y:
projection = projection.T
ax.imshow(
np.rot90(projection), # integrate out the unused dim
cmap=plt.cm.Reds,
extent=[mins[x], maxs[x], mins[y], maxs[y]],
vmin=0,
)
ax.set_xlim([mins[x], maxs[x]])
ax.set_ylim([maxs[y], mins[y]])
ax.set_xticks([])
ax.set_yticks([])
ax.set_xlabel("")
ax.set_ylabel("")
remove_spines(ax)
prob_mat[:, t] = np.squeeze(new_state_vec)
state_vec = new_state_vec
sensory_mats.append(prob_mat)
# %% [markdown]
# #
from src.visualization import remove_spines
plot_df = pd.DataFrame(data=sensory_mats[0], columns=list(range(n_timesteps)))
# plot_df["Merge Class"] = mg.meta["Merge Class"]
# plot_df["ind"] = range(len(plot_df))
i = 21
fig, ax = plt.subplots(n_timesteps, 1, figsize=(5, 10))
for t in range(n_timesteps):
ax[t].plot(sensory_mats[i][:, t])
remove_spines(ax[t])
plt.suptitle(mg.meta.iloc[sensory_inds[i], 0] + " " +
mg.meta.iloc[sensory_inds[i], 10])
# %% [markdown]
# #
from sklearn.decomposition import PCA
pca = PCA(n_components=2)
X = np.array(sensory_mats)
X = X.reshape((len(sensory_inds), -1))
pcs = pca.fit_transform(X)
df = pd.DataFrame(data=pcs)
df["class"] = mg.meta.loc[is_sensory, "Merge Class"]
sns.scatterplot(data=df, x=0, y=1, hue="class")
height = max_y - min_y
x_label = bound_df.index[x]
y_label = bound_df.index[y]
edge = blockmodel_edges[
(blockmodel_edges["source"] == y_label)
& (blockmodel_edges["target"] == x_label)
]
rect = patches.Rectangle((min_x, min_y), width, height)
main_ax.add_patch(rect)
main_ax.set_xlabel("")
main_ax.set_ylabel("")
remove_spines(main_ax)
divider = make_axes_locatable(main_ax)
meta = full_meta.copy()
left_ax = divider.append_axes("left", size="20%", pad=0, sharey=main_ax)
ax = left_ax
# ax.set_ylim((-gap, (2 * n_pairs + gap * n_leaf)))
ax.set_xlim((-0.5, lowest_level + 0.5))
draw_bar_dendrogram(meta, ax)
ax.set_yticks([])
ax.spines["left"].set_visible(False)
ax.set_xlabel("Level")
ax.set_xticks(np.arange(lowest_level + 1))
ax.spines["bottom"].set_visible(False)
def run_experiment(seed=None, graph_type=None, threshold=None, param_key=None):
np.random.seed(seed)
if BLIND:
temp_param_key = param_key.replace(
" ", "") # don't want spaces in filenames
savename = f"{temp_param_key}-cell-types-"
title = param_key
else:
savename = f"{graph_type}-t{threshold}-cell-types"
title = f"{graph_type}, threshold = {threshold}"
mg = load_metagraph(graph_type, version=VERSION)
# simple threshold
# TODO they will want symmetric threshold...
# TODO maybe make that a parameter
adj = mg.adj.copy()
adj[adj <= threshold] = 0
meta = mg.meta.copy()
meta = pd.DataFrame(mg.meta["neuron_name"])
mg = MetaGraph(adj, meta)
# run the graphtool code
temp_loc = f"maggot_models/data/interim/temp-{param_key}.graphml"
block_series = run_minimize_blockmodel(mg, temp_loc)
# manage the output
mg = load_metagraph(graph_type, version=VERSION)
mg.meta = pd.concat((mg.meta, block_series), axis=1)
mg.meta["Original index"] = range(len(mg.meta))
keep_inds = mg.meta[~mg.meta["block_label"].isna(
)]["Original index"].values
mg.reindex(keep_inds)
if graph_type != "G":
mg.verify(10000, graph_type=graph_type, version=VERSION)
# deal with class labels
lineage_labels = mg.meta["lineage"].values
lineage_labels = np.vectorize(lambda x: "~" + x)(lineage_labels)
class_labels = mg["Merge Class"]
skeleton_labels = mg.meta.index.values
classlin_labels, color_dict, hatch_dict = augment_classes(
skeleton_labels, class_labels, lineage_labels)
block_label = mg["block_label"].astype(int)
# barplot with unknown class labels merged in, proportions
_, _, order = barplot_text(
block_label,
classlin_labels,
norm_bar_width=True,
color_dict=color_dict,
hatch_dict=hatch_dict,
title=title,
figsize=(24, 18),
return_order=True,
)
stashfig(savename + "barplot-mergeclasslin-props")
category_order = np.unique(block_label)[order]
# barplot with regular class labels
barplot_text(
block_label,
class_labels,
norm_bar_width=True,
color_dict=color_dict,
hatch_dict=hatch_dict,
title=title,
figsize=(24, 18),
category_order=category_order,
)
stashfig(savename + "barplot-mergeclass-props")
# barplot with unknown class labels merged in, counts
barplot_text(
block_label,
classlin_labels,
norm_bar_width=False,
color_dict=color_dict,
hatch_dict=hatch_dict,
title=title,
figsize=(24, 18),
return_order=True,
category_order=category_order,
)
stashfig(savename + "barplot-mergeclasslin-counts")
# barplot of hemisphere membership
fig, ax = plt.subplots(1, 1, figsize=(10, 20))
stacked_barplot(
block_label,
mg["Hemisphere"],
norm_bar_width=True,
category_order=category_order,
ax=ax,
)
remove_spines(ax)
stashfig(savename + "barplot-hemisphere")
# plot block probability matrix
counts = False
weights = False
prob_df = get_blockmodel_df(mg.adj,
block_label,
return_counts=counts,
use_weights=weights)
prob_df = prob_df.reindex(order, axis=0)
prob_df = prob_df.reindex(order, axis=1)
ax = probplot(100 * prob_df,
fmt="2.0f",
figsize=(20, 20),
title=title,
font_scale=0.4)
stashfig(savename + "probplot")
block_series.name = param_key
return block_series
plot_df["P(mirror edge present)"] = props
plot_df["Proportion of edges left"] = prop_edges
plot_df["Proportion of synapses left"] = prop_syns
fig, ax = plt.subplots(1, 1, figsize=(10, 5))
sns.lineplot(data=plot_df, x="Threshold", y="P(mirror edge present)", ax=ax)
ax_right = ax.twinx()
sns.lineplot(
data=plot_df,
x="Threshold",
y="Proportion of synapses left",
ax=ax_right,
color="orange",
)
remove_spines(ax_right)
remove_spines(ax)
ax.set_ylim((0, 1))
ax_right.set_ylim((0, 1))
ax.set_title(f"{graph_type}")
stashfig(f"thresh-sweep-{graph_type}-brain-syns")
# %% [markdown]
# # Plot these against each other
fig, ax = plt.subplots(1, 1, figsize=(10, 10))
sns.scatterplot(data=plot_df, x="P(mirror edge present)", y="Proportion of edges left")
ax.set_xlim((0, 1.1))
ax.set_ylim((0, 1.1))
remove_spines(ax)
stashfig(f"thresh-sweep-paired-{graph_type}-brain")
# %% [markdown]
max_pair_edge_df = edgelist_df.groupby("edge pair ID").max()
edge_max_weight_map = dict(
zip(max_pair_edge_df.index.values, max_pair_edge_df["weight"])
)
edgelist_df["max_weight"] = itemgetter(*edgelist_df["edge pair ID"])(
edge_max_weight_map
)
thresh_result_df = threshold_sweep(edgelist_df, max_pair_edge_df)
fig, ax = plt.subplots(1, 1, figsize=(10, 6))
sns.lineplot(
data=thresh_result_df, x="threshold", y="Prop. paired edges symmetric", ax=ax
)
remove_spines(ax)
ax_right = plt.twinx(ax)
sns.lineplot(
data=thresh_result_df,
x="threshold",
y="Prop. edges left",
ax=ax_right,
color="orange",
label="Edges",
)
remove_spines(ax_right)
sns.lineplot(
data=thresh_result_df,
x="threshold",
y="Prop. synapses left",
ax=ax_right,
def remove_axis(ax):
remove_spines(ax)
ax.set_xlabel("")
ax.set_ylabel("")
ax.set_xticks([])
ax.set_yticks([])
palette=cc.glasbey_light[:n_unique],
hue="Label",
ax=ax,
s=20,
)
add_connections(
latent[:n_pairs, dim1],
latent[n_pairs:2 * n_pairs, dim1],
latent[:n_pairs, dim2],
latent[n_pairs:2 * n_pairs, dim2],
ax=ax,
color="grey",
)
remove_spines(ax)
ax.xaxis.set_major_locator(plt.FixedLocator([0]))
ax.yaxis.set_major_locator(plt.FixedLocator([0]))
stashfig(f"trunc-max-sym-dim{dim1}-vs-dim{dim2}")
plt.close()
# %% [markdown]
# #
import pandas as pd
from bokeh.layouts import column, row
from bokeh.models import Select
from bokeh.palettes import Spectral5
from bokeh.plotting import curdoc, figure, show
from bokeh.sampledata.autompg import autompg_clean as df
from bokeh.io import output_notebook, output_file
plot_df["merge_class"] = meta["merge_class"].values
ax = axs[0]
sns.scatterplot(
data=plot_df,
x=0,
y=1,
hue="merge_class",
palette=CLASS_COLOR_DICT,
legend=False,
ax=ax,
s=20,
linewidth=0.5,
alpha=0.7,
)
# ax.axis("off")
remove_spines(ax)
ax.set_xlabel("")
ax.set_ylabel("")
ax.set_xticks([])
ax.set_yticks([])
ax.spines["right"].set_visible(True)
ax.set_title("Before Procrustes")
add_connections(
plot_df.iloc[lp_inds, 0],
plot_df.iloc[rp_inds, 0],
plot_df.iloc[lp_inds, 1],
plot_df.iloc[rp_inds, 1],
ax=ax,
)
left_inds = meta[meta["left"]]["inds"]
# cluster = GaussianCluster(
# min_components=2, max_components=10, covariance_type="all", n_init=100
# )
cluster = AutoGMMCluster(min_components=2, max_components=10)
pred_labels = cluster.fit_predict(latent)
ari = adjusted_rand_score(true_labels, pred_labels)
row = {"ARI": ari, "Threshold": threshold, "Method": "GMMoASE"}
rows.append(row)
# do the MCMC
block_series = run_minimize_blockmodel(mg, weight_model="discrete-poisson")
ari = adjusted_rand_score(true_labels, block_series.values)
row = {"ARI": ari, "Threshold": threshold, "Method": "GT-dp"}
rows.append(row)
# do the MCMC
block_series = run_minimize_blockmodel(mg, weight_model=None)
ari = adjusted_rand_score(true_labels, block_series.values)
row = {"ARI": ari, "Threshold": threshold, "Method": "GT-None"}
rows.append(row)
# %% [markdown]
# #
result_df = pd.DataFrame(rows)
fig, ax = plt.subplots(1, 1, figsize=(10, 5))
sns.lineplot(data=result_df, x="Threshold", y="ARI", ax=ax, hue="Method")
remove_spines(ax, keep_corner=True)
ax.set_title(f"Mushroom Body, n_components={n_components}")
stashfig(f"mb-nc{n_components}-tr{threshold_raw}")