sns.set_palette("deep")
sns.set_context("talk", font_scale=1)
def stashfig(name, **kws):
if SAVEFIGS:
savefig(name,
foldername=FNAME,
fmt=DEFAULT_FMT,
dpi=DEFUALT_DPI,
**kws)
GRAPH_VERSION = "2019-09-18-v2"
adj, class_labels, side_labels = load_everything("Gad",
GRAPH_VERSION,
return_class=True,
return_side=True)
adj, inds = get_lcc(adj, return_inds=True)
class_labels = class_labels[inds]
side_labels = side_labels[inds]
n_verts = adj.shape[0]
# %% [markdown]
# #
graph_types = ["Gad", "Gaa", "Gdd", "Gda"]
graph_type_labels = [r"A $\to$ D", r"A $\to$ A", r"D $\to$ D", r"D $\to$ A"]
GRAPH_VERSION = "2019-09-18-v2"
sns.set_context("talk", font_scale=1)
PTR = True
ONLY_RIGHT = True
def stashfig(name, **kws):
if SAVEFIGS:
savefig(name,
foldername=FNAME,
fmt=DEFAULT_FMT,
dpi=DEFUALT_DPI,
**kws)
adj, class_labels, side_labels, skeleton_labels = load_everything(
"Gad",
version=BRAIN_VERSION,
return_keys=["Merge Class", "Hemisphere"],
return_ids=True,
)
# select the right hemisphere
if ONLY_RIGHT:
side = "right hemisphere"
right_inds = np.where(side_labels == "R")[0]
adj = adj[np.ix_(right_inds, right_inds)]
class_labels = class_labels[right_inds]
skeleton_labels = skeleton_labels[right_inds]
else:
side = "full brain"
# sort by number of synapses
degrees = adj.sum(axis=0) + adj.sum(axis=1)
nonzero_inds = np.nonzero(adj.ravel())
x = xs.ravel()[nonzero_inds]
y = ys.ravel()[nonzero_inds]
weights = adj.ravel()[nonzero_inds]
return list(x), list(y), list(weights)
#%%
GRAPH_TYPES = ["Gad", "Gaa", "Gdd", "Gda"]
GRAPH_VERSION = "2020-01-14"
# Sort the graph appropriately first
graph_type = "G"
G_adj, class_labels, side_labels, pair_labels, id_labels = load_everything(
graph_type,
return_keys=["Merge Class", "Hemisphere", "Pair"],
return_ids=True,
version=GRAPH_VERSION,
)
side_class_labels = []
for s, c in zip(side_labels, class_labels):
side_class_labels.append(str(s + c))
side_class_labels = np.array(side_class_labels)
sort_labels = class_labels # the labels on which to sort the graph into blocks
sort_inds = _sort_inds(G_adj, sort_labels, side_labels, True)
G_adj = _sort_graph(G_adj, sort_labels, side_labels, True)
sort_labels = sort_labels[sort_inds]
id_labels = id_labels[sort_inds]
pair_labels = pair_labels[sort_inds]
# %% [markdown]
# # Try on real data
print("Trying on real data")
def unshuffle(shuffle_inds, perm_inds):
pred_inds = np.empty_like(shuffle_inds)
pred_inds[shuffle_inds[perm_inds]] = range(len(shuffle_inds))
return pred_inds
GRAPH_VERSION = "2019-09-18-v2"
adj, class_labels, side_labels = load_everything(
"Gad", GRAPH_VERSION, return_keys=["Class", "Hemisphere"]
)
adj, inds = get_lcc(adj, return_inds=True)
class_labels = class_labels[inds]
side_labels = side_labels[inds]
n_verts = adj.shape[0]
name_map = {" mw right": "R", " mw left": "L"}
side_labels = np.array(itemgetter(*side_labels)(name_map))
name_map = {
"CN": "Unk",
"DANs": "MBIN",
"KCs": "KC",
pred_known_labels = pred_labels[known_inds]
ari = adjusted_rand_score(true_known_labels, pred_known_labels)
return ari
# Set up plotting constants
plt.style.use("seaborn-white")
sns.set_palette("deep")
sns.set_context("talk", font_scale=1)
# %% [markdown]
# # Load the data
adj, class_labels, side_labels, skeleton_labels = load_everything(
"Gad",
version=BRAIN_VERSION,
return_class=True,
return_side=True,
return_ids=True)
# select the right hemisphere
if ONLY_RIGHT:
side = "right hemisphere"
right_inds = np.where(side_labels == " mw right")[0]
adj = adj[np.ix_(right_inds, right_inds)]
class_labels = class_labels[right_inds]
skeleton_labels = skeleton_labels[right_inds]
else:
side = "full brain"
# sort by number of synapses
degrees = adj.sum(axis=0) + adj.sum(axis=1)
data=scatter_df,
hue="Labels",
palette=sns.color_palette("Set1", scatter_df.Labels.nunique()),
)
plt.title("Signal flow metric on an imperfect feedforward network")
plt.show()
# %% [markdown]
# ## Now, look at the output for this signal flow metric on the A $\rightarrow$ D graph
# Here I am just using labels for MB and PNs, as well as indicating side with the
# direction of the marker
# Load the data
GRAPH_VERSION = "2019-09-18-v2"
adj, class_labels, side_labels = load_everything("Gad",
GRAPH_VERSION,
return_class=True,
return_side=True)
adj, inds = get_lcc(adj, return_inds=True)
class_labels = class_labels[inds]
side_labels = side_labels[inds]
name_map = {" mw right": "R", " mw left": "L"}
side_labels = np.array(itemgetter(*side_labels)(name_map))
name_map = {
"CN": "Unk",
"DANs": "MBIN",
"KCs": "KC",
"LHN": "Unk",
"LHN; CN": "Unk",
def stashfig(name, **kws):
if SAVEFIGS:
savefig(name, foldername=FNAME, fmt=DEFAULT_FMT, dpi=DEFUALT_DPI, **kws)
# Set up plotting constants
palette = "deep"
plt.style.use("seaborn-white")
sns.set_palette(palette)
sns.set_context("talk", font_scale=1)
# Load data
adj, class_labels, side_labels, id_labels = load_everything(
"G", version=BRAIN_VERSION, return_class=True, return_side=True, return_ids=True
)
side_map = {" mw right": "R", " mw left": "L"}
side_labels = np.array(itemgetter(*side_labels)(side_map))
degrees = adj.sum(axis=0) + adj.sum(axis=1)
sort_inds = np.argsort(degrees)[::-1]
og_class_labels = class_labels[sort_inds]
adj = adj[np.ix_(sort_inds, sort_inds)]
name_map = {
"CN": "Unknown",
"DANs": "DAN",
"KCs": "KC",
foldername=FNAME,
fmt=DEFAULT_FMT,
dpi=DEFUALT_DPI,
**kws)
# %% [markdown]
# #
sns.set_context("talk", font_scale=1.2)
fig, axs = plt.subplots(4, 5, figsize=(20, 20))
for i in range(len(GRAPH_TYPES)):
g_type = GRAPH_TYPES[i]
g_type_label = GRAPH_TYPE_LABELS[i]
adj = load_everything(g_type, version=BRAIN_VERSION)
in_sum = np.sort(adj.sum(axis=0))
out_sum = np.sort(adj.sum(axis=1))
ax = sns.scatterplot(x=range(len(in_sum)),
y=in_sum + 1,
s=10,
linewidth=0,
ax=axs[0, i])
ax.set(yscale="log")
ax.set_xticklabels([])
ax = sns.scatterplot(x=range(len(out_sum)),
y=out_sum + 1,
s=10,
# %% [markdown]
# #
from src.data import load_networkx, load_everything
import networkx as nx
from graspy.utils import binarize, symmetrize
graph = load_networkx("G")
nx.algorithms.diameter(graph)
# %% [markdown]
# #
adj = load_everything("G")
adj = symmetrize(adj, "avg")
graph = nx.from_numpy_array(adj)
nx.algorithms.diameter(graph)
# %% [markdown]
# #
adj = load_everything("Gad")
adj = symmetrize(adj, "avg")
graph = nx.from_numpy_array(adj)
nx.algorithms.diameter(graph)
