def experiment_VI_plots(
paths,
names,
title,
out_name,
out_dir,
cond_ent_over="GT | Output",
cond_ent_under="Output | GT",
):
groups = []
ce0 = []
ce1 = []
for i, p in enumerate(paths):
df = pd.read_csv(p)
ce0.append(df[cond_ent_over].values)
ce1.append(df[cond_ent_under].values)
groups += [names[i]] * len(df)
x = 'Experiment'
data = {
x: groups,
cond_ent_over: np.concatenate(ce0),
cond_ent_under: np.concatenate(ce1)
}
data = pd.DataFrame(data)
f, axs = plt.subplots(1, 2, figsize=(12, 10))
ax0 = axs[0, 0]
ax1 = axs[0, 1]
o = 'h'
pal = 'Set2'
sigma = .2
pt.RainCloud(x=x,
y=cond_ent_over,
data=data,
palette=pal,
bw=sigma,
width_viol=.6,
ax=ax0,
orient=o)
pt.RainCloud(x=x,
y=cond_ent_under,
data=data,
palette=pal,
bw=sigma,
width_viol=.6,
ax=ax1,
orient=o)
plt.title(title)
if save:
save_path = os.path.join(out_dir, '_VI_rainclould_plots.png')
plt.savefig(save_path, bbox_inches='tight')
if show:
plt.show()
def task_cp_reg():
sns.set(style="whitegrid", font_scale=2)
legend_handles = []
for task, color in zip(task_order(False), task_colors()):
legend_handles.append(Patch(facecolor=color, edgecolor=color, label=task))
fig, axs = plt.subplots(2, 3, figsize=(36, 24), sharex="col", sharey="row")
for col, (tpt, h_name) in enumerate(template_meta_combination):
for row, (lib, label, name) in enumerate(lib_details):
df = lib.gen_long_data(tpt).groupby(["task", "region", "network"]).mean().reset_index() \
.and_filter(NOTtask="Rest") \
.convert_column(metric=lambda x: x * 1000) \
.add_topo(topo_at[tpt.key]) \
.add_net_meta(tpt.net_hierarchy(h_name)) \
.groupby("task").apply(
lambda x: pd.merge(x, pd.Series(sm.OLS(x.metric, x.coord_y).fit().resid, x.index, float, "resid"),
left_index=True, right_index=True)).reset_index(drop=True) \
.groupby(["task", "net_meta"]).apply(remove_outliers, of="metric").reset_index(drop=True)
ax = axs[row, col]
pt.RainCloud(data=df, hue="task", y="resid", x="net_meta", alpha=.65, hue_order=task_order(False),
order=h_name.keys, ax=ax, offset=0.1, dodge=True, bw=.2, width_viol=.7,
pointplot=True, palette=task_colors())
ax.set(xlabel="", ylabel=f"{name} Residual" if col == 0 else "")
ax.get_legend().remove()
ax.set_xticklabels(h_name.labels if row == 1 else [])
if row == 0:
ax.legend(handles=legend_handles, loc=2)
fig.subplots_adjust(wspace=0.1, hspace=0.1)
print(savefig(fig, "task.cp.res", low=False))
def my_rain_plot(path):
results = pd.read_csv(path + '/results.csv', delimiter=';')
del results['HDRFDST']
new_results = results.melt(id_vars=["SUBJECT", "LABEL"],
var_name="metric",
value_name="Score")
dx = "LABEL"
dy = "Score"
dhue = "metric"
ort = "v"
pal = "Set2"
sigma = .2
f, ax = plt.subplots(figsize=(12, 5))
ax = pt.RainCloud(x=dx,
y=dy,
hue=dhue,
data=new_results,
palette=pal,
bw=sigma,
width_viol=1,
ax=ax,
orient=ort,
alpha=.65,
dodge=True,
pointplot=True,
move=.1)
plt.show()
def alpha():
sns.set(style="whitegrid", font_scale=2)
legend_handles = []
for task, color in zip(task_order(), task_colors(True)):
legend_handles.append(Patch(facecolor=color, edgecolor=color, label=task))
fig, axs = plt.subplots(2, 3, figsize=(36, 24), sharex="col", sharey="row")
for col, (tpt, h_name) in enumerate(template_meta_combination):
for row, (lib, label) in enumerate(zip([acwb, aczb], ["ACW-50", "ACW-0"])):
df = lib.gen_long_data(tpt) \
.groupby(["task", "region", "network"]).mean().reset_index() \
.convert_column(metric=lambda x: x * 1000) \
.add_net_meta(tpt.net_hierarchy(h_name)).drop("network", 1) \
.groupby(["task", "net_meta"]).apply(remove_outliers, of="metric").reset_index(drop=True)
ax = axs[row, col]
pt.RainCloud(data=df, hue="task", y="metric", x="net_meta", alpha=.65, hue_order=task_order(),
order=h_name.keys, ax=ax, offset=0.1, dodge=True, bw=.2, width_viol=.7,
pointplot=True, palette=task_colors(True))
ax.set(xlabel="", ylabel=f"{label} (ms)" if col == 0 else "")
ax.get_legend().remove()
ax.set_xticklabels(h_name.labels if row == 1 else [])
if row == 0:
ax.legend(handles=legend_handles)
fig.subplots_adjust(wspace=0.1, hspace=0.1)
print(savefig(fig, "alpha.cp", low=False))
def raincloud(col: str, target_col: str, data, **params):
"""
Visualizes 2 columns using raincloud.
Parameters
----------
col : str
Column name of general data
target_col : str
Column name of measurable data, numerical
data : Dataframe
Dataframe of the data
params: dict
Parameters for the RainCloud visualization
"""
_, ax = plt.subplots(figsize=(12, 8))
if not params:
params = {
"x": col,
"y": target_col,
"data": data.infer_objects(),
"pointplot": True,
"width_viol": 0.8,
"width_box": 0.4,
"orient": "h",
"move": 0.0,
"ax": ax,
}
ax = pt.RainCloud(**params)
def raincloud(par1, par2, df):
"""
Same specifications and requirements as overlapping density plot
Function takes package name, input variables(categories), and target variable as input.
Returns a figure
PARAMETERS
:param package: should only take sns or matplotlib as inputs, any other value should throw and error
:param input_vars: should take the x variables/categories you want to plot
:param target_vars: the y variable of your plot, what you are comparing
:return: fig to be enhanced in subsequent visualization functions
"""
dx = par1
dy = par2
ort = "h"
pal = "Set2"
sigma = .2
fig, ax = plt.subplots(figsize=(16, 10))
pt.RainCloud(x=dx,
y=dy,
data=df,
palette=pal,
bw=sigma,
width_viol=.6,
ax=ax,
orient=ort,
move=0)
plt.xlabel('Danceability')
plt.title('20 year Comparison of Songs Danceability')
return fig
def pchange_net():
sns.set(style="whitegrid", font_scale=2)
fig, axs = plt.subplots(2, 2, figsize=(36, 20), sharey="row", sharex="col",
gridspec_kw={'width_ratios': [7 / 19, 12 / 19]})
for col, tpt in enumerate([tpt_sh, tpt_cole]):
for row, (lib, label, name) in enumerate(lib_details):
df = lib.gen_long_data(tpt) \
.and_filter(subject=lib.find_shared_subjects(tpt, task_order())) \
.groupby(["task", "subject", "network", "region"]).mean().reset_index() \
.groupby(["subject", "network", "region"]).apply(calc_percentage_change).reset_index() \
.groupby(["task", "network", "region"]).mean().reset_index()
ax = axs[row, col]
pt.RainCloud(data=df, hue="task", y="pchange", x="network", alpha=.65, hue_order=task_order(False),
order=tpt.net_order, ax=ax, offset=0.1, dodge=True, bw=.2, width_viol=.7,
pointplot=True, palette=task_colors())
ax.set(xlabel="", ylabel=f"{label} Change From Rest (%)" if col == 0 else "")
ax.set_xticklabels(tpt.net_labels, rotation=90)
ax.get_legend().remove()
fig.subplots_adjust(wspace=0.1, hspace=0.1)
legend_handles = []
for task, color in zip(task_order(False), task_colors()):
legend_handles.append(Patch(facecolor=color, edgecolor=color, label=task))
lgn = fig.legend(handles=legend_handles, loc=2, ncol=3, mode="expand",
bbox_to_anchor=(0.12, -0.08, 0.785, 1))
print(savefig(fig, "pchange.net", low=False, extra_artists=(lgn,)))
def pchange_cp():
sns.set(style="whitegrid", font_scale=2)
legend_handles = []
for task, color in zip(task_order(False), task_colors()):
legend_handles.append(Patch(facecolor=color, edgecolor=color, label=task))
fig, axs = plt.subplots(2, 3, figsize=(36, 24), sharex="col", sharey="row")
for col, (tpt, h_name) in enumerate(template_meta_combination):
for row, (lib, label, name) in enumerate(lib_details):
df = lib.gen_long_data(tpt) \
.and_filter(subject=lib.find_shared_subjects(tpt, task_order())) \
.groupby(["task", "subject", "network", "region"]).mean().reset_index() \
.groupby(["subject", "network", "region"]).apply(calc_percentage_change).reset_index() \
.add_net_meta(tpt.net_hierarchy(h_name)) \
.groupby(["task", "region", "net_meta"]).mean().reset_index()
ax = axs[row, col]
pt.RainCloud(data=df, hue="task", y="pchange", x="net_meta", alpha=.65, hue_order=task_order(False),
order=h_name.keys, ax=ax, offset=0.1, dodge=True, bw=.2, width_viol=.7,
pointplot=True, palette=task_colors())
ax.set(xlabel="", ylabel=f"{label} Change From Rest (%)" if col == 0 else "")
ax.get_legend().remove()
ax.set_xticklabels(h_name.labels if row == 1 else [])
if row == 0:
ax.legend(handles=legend_handles, loc=2)
fig.subplots_adjust(wspace=0.1, hspace=0.1)
print(savefig(fig, "pchange.cp", low=False))
def hyperparameter_dendrites_wit_si_search_panel():
"""
Plots a 3 panels figure on 1 rows x 3 columns
Rows contains figures representing hyperparameters search for 10
permutedMNIST tasks resulting from hyperparameter_search.py config file.
Columns 1 is the number of dendritic segments, columns 2 the activation
sparsity and column 3 the weight sparsity.
"""
df_path1 = f"{experiment_folder}si_prototype_hp_10_lasttask.csv"
df1 = pd.read_csv(df_path1)
df_path2 = f"{experiment_folder}si_prototype_hp_10_control_lasttask.csv"
df2 = pd.read_csv(df_path2)
df1 = df1[[
"Activation sparsity", "FF weight sparsity", "Num segments", "Accuracy"
]]
df2 = df2[[
"Activation sparsity", "FF weight sparsity", "Num segments", "Accuracy"
]]
df1["condition"] = "dendrite_and_ff"
df2["condition"] = "ff_only"
df = pd.concat([df1, df2])
gs = gridspec.GridSpec(1, 1)
fig = plt.figure(figsize=(5, 5))
ax1 = fig.add_subplot(gs[0, 0])
x1 = "Num segments"
dhue = "condition"
y = "Accuracy"
ort = "v"
pal = sns.color_palette(n_colors=9)
sigma = 0.2
fig.suptitle("Impact of the number of segments with SI on performance",
fontsize=12)
pt.RainCloud(x=x1,
y=y,
hue=dhue,
data=df,
palette=pal,
bw=sigma,
width_viol=0.6,
ax=ax1,
orient=ort,
move=0.2,
pointplot=True,
alpha=0.65)
ax1.set_ylabel("Mean accuracy", fontsize=16)
ax1.set_xlabel("Number of dendritic segments", fontsize=16)
if savefigs:
plt.savefig(
f"{figs_dir}/hyperparameter_search_panel_with_si_dendrites.png",
bbox_inches="tight")
def display_raincloud(input_df, scaling=True):
print(
"==============================================================================================================="
)
print('# raincloud')
print(
"==============================================================================================================="
)
_df = input_df.copy()
if scaling:
_df = (_df - _df.mean()) / _df.std()
cols = list(_df.select_dtypes('number'))
fig, ax = plt.subplots(figsize=(18, 6))
ptitprince.RainCloud(data=_df[cols], ax=ax, orient='v')
fig.tight_layout()
display(fig)
plt.close()
def plot_csv(
filename: str,
outpath: str,
font: int = 14,
width: int = 10,
height: int = 4,
):
csv = pd.read_csv(filename)
f, ax = plt.subplots(figsize=(width, height))
ax = pt.RainCloud(
x="type",
y="seconds",
hue="source",
data=csv,
palette="Set2",
order=("Overhead", "Zarr", "TIFF", "HDF5"),
# bw = .2,
width_viol=0.6,
ax=ax,
orient="h",
alpha=0.65,
# dodge = True,
jitter=0.03,
move=0.2,
# pointplot = True,
)
# ax.set(ylim=(0.0002, 5))
ax.set_xscale("log")
ax.set_xlabel("seconds per chunk")
for item in (
[ax.title, ax.xaxis.label, ax.yaxis.label]
+ ax.get_xticklabels()
+ ax.get_yticklabels()
):
item.set_fontsize(font)
ax.axes.get_yaxis().get_label().set_visible(False)
handles, labels = ax.get_legend_handles_labels()
plt.legend(handles[0:3], labels[0:3], loc="lower left", prop={"size": font})
plt.tight_layout()
f.savefig(outpath)
def raincloud(col: str,
target_col: str,
data: pd.DataFrame,
output_file="",
**params):
"""
Visualizes 2 columns using raincloud.
Parameters
----------
col : str
Column name of general data
target_col : str
Column name of measurable data, numerical
data : Dataframe
Dataframe of the data
params: dict
Parameters for the RainCloud visualization
ouput_file : str
Output file name for the image including extension (.jpg, .png, etc.)
"""
fig, ax = plt.subplots(figsize=(12, 8))
if not params:
params = {
"pointplot": True,
"width_viol": 0.8,
"width_box": 0.4,
"orient": "h",
"move": 0.0,
"ax": ax,
}
ax = pt.RainCloud(x=col, y=target_col, data=data.infer_objects(), **params)
if output_file: # pragma: no cover
fig.savefig(os.path.join(IMAGE_DIR, output_file))
def rest_net():
sns.set(style="whitegrid", font_scale=2)
fig, axs = plt.subplots(
2, 2, figsize=(36, 20), sharey="row", sharex="col", gridspec_kw={'width_ratios': [7 / 19, 12 / 19]})
for col, tpt in enumerate([tpt_sh, tpt_cole]):
for row, (lib, label, name) in enumerate(lib_details):
df = lib.gen_long_data(tpt) \
.groupby(["task", "region", "network"]).mean().reset_index() \
.and_filter(task="Rest") \
.convert_column(metric=lambda x: x * 1000) \
.groupby("network").apply(remove_outliers, of="metric").reset_index(drop=True)
ax = axs[row, col]
pt.RainCloud(data=df, x="network", y="metric", order=tpt.net_order, ax=ax, offset=0.1,
pointplot=True, palette=tpt.net_colors, scale="width")
ax.set(xlabel="", ylabel=f"{name} (ms)" if col == 0 else "")
ax.set_xticklabels(tpt.net_labels, rotation=90)
fig.subplots_adjust(wspace=0.1, hspace=0.1)
print(savefig(fig, "rest.net", low=False))
def plt_raincloud(ax, df, cmap):
pt.RainCloud(
x="type",
y="seconds",
hue="type",
data=df,
palette=cmap.name,
width_viol=0.6,
ax=ax,
orient="h",
alpha=0.65,
jitter=0.03,
move=0.2,
)
ax.legend().set_visible(False)
ax.axes.get_yaxis().get_label().set_visible(False)
ax.set_title(df["name"][0])
ax.set_xscale("log")
ax.set_xlabel("seconds per chunk")
return ax
def rest_cp():
sns.set(style="whitegrid", font_scale=2)
fig, axs = plt.subplots(2, 3, figsize=(24, 24), sharex="col", sharey="row")
for col, (tpt, h_name) in enumerate(template_meta_combination):
for row, (lib, label, name) in enumerate(lib_details):
df = lib.gen_long_data(tpt) \
.groupby(["task", "region", "network"]).mean().reset_index() \
.and_filter(task="Rest") \
.convert_column(metric=lambda x: x * 1000) \
.add_net_meta(tpt.net_hierarchy(h_name)) \
.drop("network", 1) \
.groupby("net_meta").apply(remove_outliers, of="metric").reset_index(drop=True)
ax = axs[row, col]
pt.RainCloud(data=df, x="net_meta", y="metric", order=h_name.keys, ax=ax, offset=0.1,
pointplot=True, palette=PC_colors_tuple)
ax.set(xlabel="", ylabel=f"{name} (ms)" if col == 0 else "")
ax.set_xticklabels(h_name.labels)
fig.subplots_adjust(wspace=0.1, hspace=0.1)
print(savefig(fig, "rest.cp", low=False))
def VI_plot(path,
cond_ent_over="GT | Output",
cond_ent_under="Output | GT",
lab="",
save=False,
show=True):
df = pd.read_csv(path)
overseg = df[cond_ent_over].values
o_groups = [cond_ent_over] * len(overseg)
underseg = df[cond_ent_under].values
u_groups = [cond_ent_under] * len(underseg)
groups = o_groups + u_groups
x = 'Variation of information'
y = 'Conditional entropy'
data = {x: groups, y: np.concatenate([overseg, underseg])}
data = pd.DataFrame(data)
o = 'h'
pal = 'Set2'
sigma = .2
f, ax = plt.subplots(figsize=(12, 10))
pt.RainCloud(x=x,
y=y,
data=data,
palette=pal,
bw=sigma,
width_viol=.6,
ax=ax,
orient=o)
p = Path(path)
plt.title(p.stem)
if save:
save_path = os.path.join(p.parents[0],
p.stem + lab + '_VI_rainclout_plot.png')
plt.savefig(save_path, bbox_inches='tight')
if show:
plt.show()
def raincloud_plot(folder_dir, file_name, x_data, title, y_label, x_label):
sns.set(style="whitegrid")
#ax = sns.boxplot(x=pauses, whis=np.inf)
#ax = sns.swarmplot(x=pauses, color='black')
#x = (3.5+2*np.random.randn(1000, 1))#); x1 = (-3.5+2*np.random.randn(1000, 2))
#x=np.concatenate((x,x1),axis=0)
#x_cat = np.random.randint(0,4,size=(2000, 1))
#x=np.concatenate((x_cat,x),axis=1)
#df_rand = pd.DataFrame(pauses, columns=['pauses','all pauses'])
fig, ax = plt.subplots(figsize=(8, 3))
ax = pt.RainCloud(x=np.array(x_data), orient='h', bw=.1, ax=ax)
#sns.despine()
#sns.despine()
#ax.figure.set_size_inches(12,8)
plt.title(title)
plt.ylabel(y_label)
plt.xlabel(x_label)
#ax.xlabel(x_label)
#fig.xlabel(x_label)
plt.savefig('./output' + folder_dir + file_name + '/' +
'raincloud_pause_groups_num_all.png')
#%% Raincloud plots by brain area - mean tau
# ACC
dx = "species"
dy = "tau"
ort = "h"
sigma = .2
fig, ax = plt.subplots(figsize=(5, 5))
pt.RainCloud(x=dx,
y=dy,
data=acc_means,
bw=sigma,
width_viol=.6,
ax=ax,
orient=ort,
point_size=1)
plt.title('ACC')
plt.show()
#%%
acc_mod = smf.ols('tau ~ species', data=acc_means)
acc_mod = acc_mod.fit()
print(acc_mod.summary())
#%%
acc_mod2 = smf.ols('tau ~ species + mean_fr', data=acc_means)
acc_mod2 = acc_mod2.fit()
pal = "Set2"
sigma = .2
fig = plt.figure(figsize=[15, 15])
gs = gridspec.GridSpec(ncols=2, nrows=2)
plt.subplots_adjust(bottom=0.2, hspace=0.5)
ax1 = fig.add_subplot(gs[0])
dy = "SignalVEH.+"
ax1 = pt.RainCloud(x=dx,
y=dy,
hue=dhue,
data=capG,
palette=pal,
bw=sigma,
width_viol=.7,
ax=ax1,
orient=ort,
alpha=.65,
dodge=True,
move=.2)
ax1.get_legend().remove()
ax1.set(yscale="log")
ax2 = fig.add_subplot(gs[1])
dy = "SignalVEH.-"
ax2 = pt.RainCloud(x=dx,
y=dy,
hue=dhue,
data=capG,
# load UKBB
ukbb_path = '/Users/hannah/SB/ukb_add1_holmes_merge_brain.csv'
if 'ukbb' not in locals():
ukbb = pd.read_csv(ukbb_path)
else:
print('Database is already in memory!')
keep = ['31-0.0', '21022-0.0', '2040-0.0']
ukbb_dem = ukbb.copy()[keep].dropna()
ukbb_dem = ukbb_dem[ukbb_dem['2040-0.0'] >= 0]
sex='31-0.0'; age='21022-0.0'; risk='2040-0.0'
sex_colors = sns.set_palette(['#ff019c', '#F5D300'])
f, ax = plt.subplots(figsize=(8, 8))
pt.RainCloud(x = risk, y = age, data = ukbb_dem,
ax = ax, hue=sex, palette=sex_colors, orient='h',
dodge=True, point_size=1.0, linewidth=0.2,
width_viol=1.3, width_box=0.25,
alpha=0.60)
plt.tight_layout()
plt.savefig('%s/raincloud.png' % (OUT_DIR), dpi=600)
pal = sns.color_palette(n_colors=3)
sigma = .3
fig, axes = plt.subplots(ncols=4, nrows=1, figsize=(
23.38,
8.27,
))
fig.suptitle('volume of thalamic subnuclei (corrected for ICV)')
for i, ax in zip(range(len(dfs)), axes.flat):
data = dfs[i]
ax_al = pt.RainCloud(x=dx,
y=dy,
data=data,
palette=pal,
bw=sigma,
width_viol=.3,
figsize=(7, 5),
orient=ort,
ax=ax)
ax.set_title('')
ax.set_ylabel('mm³')
ax.set_xlabel('')
plt.setp(ax.get_xticklabels(),
rotation=20,
ha="right",
rotation_mode="anchor")
plt.subplots_adjust(left=0.125,
bottom=0.1,
right=0.9,
sigma = .2
dx = "group"
dy = "score"
dhue = "gr2"
ort = "h"
pal = "Set2"
sigma = .2
#f, ax = plt.subplots(figsize=(5, 10))
ax = pt.RainCloud(x=dx,
y=dy,
hue=dhue,
data=df,
palette=pal,
bw=sigma,
width_viol=0.9,
figsize=(40, 10),
orient=ort,
alpha=.65) # pointplot = True # , move = .3
# orient = ort)
ax.set(xlim=(0.3, 0.9))
# ax.set(ylim=(0.2, 0.6))
sns.despine()
plt.show()
plt.tight_layout()
('female3'), ('female4'), ('female5'), ('female6')]
df_tpre = pd.DataFrame(tpre, columns=['sex', 'group', 'fatigue'])
df_ID = pd.DataFrame(participant_ID, columns=['ID'])
df_tpre['ID'] = participant_ID
df_tpre_male = pd.DataFrame(tpre_male, columns=['sex1', 'group1', 'fatigue1'])
df_tpre_female = pd.DataFrame(tpre_female,
columns=['sex2', 'group2', 'fatigue2'])
#make it rain
plt.subplot()
ax = pt.RainCloud(x='group',
y='fatigue',
data=df_tpre,
pointplot=True,
width_viol=2,
width_box=.1,
orient='h',
move=.0)
plt.subplot
ax1 = pt.RainCloud(x='group1',
y='fatigue1',
data=df_tpre_male,
pointplot=True,
width_viol=2,
width_box=.1,
orient='h',
move=.0)
ax2 = pt.RainCloud(x='group2',
def genera_raincloud():
# Plotting the clouds
f, ax = plt.subplots(figsize=(7, 5))
dy = "variety"
dx = "sepal.length"
ort = "h"
pal = sns.color_palette(n_colors=1)
ax = pt.half_violinplot(x=dx,
y=dy,
data=df,
palette=pal,
bw=.2,
cut=0.,
scale="area",
width=.6,
inner=None,
orient=ort)
plt.title("Raincloud with Clouds")
plt.savefig("img/Raincloud_Clouds.png")
plt.close()
# Adding the rain
f, ax = plt.subplots(figsize=(7, 5))
ax = pt.half_violinplot(x=dx,
y=dy,
data=df,
palette=pal,
bw=.2,
cut=0.,
scale="area",
width=.6,
inner=None,
orient=ort)
ax = sns.stripplot(x=dx,
y=dy,
data=df,
palette=pal,
edgecolor="white",
size=3,
jitter=0,
zorder=0,
orient=ort)
plt.title("Raincloud with Clouds and Rain")
plt.savefig("img/Raincloud_Clouds_Rain.png")
plt.close()
# Adding jitter to the rain
f, ax = plt.subplots(figsize=(7, 5))
ax = pt.half_violinplot(x=dx,
y=dy,
data=df,
palette=pal,
bw=.2,
cut=0.,
scale="area",
width=.6,
inner=None,
orient=ort)
ax = sns.stripplot(x=dx,
y=dy,
data=df,
palette=pal,
edgecolor="white",
size=3,
jitter=1,
zorder=0,
orient=ort)
plt.title("Raincloud with Clouds and Jitter rain")
plt.savefig("img/Raincloud_Clouds_Rain_Jitter.png")
# Adding the boxplot with quartiles
f, ax = plt.subplots(figsize=(7, 5))
ax = pt.half_violinplot(x=dx,
y=dy,
data=df,
palette=pal,
bw=.2,
cut=0.,
scale="area",
width=.6,
inner=None,
orient=ort)
ax = sns.stripplot(x=dx,
y=dy,
data=df,
palette=pal,
edgecolor="white",
size=3,
jitter=1,
zorder=0,
orient=ort)
ax=sns.boxplot( x = dx, y = dy, data = df, color = "black", width = .15, zorder = 10,\
showcaps = True, boxprops = {'facecolor':'none', "zorder":10},\
showfliers=True, whiskerprops = {'linewidth':2, "zorder":10},\
saturation = 1, orient = ort)
sns.boxplot( x = dx, y = dy, data = df, color = "black", width = .15, zorder = 10,\
showcaps = True, boxprops = {'facecolor':'none', "zorder":10},\
showfliers=True, whiskerprops = {'linewidth':2, "zorder":10},\
saturation = 1, orient = ort)
plt.title("Raincloud with Boxplot")
plt.savefig("img/Raincloud_Boxplot.png")
plt.close()
dx = "variety"
dy = "sepal.length"
ort = "h"
pal = "Set2"
sigma = .2
f, ax = plt.subplots(figsize=(7, 5))
ax = pt.RainCloud(x=dx,
y=dy,
data=df,
palette=pal,
bw=sigma,
width_viol=.6,
ax=ax,
orient=ort,
move=.2)
plt.title("Raincloud with Boxplot and Shifted Rain")
plt.savefig("img/Raincloud_Boxplot_Shifted_Rain.png")
plt.close()
def performance_across_tasks():
"""
Similar representation as previous function (hyperparameter_search_panel)
but in this case, it represents the performance along the number of tasks
and we plot all the hyperparameters on the same figure for each figures.
"""
df_path1 = f"{experiment_folder}segment_search_all.csv"
df1 = pd.read_csv(df_path1)
df_path2 = f"{experiment_folder}kw_sparsity_search_all.csv"
df2 = pd.read_csv(df_path2)
df_path3 = f"{experiment_folder}w_sparsity_search_all.csv"
df3 = pd.read_csv(df_path3)
df_path1_50 = f"{experiment_folder}segment_search_50_all.csv"
df1_50 = pd.read_csv(df_path1_50)
df_path2_50 = f"{experiment_folder}kw_sparsity_search_50_all.csv"
df2_50 = pd.read_csv(df_path2_50)
df_path3_50 = f"{experiment_folder}w_sparsity_search_50_all.csv"
df3_50 = pd.read_csv(df_path3_50)
gs = gridspec.GridSpec(2, 3)
fig = plt.figure(figsize=(14, 10))
ax1 = fig.add_subplot(gs[0, 0])
ax2 = fig.add_subplot(gs[0, 1])
ax3 = fig.add_subplot(gs[0, 2])
ax1_50 = fig.add_subplot(gs[1, 0])
ax2_50 = fig.add_subplot(gs[1, 1])
ax3_50 = fig.add_subplot(gs[1, 2])
x1 = "Iteration"
hue1 = "Num segments"
hue2 = "Activation sparsity"
hue3 = "FF weight sparsity"
y = "Accuracy"
ort = "v"
pal = sns.color_palette(n_colors=10)
sigma = 0.2
fig.suptitle(
"""Performance along number of tasks with different
hyperpameter conditions""",
fontsize=16,
)
pt.RainCloud(x=x1,
y=y,
hue=hue1,
data=df1,
palette=pal,
bw=sigma,
width_viol=0.6,
ax=ax1,
orient=ort,
move=0.2,
pointplot=True,
alpha=0.65)
l, h = ax1.get_legend_handles_labels()
ax1.legend(handles=l[0:10], labels=h[0:10], fontsize="8")
pt.RainCloud(x=x1,
y=y,
hue=hue2,
data=df2,
palette=pal,
bw=sigma,
width_viol=0.6,
ax=ax2,
orient=ort,
move=0.2,
pointplot=True,
alpha=0.65)
l, h = ax2.get_legend_handles_labels()
ax2.legend(handles=l[0:9], labels=h[0:9], fontsize="8")
pt.RainCloud(x=x1,
y=y,
hue=hue3,
data=df3,
palette=pal,
bw=sigma,
width_viol=0.6,
ax=ax3,
orient=ort,
move=0.2,
pointplot=True,
alpha=0.65)
l, h = ax3.get_legend_handles_labels()
ax3.legend(handles=l[0:8], labels=h[0:8], fontsize="8")
pt.RainCloud(x=x1,
y=y,
hue=hue1,
data=df1_50,
palette=pal,
bw=sigma,
width_viol=0.6,
ax=ax1_50,
orient=ort,
move=0.2,
pointplot=True,
alpha=0.65)
l, h = ax1_50.get_legend_handles_labels()
labels = h[0:9]
ax1_50.legend(
handles=l[0:9],
labels=labels,
fontsize="8",
)
pt.RainCloud(x=x1,
y=y,
hue=hue2,
data=df2_50,
palette=pal,
bw=sigma,
width_viol=0.6,
ax=ax2_50,
orient=ort,
move=0.2,
pointplot=True,
alpha=0.65)
l, h = ax2_50.get_legend_handles_labels()
ax2_50.legend(handles=l[0:8], labels=h[0:8], fontsize="8")
pt.RainCloud(x=x1,
y=y,
hue=hue3,
data=df3_50,
palette=pal,
bw=sigma,
width_viol=0.6,
ax=ax3_50,
orient=ort,
move=0.2,
pointplot=True,
alpha=0.65)
l, h = ax3_50.get_legend_handles_labels()
ax3_50.legend(handles=l[0:8], labels=h[0:8], fontsize="8")
ax1.set_xlabel("")
ax1.set_ylabel("Mean Accuracy")
ax1.set_title("Number of segments")
ax1_50.set_xlabel("Tasks", fontsize=16)
ax1_50.set_ylabel("Mean Accuracy")
ax1_50.xaxis.set_major_locator(ticker.MultipleLocator(10))
ax1_50.xaxis.set_major_formatter(ticker.ScalarFormatter())
ax2.set_title("Activation density")
ax2.set_xlabel("")
ax2.set_ylabel("")
ax2_50.set_xlabel("Tasks", fontsize=16)
ax2_50.set_ylabel("")
ax2_50.xaxis.set_major_locator(ticker.MultipleLocator(10))
ax2_50.xaxis.set_major_formatter(ticker.ScalarFormatter())
ax3.set_xlabel("")
ax3.set_ylabel("")
ax3.set_title("FF weight density")
ax3_50.set_xlabel("Tasks", fontsize=16)
ax3_50.set_ylabel("")
ax3_50.xaxis.set_major_locator(ticker.MultipleLocator(10))
ax3_50.xaxis.set_major_formatter(ticker.ScalarFormatter())
plt.figtext(-0.01, 0.7, " 10 TASKS", fontsize=14)
plt.figtext(-0.01, 0.28, " 50 TASKS", fontsize=14)
if savefigs:
plt.savefig(f"{figs_dir}/hyperparameter_search_panel_along_tasks.png")
def hyperparameter_search_panel():
"""
Plots a 6 panels figure on 2 rows x 3 columns
Rows contains figures representing hyperparameters search for 10 and 50
permutedMNIST tasks resulting from hyperparameter_search.py config file.
Columns 1 is the number of dendritic segments, columns 2 the activation
sparsity and column 3 the weight sparsity.
"""
df_path1 = f"{experiment_folder}segment_search_lasttask.csv"
df1 = pd.read_csv(df_path1)
df_path2 = f"{experiment_folder}kw_sparsity_search_lasttask.csv"
df2 = pd.read_csv(df_path2)
df_path3 = f"{experiment_folder}w_sparsity_search_lasttask.csv"
df3 = pd.read_csv(df_path3)
df_path1_50 = f"{experiment_folder}segment_search_50_lasttask.csv"
df1_50 = pd.read_csv(df_path1_50)
df_path2_50 = f"{experiment_folder}kw_sparsity_search_50_lasttask.csv"
df2_50 = pd.read_csv(df_path2_50)
df_path3_50 = f"{experiment_folder}w_sparsity_search_50_lasttask.csv"
df3_50 = pd.read_csv(df_path3_50)
relevant_columns = [
"Activation sparsity", "FF weight sparsity", "Num segments", "Accuracy"
]
df1 = df1[relevant_columns]
df2 = df2[relevant_columns]
df3 = df3[relevant_columns]
df1_50 = df1_50[relevant_columns]
df2_50 = df2_50[relevant_columns]
df3_50 = df3_50[relevant_columns]
# Figure 1 'Impact of the different hyperparameters on performance
# full cross product of hyperparameters
gs = gridspec.GridSpec(2, 3)
fig = plt.figure(figsize=(14, 10))
ax1 = fig.add_subplot(gs[0, 0])
ax2 = fig.add_subplot(gs[0, 1])
ax3 = fig.add_subplot(gs[0, 2])
ax1_50 = fig.add_subplot(gs[1, 0])
ax2_50 = fig.add_subplot(gs[1, 1])
ax3_50 = fig.add_subplot(gs[1, 2])
x1 = "Num segments"
x2 = "Activation sparsity"
x3 = "FF weight sparsity"
y = "Accuracy"
ort = "v"
pal = sns.color_palette(n_colors=6)
sigma = 0.2
fig.suptitle("Impact of the different hyperparameters on performance",
fontsize=12)
pt.RainCloud(x=x1,
y=y,
data=df1,
palette=pal,
bw=sigma,
width_viol=0.6,
ax=ax1,
orient=ort,
move=0.2,
pointplot=True,
alpha=0.65)
pt.RainCloud(x=x1,
y=y,
data=df1_50,
palette=pal,
bw=sigma,
width_viol=0.6,
ax=ax1_50,
orient=ort,
move=0.2,
pointplot=True,
alpha=0.65)
pt.RainCloud(x=x2,
y=y,
data=df2,
palette=pal,
bw=sigma,
width_viol=0.6,
ax=ax2,
orient=ort,
move=0.2,
pointplot=True,
alpha=0.65)
pt.RainCloud(x=x2,
y=y,
data=df2_50,
palette=pal,
bw=sigma,
width_viol=0.6,
ax=ax2_50,
orient=ort,
move=0.2,
pointplot=True,
alpha=0.65)
pt.RainCloud(x=x3,
y=y,
data=df3,
palette=pal,
bw=sigma,
width_viol=0.6,
ax=ax3,
orient=ort,
move=0.2,
pointplot=True,
alpha=0.65)
pt.RainCloud(x=x3,
y=y,
data=df3_50,
palette=pal,
bw=sigma,
width_viol=0.6,
ax=ax3_50,
orient=ort,
move=0.2,
pointplot=True,
alpha=0.65)
ax1.set_ylabel("Mean accuracy", fontsize=16)
ax1.set_xlabel("Number of dendritic segments", fontsize=16)
ax1_50.set_ylabel("Mean accuracy", fontsize=16)
ax1_50.set_xlabel("Number of dendritic segments", fontsize=16)
ax2.set(ylabel="")
ax2.set_xlabel("Activation density", fontsize=16)
ax2_50.set(ylabel="")
ax2_50.set_xlabel("Activation density", fontsize=16)
ax3.set(ylabel="")
ax3.set_xlabel("FF Weight density", fontsize=16)
ax3_50.set(ylabel="")
ax3_50.set_xlabel("FF Weight density", fontsize=16)
# Add 10 tasks and 50 tasks labels on the left
plt.figtext(-0.02, 0.7, "10 TASKS", fontsize=16)
plt.figtext(-0.02, 0.28, "50 TASKS", fontsize=16)
fig.suptitle(
"""Impact of different hyperparameters on \n 10-tasks and 50-tasks
permuted MNIST performance""",
fontsize=16,
)
if savefigs:
plt.savefig(f"{figs_dir}/hyperparameter_search_panel.png",
bbox_inches="tight")
def cns_figure_1c():
"""
CNS 2021 abstract figure 1C.
"""
data_folder = "cns2021_figure1c_data/"
savefigs = True
df_path1 = f"{data_folder}nb_segment_search2.csv"
df1 = pd.read_csv(df_path1)
df_path1bis = f"{data_folder}nb_segment_search3.csv"
df1bis = pd.read_csv(df_path1bis)
df_path2 = f"{data_folder}kw_sparsity_search.csv"
df2 = pd.read_csv(df_path2)
relevant_columns = [
"Activation sparsity", "FF weight sparsity", "Num segments", "Accuracy"
]
df1 = df1[relevant_columns]
df1bis = df1bis[relevant_columns]
df2 = df2[relevant_columns]
df1 = pd.concat([df1, df1bis])
gs = gridspec.GridSpec(1, 2)
fig = plt.figure(figsize=(10, 8))
ax1 = fig.add_subplot(gs[:, 0])
ax2 = fig.add_subplot(gs[:, 1])
x1 = "Num segments"
x2 = "Activation sparsity"
y = "Accuracy"
ort = "v"
pal = "Set2"
sigma = 0.2
fig.suptitle(
"Impact of the number of dendritic segments or the\n \
activation sparsity on 10-tasks permuted MNIST performance",
fontsize=16,
)
pt.RainCloud(x=x1,
y=y,
data=df1,
palette=pal,
bw=sigma,
width_viol=0.6,
ax=ax1,
orient=ort,
move=0.2,
pointplot=True,
alpha=0.65)
pt.RainCloud(x=x2,
y=y,
data=df2,
palette=pal,
bw=sigma,
width_viol=0.6,
ax=ax2,
orient=ort,
move=0.2,
pointplot=True,
alpha=0.65)
ax1.set_ylim([0.9, 0.96])
ax1.set_ylabel("Mean accuracy", fontsize=16)
ax1.set_xlabel("Number of dendritic segments", fontsize=16)
ax1.set_xticklabels(["2", "3", "5", "7", "10", "14", "20"], fontsize=14)
ax1.set_yticklabels(
["0.90", "0.91", "0.92", "0.93", "0.94", "0.95", "0.96"], fontsize=14)
ax2.set_ylim([0.60, 1])
ax2.set_ylabel("")
ax2.set_xticklabels(
["0.99", "0.95", "0.9", "0.8", "0.6", "0.4", "0.2", "0.1"],
fontsize=14)
ax2.set_yticklabels([
"0.60", "0.65", "0.70", "0.75", "0.80", "0.85", "0.90", "0.95", "1.0"
],
fontsize=14)
ax2.set_xlabel("Activation sparsity", fontsize=16)
if savefigs:
plt.savefig("cns2021_figure1c.png", bbox_inches="tight", dpi=1200)
def dist_splits(key, data):
data = data.assign(joiner=0)
fig = plt.figure(figsize=[15, 5])
gs = mpl.gridspec.GridSpec(2, 7, figure=fig)
ax0 = fig.add_subplot(gs[:, 0:3])
ax1 = fig.add_subplot(gs[:, 3:5])
ax2 = fig.add_subplot(gs[0, 5:7])
ax3 = fig.add_subplot(gs[1, 5:7])
pt.RainCloud(x='strategy',
y=key,
data=data,
bw=.2,
width_viol=.6,
ax=ax0,
orient='v',
alpha=0.5,
palette='Set1',
hue='n_parties',
dodge=True)
ax0.set_title('Split by n_parties')
handles, labels = ax0.get_legend_handles_labels()
ax0.legend().remove()
fig.legend((handles[0], handles[1]), (labels[0], labels[1]),
title='n_parties',
loc=(0.9, 0.325))
ax0.set_xlabel('')
pt.RainCloud(x='n_parties',
y=key,
data=data,
bw=.2,
width_viol=.6,
ax=ax1,
orient='v',
alpha=0.5,
palette='Set2',
hue='strategy',
dodge=True)
ax1.set_title('Split by strategy')
ax1.axes.get_yaxis().set_visible(False)
handles, labels = ax1.get_legend_handles_labels()
ax1.legend().remove()
fig.legend((handles[0], handles[1], handles[2]),
(labels[0], labels[1], labels[2]),
title='strategy',
loc=(0.9, 0.71))
ax1.set_xlabel('')
pt.RainCloud(x='joiner',
y=key,
data=data,
bw=.2,
width_viol=.6,
ax=ax2,
orient='h',
alpha=0.5,
palette='Set2',
hue='strategy',
dodge=True)
ax2.legend().remove()
ax2.axes.get_yaxis().set_visible(False)
ax2.axes.get_xaxis().set_visible(False)
ax2.set_xlabel('')
pt.RainCloud(x='joiner',
y=key,
data=data,
bw=.2,
width_viol=.6,
ax=ax3,
orient='h',
alpha=0.5,
palette='Set1',
hue='n_parties',
dodge=True)
ax3.legend().remove()
ax3.axes.get_yaxis().set_visible(False)
ax3.set_xlabel('')
fig.suptitle('{0} distributions'.format(key), fontsize=14)
plt.subplots_adjust(wspace=0.08, hspace=0.08)
return fig
'#FF9300', '#FF9300', '#FF9300', '#FF9C54', '#FF9C54', '#FFAA8A',
'#FFAA8A', '#FFAA8A', '#FFBFBB', '#FFBFBB'
]
likableness_palette = [
'#009FDA', '#009FDA', '#009FDA', '#418DD7', '#418DD7', '#6979CC',
'#6979CC', '#6979CC', '#8862B6', '#8862B6'
]
dx = 'ROI'
dy = 'Classification accuracy'
ort = 'v'
pal = affect_palette
sigma = .2
#f, ax = plt.subplots(figsize=(5, 10))
ax = pt.RainCloud(x=dx,
y=dy,
data=clean_df,
palette=pal,
bw=sigma,
width_viol=0.7,
orient=ort,
move=.3,
alpha=.65)
ax.set(ylim=(0.40, 0.90))
# ax.set(ylim=(0.2, 0.6))
sns.despine()
plt.show()
print("{} Pearson R = ".format(region), pcorr)
# create raincloud plots
sns.set(style="ticks", context=("poster"), font_scale=1.25)
fig, ax = plt.subplots()
fig.set_size_inches(6, 10)
dx = "Group"
dy = region
ort = "v"
pal = "colorblind"
sigma = .25
ax = pt.RainCloud(x=dx,
y=dy,
data=df,
palette='colorblind',
width_viol=.5,
width_box=.25,
orient=ort,
move=.0,
bw=sigma,
showfliers=False)
plt.title("{} Activity at Event Boundaries".format(region), y=1.02)
plt.ylabel("% Signal Change\n(Boundary - Within-Event)")
plt.xlabel("Group")
sns.despine()
plt.savefig(fig_dir + '{}_raincloud.pdf'.format(region),
format='pdf',
dpi=300,
bbox_inches="tight")
# run ANOVAs with posthoc Tukey HSD comparisons
print("\n{} One-Way ANOVA:".format(region))
mod = ols('{} ~ Group'.format(region), data=df).fit()
