def _plot_bars(self, pred_side): ax = stacked_barplot( pred_side, self.meta["merge_class"], color_dict=CLASS_COLOR_DICT, legend_ncol=6, category_order=np.unique(pred_side), ) k = int(len(np.unique(pred_side)) / 2) ax.set_title(f"{self.name}, k={k}") self._stashfig(f"bars-k={k}")
def one_iteration(start_labels, class_key="Merge Class"): # generate walks data, bins, classes = random_walk_classes(start_labels, seed=None, class_key=class_key) log_data = np.log10(data + 1) # plot the clustermap path_clustermap(log_data, classes, bins) # embed and plot by known class embedding = PCA(n_components=8).fit_transform(log_data) pairplot(embedding, labels=classes, palette=CLASS_COLOR_DICT) # cluster agm = AutoGMMCluster(min_components=2, max_components=20, n_jobs=-1, verbose=10) pred_labels = agm.fit_predict(embedding) plt.figure() sns.scatterplot(data=agm.results_, x="n_components", y="bic/aic") # plot embedding by cluster pairplot(embedding, labels=pred_labels, palette=cc.glasbey_light) # plot predicted clusters by known class stacked_barplot(pred_labels, classes, color_dict=CLASS_COLOR_DICT) return pred_labels
def bartreeplot( dc, class_labels, show_props=True, print_props=True, text_pad=0.01, inverse_memberships=True, figsize=(24, 23), title=None, palette=cc.glasbey_light, color_dict=None, ): # gather necessary info from model linkage, labels = dc.build_linkage( bic_distance=False) # hackily built like scipy's pred_labels = dc.predict(latent) uni_class_labels, uni_class_counts = np.unique(class_labels, return_counts=True) uni_pred_labels, uni_pred_counts = np.unique(pred_labels, return_counts=True) # set up the figure fig = plt.figure(figsize=figsize) r = fig.canvas.get_renderer() gs0 = plt.GridSpec(1, 2, figure=fig, width_ratios=[0.2, 0.8], wspace=0) gs1 = plt.GridSpec(1, 1, figure=fig, width_ratios=[0.2], wspace=0.1) # title the plot plt.suptitle(title, y=0.92, fontsize=30, x=0.5) # plot the dendrogram ax0 = fig.add_subplot(gs0[0]) dendr_data = dendrogram( linkage, orientation="left", labels=labels, color_threshold=0, above_threshold_color="k", ax=ax0, ) ax0.axis("off") ax0.set_title("Dendrogram", loc="left") # get the ticks from the dendrogram to apply to the bar plot ticks = ax0.get_yticks() # plot the barplot (and ticks to the right of them) leaf_names = np.array(dendr_data["ivl"])[::-1] ax1 = fig.add_subplot(gs0[1], sharey=ax0) ax1, prop_data, uni_class, subcategory_colors = stacked_barplot( pred_labels, class_labels, label_pos=ticks, category_order=leaf_names, ax=ax1, bar_height=5, horizontal_pad=0, palette=palette, norm_bar_width=show_props, return_data=True, color_dict=color_dict, ) ax1.set_frame_on(False) ax1.yaxis.tick_right() if show_props: ax1_title = "Cluster proportion of known cell types" else: ax1_title = "Cluster counts by known cell types" ax1_title = ax1.set_title(ax1_title, loc="left") transformer = ax1.transData.inverted() bbox = ax1_title.get_window_extent(renderer=r) bbox_points = bbox.get_points() out_points = transformer.transform(bbox_points) xlim = ax1.get_xlim() ax1.text(xlim[1], out_points[0][1], "Cluster name (size)", verticalalignment="bottom") # plot the cluster compositions as text to the right of the bars gs0.update(right=0.4) ax2 = fig.add_subplot(gs1[0], sharey=ax0) ax2.axis("off") gs1.update(left=0.48) text_kws = { "verticalalignment": "center", "horizontalalignment": "left", "fontsize": 12, "alpha": 1, "weight": "bold", } ax2.set_xlim((0, 1)) transformer = ax2.transData.inverted() cluster_sizes = prop_data.sum(axis=1) for i, y in enumerate(ticks): x = 0 for j, (colname, color) in enumerate(zip(uni_class, subcategory_colors)): prop = prop_data[i, j] if prop > 0: if inverse_memberships: prop = prop / uni_class_counts[j] name = f"{colname} ({prop:3.0%})" else: if print_props: name = f"{colname} ({prop / cluster_sizes[i]:3.0%})" else: name = f"{colname} ({prop})" text = ax2.text(x, y, name, color=color, **text_kws) bbox = text.get_window_extent(renderer=r) bbox_points = bbox.get_points() out_points = transformer.transform(bbox_points) width = out_points[1][0] - out_points[0][0] x += width + text_pad # deal with title for the last plot column based on options if inverse_memberships: ax2_title = "Known cell type (percentage of cell type in cluster)" else: if print_props: ax2_title = "Known cell type (percentage of cluster)" else: ax2_title = "Known cell type (count in cluster)" ax2.set_title(ax2_title, loc="left")
# %% from src.visualization import stacked_barplot labels = meta["merge_class"].values uni_labels, counts = np.unique(labels, return_counts=True) inds = np.argsort(-counts) paired = meta["Pair ID"] != -1 fig, axs = plt.subplots(1, 2, figsize=(20, 20)) ax = axs[0] ax, data, uni_subcat, subcategory_colors, order, = stacked_barplot( labels, labels, color_dict=CLASS_COLOR_DICT, category_order=uni_labels[inds], norm_bar_width=False, ax=ax, return_data=True, ) ax.get_legend().remove() ax.set_title("Class membership") ax = axs[1] ax, data, uni_subcat, subcategory_colors, order, = stacked_barplot( labels, paired, category_order=uni_labels[inds], norm_bar_width=False, ax=ax, return_data=True,
stashfig("ffwdness-by-model") # %% [markdown] # ## make barplots from src.visualization import barplot_text lvls = ["lvl0_labels", "lvl1_labels", "lvl2_labels"] for lvl in lvls: pred_labels = meta[lvl] true_labels = meta["merge_class"].values fig, ax = plt.subplots(1, 1, figsize=(15, 20)) stacked_barplot( pred_labels, true_labels, category_order=np.unique(pred_labels), color_dict=CLASS_COLOR_DICT, ax=ax, ) stashfig(f"barplot-no-text-lvl-{lvl}", dpi=200) # %% [markdown] # ## meta["lvl0_labels"] = meta["0_pred"] meta["lvl1_labels"] = meta["0_pred"] + "-" + meta["1_pred"] meta["lvl2_labels"] = meta["0_pred"] + "-" + meta["1_pred"] + "-" + meta[ "2_pred"] meta["lvl0_labels_side"] = meta["lvl0_labels"] + meta["hemisphere"] meta["lvl1_labels_side"] = meta["lvl1_labels"] + meta["hemisphere"] meta["lvl2_labels_side"] = meta["lvl2_labels"] + meta["hemisphere"]
ase = AdjacencySpectralEmbed(n_components=n_components) latent = ase.fit_transform(lap) latent = np.concatenate(latent, axis=-1) return latent n_components = None k = 30 latent = lse(adj, n_components, regularizer=None) gmm = GaussianCluster(min_components=k, max_components=k) pred_labels = gmm.fit_predict(latent) stacked_barplot(pred_labels, class_labels, palette="tab20") # %% [markdown] # # verify on sklearn toy dataset from sklearn.datasets import make_blobs from sklearn.cluster import KMeans X, y = make_blobs(n_samples=200, n_features=3, centers=None, cluster_std=3) # y = y.astype(int).astype(str) data_df = pd.DataFrame( data=np.concatenate((X, y[:, np.newaxis]), axis=-1), columns=("Dim 0", "Dim 1", "Dim 2", "Labels"), ) # data_df["Labels"] = data_df["Labels"].values.astype("<U10") sns.scatterplot(data=data_df, x="Dim 1",
basename = f"louvain-res{r}-t{thresh}-{graph_type}-" title = f"Louvain, {graph_type}, res = {r}, thresh = {thresh}" # barplot by merge class label (more detail) class_label_dict = nx.get_node_attributes(g_sym, "Merge Class") class_labels = np.array( itemgetter(*skeleton_labels)(class_label_dict)) part_color_dict = dict(zip(np.unique(partition), cc.glasbey_warm)) true_color_dict = dict(zip(names, colors)) color_dict = {**part_color_dict, **true_color_dict} fig, ax = plt.subplots(1, 1, figsize=(20, 20)) stacked_barplot( partition, class_labels, ax=ax, color_dict=color_dict, plot_proportions=False, norm_bar_width=True, category_order=sort_partition_sf.index.values, ) ax.set_title(title) ax.set_ylabel(r"Median signal flow $\to$", fontsize=28) stashfig(basename + "barplot-mergeclass") # sorted heatmap heatmap( mg.adj, transform="simple-nonzero", figsize=(20, 20), inner_hier_labels=partition, hier_label_fontsize=10,
ax.set_ylabel("Prop. in upper triangle") ax.set_xlabel("Model") stashfig("ffwdness-by-model") # %% [markdown] # ## make barplots from src.visualization import barplot_text lvls = ["lvl0_labels", "lvl1_labels", "lvl2_labels"] for lvl in lvls: pred_labels = meta[lvl] true_labels = meta["merge_class"].values fig, ax = plt.subplots(1, 1, figsize=(15, 20)) stacked_barplot(pred_labels, true_labels, color_dict=CLASS_COLOR_DICT, ax=ax) stashfig(f"barplot-no-text-lvl-{lvl}", dpi=200) # %% [markdown] # ## start_instance() # labels = meta["lvl2_labels"].values for tp in meta["lvl2_labels"].unique(): ids = list(meta[meta["lvl2_labels"] == tp].index.values) ids = [int(i) for i in ids] fig = plt.figure(figsize=(30, 10)) gs = plt.GridSpec(2, 3,
min_split=4, ) mc.fit(n_levels=n_levels, metric=metric) n_levels = mc.height show_bars = False if show_bars: fig, axs = plt.subplots(1, n_levels, figsize=(8 * n_levels, 30)) for i in range(n_levels): ax = axs[i] 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, ) ax.set_yticks([]) ax.get_legend().remove() ax.set_title(title) plt.tight_layout() stashfig(f"count-barplot-lvl{i}" + basename) plt.close() inds = np.concatenate((lp_inds, rp_inds)) new_adj = adj[np.ix_(inds, inds)] new_meta = mc.meta
left=margin + 3 / n_col + gap, right=margin + 5 / n_col + gap, bottom=margin, top=1 - margin, ) # ax = fig.add_subplot(mid_gs[0, 0]) ax = fig.add_subplot(mid_gs[0, 1:]) cat = temp_meta[f"lvl{level}_labels_side"].values subcat = temp_meta["merge_class"].values stacked_barplot( cat, subcat, 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,
color_threshold=0, above_threshold_color="k", ax=ax0, ) ax0.axis("off") ticks = ax0.get_yticks() leaf_names = np.array(dendr_data["ivl"])[::-1] ax1 = fig.add_subplot(gs0[1], sharey=ax0) ax1, prop_data, uni_class, subcategory_colors = stacked_barplot( pred_labels, class_labels, label_pos=ticks, category_order=leaf_names, ax=ax1, bar_height=5, horizontal_pad=0, palette="tab20", norm_bar_width=show_props, return_data=True, ) ax1.set_frame_on(False) ax1.yaxis.tick_right() gs0.update(right=0.5) ax2 = fig.add_subplot(gs1[0], sharey=ax0) ax2.axis("off") gs1.update(left=0.6) text_kws = { "verticalalignment": "center",
linkage, orientation="left", labels=labels, color_threshold=0, above_threshold_color="k", ax=ax0, ) ax0.axis("off") ticks = ax0.get_yticks() leaf_names = np.array(dendr_data["ivl"])[::-1] ax1 = fig.add_subplot(gs[1], sharey=ax0) ax1 = stacked_barplot( pred_labels, class_labels, label_pos=ticks, category_order=leaf_names, ax=ax1, bar_height=5, horizontal_pad=0, palette="tab20", norm_bar_width=True, ) ax1.set_frame_on(False) ax1.yaxis.tick_right() plt.title( r"Divisive hierarchical clustering, GraspyGMM, LSE, PTR, Full Brain, A $\to$ D" ) stashfig("hierarchy-bars")
norm_embed_spherical = n_sphere.convert_spherical(norm_embed) norm_embed_spherical = norm_embed_spherical[:, 1:] # chop off R dimension pg = pairplot(norm_embed_spherical, labels=labels, palette=CLASS_COLOR_DICT) pg._legend.remove() # %% [markdown] # ## from sklearn.cluster import AgglomerativeClustering for k in range(2, 10): ag = AgglomerativeClustering(n_clusters=k, affinity="cosine", linkage="average") pred_labels = ag.fit_predict(norm_embed) ax = stacked_barplot(pred_labels, labels, color_dict=CLASS_COLOR_DICT) ax.set_title(f"k={k}") # %% [markdown] # ## new np.random.seed(8888) mc = MaggotCluster( "0", adj=adj, meta=meta, n_init=50, stashfig=stashfig, max_clusters=8, n_components=None, embed="unscaled_ase", reembed=True, realign=True,
plt.tight_layout() plt.rcParams["figure.facecolor"] = "w" plt.rcParams["savefig.facecolor"] = "w" stashfig(f"gmm-crossval-pairs-k={k}-n_components={n_components}") stashfig(f"gmm-crossval-pairs-k={k}-n_components={n_components}", fmt="pdf") # %% [markdown] # ## from src.visualization import barplot_text, stacked_barplot # barplot_text(pred, meta["merge_class"].values, color_dict=CLASS_COLOR_DICT) stacked_barplot(pred, meta["merge_class"].values, color_dict=CLASS_COLOR_DICT, legend_ncol=4) stashfig(f"gmm-crossval-barplot-k={k}-n_components={n_components}") # %% [markdown] # ## SUBCLUSTER ! from scipy.optimize import linear_sum_assignment def compute_pairedness(partition, meta, rand_adjust=False, plot=False): partition = partition.copy() meta = meta.copy() uni_labels, inv = np.unique(partition, return_inverse=True)
model = results.loc[ind, "model"] pred = predict(joint_embed, left_inds, right_inds, model, relabel=False) plot_cluster_pairs( joint_embed, left_inds, right_inds, model, meta["merge_class"].values, lp_inds, rp_inds, ) # %% [markdown] # ## stacked_barplot(pred, meta["merge_class"].values, color_dict=CLASS_COLOR_DICT) # %% meta["inds"] = range(len(meta)) left_inds = meta[meta["left"]]["inds"] right_inds = meta[meta["right"]]["inds"] lp_inds, rp_inds = get_paired_inds(meta) results = crossval_cluster( embed, left_inds, right_inds, min_clusters=2, max_clusters=10, left_pair_inds=lp_inds, right_pair_inds=rp_inds,
# sub_partition.values, # comm_mg["Merge Class"], # color_dict=color_dict, # plot_proportions=False, # norm_bar_width=True, # figsize=(24, 18), # title=title, # hatch_dict=None, # ) from src.visualization import stacked_barplot stacked_barplot( partition, mg["Merge Class"], color_dict=color_dict, plot_proportions=False, norm_bar_width=True, hatch_dict=None, ax=axs[0], ) draw_networkx_nice( minigraph, "Spring-x", "Spring-y", sizes="Size", colors="Color", ax=axs[1], weight_scale=20, vmin=0.0001, ) axs[1].set_xlabel("")
g_sym = nx.to_undirected(g) skeleton_labels = np.array(list(g_sym.nodes())) scales = [1] r = 0.5 out_dict = cm.best_partition(g_sym, resolution=r) partition = np.array(itemgetter(*skeleton_labels.astype(str))(out_dict)) adj = nx.to_numpy_array(g_sym, nodelist=skeleton_labels) part_unique, part_count = np.unique(partition, return_counts=True) for uni, count in zip(part_unique, part_count): if count < 3: inds = np.where(partition == uni)[0] partition[inds] = -1 class_label_dict = nx.get_node_attributes(g_sym, "Class 1") class_labels = np.array(itemgetter(*skeleton_labels)(class_label_dict)) part_color_dict = dict(zip(np.unique(partition), cc.glasbey_warm)) true_color_dict = dict(zip(np.unique(class_labels), cc.glasbey_light)) color_dict = {**part_color_dict, **true_color_dict} fig, ax = plt.subplots(1, 1, figsize=(20, 20)) stacked_barplot( partition, class_labels, ax=ax, color_dict=color_dict, plot_proportions=False, norm_bar_width=True, ) stashfig("louvain-barplot")
print(f"ARI: {results.loc[ind, 'ARI']}") print(f"Pairedness: {results.loc[ind, 'pairedness']}\n") model = results.loc[ind, "model"] left_model = model right_model = model pred = composite_predict( X, left_inds, right_inds, left_model, right_model, relabel=False ) pred_side = composite_predict( X, left_inds, right_inds, left_model, right_model, relabel=True ) ax = stacked_barplot( pred_side, meta["merge_class"].values, color_dict=CLASS_COLOR_DICT, legend_ncol=6 ) ax.set_title(basetitle) stashfig(f"barplot" + basename) fig, ax = plot_cluster_pairs( X, left_inds, right_inds, left_model, right_model, meta["merge_class"].values ) fig.suptitle(basetitle, y=1) stashfig(f"pairs" + basename) sf = signal_flow(adj) meta["signal_flow"] = -sf
agg = AgglomerativeClustering(n_clusters=10, affinity="euclidean", linkage="average") labels = agg.fit_predict(raw_hist_data) pairplot(embedding, labels=labels, palette=cc.glasbey_light) # %% [markdown] # # from graspy.cluster import AutoGMMCluster agm = AutoGMMCluster(min_components=2, max_components=20, n_jobs=-1 agm.fit(embedding) # %% [markdown] # # # agm.results_.groupby(["affinity", "covariance_type", "linkage"]) sns.scatterplot(data=agm.results_, x='n_components', y='bic/aic') # %% [markdown] # # new_groups = agm.predict(embedding) stacked_barplot(new_groups, meta["Merge Class"].values, color_dict=CLASS_COLOR_DICT) # %% [markdown] # # pairplot(embedding, labels=new_groups, palette='tab10') # %% [markdown] # #
pred = composite_predict(X, left_inds, right_inds, left_model, right_model, relabel=False) pred_side = composite_predict(X, left_inds, right_inds, left_model, right_model, relabel=True) ax = stacked_barplot(pred_side, meta["merge_class"].values, color_dict=CLASS_COLOR_DICT, legend_ncol=6) ax.set_title(basetitle) stashfig(f"barplot" + basename) fig, ax = plot_cluster_pairs(X, left_inds, right_inds, left_model, right_model, meta["merge_class"].values) fig.suptitle(basetitle, y=1) 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(
def predict(self, X): predictions = [] for sample in X: pred = self.predict_sample(sample) predictions.append(pred) return np.array(predictions) pgmm = PartitionCluster() pgmm.fit(latent) pred_labels = pgmm.predict(latent) from src.visualization import stacked_barplot stacked_barplot(pred_labels, class_labels) # %% [markdown] # # uni_labels = np.unique(pred_labels) # consider only the longest strings: label_lens = [] for l in uni_labels: str_len = len(l) label_lens.append(str_len) label_lens = np.array(label_lens) max_len = max(label_lens) print(max_len)
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
ax=ax, s=30, alpha=1, ellipses="filled", ellipse_kws=dict(linewidth=2, alpha=0.1), ) ax.set(xlabel="", ylabel="", xticks=[], yticks=[]) ax = axs[1, j] uni_pred, uni_counts = np.unique(pred_labels, return_counts=True) sort_inds = np.argsort(uni_counts) stacked_barplot( pred_labels, labels, color_dict=palette, norm_bar_width=False, ax=ax, category_order=uni_pred[sort_inds], ) ax.set(yticks=[], xticks=[0, 25, 50]) ax.set_xticklabels([0, 25, 50], fontsize="large") ax.xaxis.set_visible(True) ax.spines["bottom"].set_visible(True) handles, labels = ax.get_legend_handles_labels() ax.get_legend().remove() axs[0, 1].legend( handles=handles, labels=labels, bbox_to_anchor=(1, 0), loc="lower right" ) # axs[1, 0].set_xlabel( #
# %% [markdown] # # paths = sm_paths path_start_labels = [] path_start_labels = [p[0] for p in paths] path_start_labels = np.array(path_start_labels) #%% class_start_labels = meta.iloc[path_start_labels, meta.columns.get_loc("Merge Class")].values # %% [markdown] # # fig, ax = plt.subplots(1, 1, figsize=(10, 20)) stacked_barplot(pred_labels, class_start_labels, ax=ax) # %% [markdown] # # Start on the big visualization # choose a cluster # get union path graph path_graph = nx.MultiDiGraph() chosen_cluster = 3 path_cluster = [] for i, path in enumerate(paths): if pred_labels[i] == chosen_cluster: path_cluster.append(path) all_nodes = list(itertools.chain.from_iterable(path_cluster))
# ax = fig.add_subplot(1, 3, 3, projection="3d") ax = fig.add_subplot(gs[0, 2], projection="3d") pymaid.plot2d( ids, color=skeleton_color_dict, ax=ax, connectors=False, method="3d", autoscale=True, ) ax.azim = -90 ax.elev = 90 ax.dist = 6 set_axes_equal(ax) ax = fig.add_subplot(gs[1, :]) temp_meta = meta[meta["lvl2_labels"] == tp] cat = temp_meta["lvl2_labels_side"].values subcat = temp_meta["merge_class"].values stacked_barplot(cat, subcat, ax=ax, color_dict=CLASS_COLOR_DICT) ax.get_legend().remove() fig.suptitle(tp) stashfig(f"plot3d-{tp}") plt.close() # %%
def plot_level(sub_results, sub_data, ks, label, metric="bic", basename=""): if isinstance(ks, int): ks = (ks, ) sub_X = sub_data["X"] sub_left_inds = sub_data["left_inds"] sub_right_inds = sub_data["right_inds"] sub_lp_inds = sub_data["left_pair_inds"] sub_rp_inds = sub_data["right_pair_inds"] sub_meta = sub_data["meta"] reembed = sub_data["reembed"] fig, axs = plot_metrics(sub_results) fig.suptitle(f"Clustering for cluster {label}, reembed={reembed}") for ax in axs[:-1]: for k in ks: ax.axvline(k, linestyle="--", color="red", linewidth=2) stashfig(f"cluster-metrics-label={label}-reembed={reembed}" + basename) plt.close() for k in ks: if k != 0: sub_basename = f"-label={label}-subk={k}-reembed={reembed}" + basename sub_basetitle = f"Cluster for {label}, subk={k}, reembed={reembed}," sub_basetitle += (f" metric={metric}, k={k}" ) # , n_components={n_components}" ind = sub_results[sub_results["k"] == k][metric].idxmax() sub_model = sub_results.loc[ind, "model"] sub_left_model = sub_model sub_right_model = sub_model sub_pred_side = composite_predict( sub_X, sub_left_inds, sub_right_inds, sub_left_model, sub_right_model, relabel=True, ) ax = stacked_barplot( sub_pred_side, sub_meta["merge_class"].values, color_dict=CLASS_COLOR_DICT, legend_ncol=6, ) ax.set_title(sub_basetitle) stashfig(f"barplot" + sub_basename) plt.close() fig, ax = plot_cluster_pairs( sub_X, sub_left_inds, sub_right_inds, sub_left_model, sub_right_model, sub_meta["merge_class"].values, ) fig.suptitle(sub_basetitle, y=1) stashfig(f"pairs" + sub_basename) plt.close()
def plot_neurons(meta, key=None, label=None, barplot=False): if label is not None: ids = list(meta[meta[key] == label].index.values) else: ids = list(meta.index.values) ids = [int(i) for i in ids] new_ids = [] for i in ids: try: pymaid.get_neuron( i, raise_missing=True, with_connectors=False, with_tags=False ) new_ids.append(i) except: print(f"Missing neuron {i}, not plotting it.") ids = new_ids meta = meta.loc[ids] fig = plt.figure(figsize=(30, 10)) gs = plt.GridSpec(2, 3, figure=fig, wspace=0, hspace=0, height_ratios=[0.8, 0.2]) skeleton_color_dict = dict( zip(meta.index, np.vectorize(CLASS_COLOR_DICT.get)(meta["merge_class"])) ) ax = fig.add_subplot(gs[0, 0], projection="3d") pymaid.plot2d( ids, color=skeleton_color_dict, ax=ax, connectors=False, method="3d", autoscale=True, ) ax.azim = -90 ax.elev = 0 ax.dist = 5 set_axes_equal(ax) ax = fig.add_subplot(gs[0, 1], projection="3d") pymaid.plot2d( ids, color=skeleton_color_dict, ax=ax, connectors=False, method="3d", autoscale=True, ) ax.azim = 0 ax.elev = 0 ax.dist = 5 set_axes_equal(ax) ax = fig.add_subplot(gs[0, 2], projection="3d") pymaid.plot2d( ids, color=skeleton_color_dict, ax=ax, connectors=False, method="3d", autoscale=True, ) ax.azim = -90 ax.elev = 90 ax.dist = 5 set_axes_equal(ax) if barplot: ax = fig.add_subplot(gs[1, :]) temp_meta = meta[meta[key] == label] cat = temp_meta[key + "_side"].values subcat = temp_meta["merge_class"].values stacked_barplot( cat, subcat, ax=ax, color_dict=CLASS_COLOR_DICT, category_order=np.unique(cat), ) ax.get_legend().remove() # fig.suptitle(label) return fig, ax