def plot_from_dict(dict_path, plt_bkend=None, fontdir=None, parallel=False,
datetime=True, overwrite=False):
"""
plot_from_dict(dict_path)
Plots data from dictionaries containing analysis parameters and results.
Required args:
- dict_path (Path): path to dictionary to plot data from
Optional_args:
- plt_bkend (str) : mpl backend to use for plotting (e.g., "agg")
default: None
- fontdir (Path) : path to directory where additional fonts are stored
default: None
- parallel (bool) : if True, some of the analysis is parallelized
across CPU cores
default: False
- datetime (bool) : figpar["save"] datatime parameter (whether to
place figures in a datetime folder)
default: True
- overwrite (bool): figpar["save"] overwrite parameter (whether to
overwrite figures)
default: False
"""
logger.info(f"Plotting from dictionary: {dict_path}",
extra={"spacing": "\n"})
figpar = sess_plot_util.init_figpar(
plt_bkend=plt_bkend, fontdir=fontdir, datetime=datetime,
overwrite=overwrite
)
plot_util.manage_mpl(cmap=False, **figpar["mng"])
dict_path = Path(dict_path)
info = file_util.loadfile(dict_path)
savedir = dict_path.parent
analysis = info["extrapar"]["analysis"]
# 0. Plots the correlation between pupil and roi/run changes for each
# session
if analysis == "c": # difference correlation
plot_pup_diff_corr(figpar=figpar, savedir=savedir, **info)
# difference correlation per ROI between stimuli
elif analysis == "r":
plot_pup_roi_stim_corr(figpar=figpar, savedir=savedir, **info)
else:
warnings.warn(f"No plotting function for analysis {analysis}",
category=UserWarning, stacklevel=1)
plot_util.cond_close_figs()
def plot_from_dict(dict_path,
plt_bkend=None,
fontdir=None,
plot_tc=True,
parallel=False,
datetime=True,
overwrite=False):
"""
plot_from_dict(dict_path)
Plots data from dictionaries containing analysis parameters and results.
Required args:
- dict_path (Path): path to dictionary to plot data from
Optional_args:
- plt_bkend (str) : mpl backend to use for plotting (e.g., "agg")
default: None
- fontdir (Path) : path to directory where additional fonts are stored
default: None
- plot_tc (bool) : if True, tuning curves are plotted for each ROI
(dummy argument)
default: True
- parallel (bool) : if True, some of the analysis is parallelized
across CPU cores
default: False
- datetime (bool) : figpar["save"] datatime parameter (whether to
place figures in a datetime folder)
default: True
- overwrite (bool): figpar["save"] overwrite parameter (whether to
overwrite figures)
default: False
"""
logger.info(f"Plotting from dictionary: {dict_path}",
extra={"spacing": "\n"})
figpar = sess_plot_util.init_figpar(plt_bkend=plt_bkend,
fontdir=fontdir,
datetime=datetime,
overwrite=overwrite)
plot_util.manage_mpl(cmap=False, **figpar["mng"])
plt.rcParams["figure.titlesize"] = "xx-large"
plt.rcParams["axes.titlesize"] = "xx-large"
dict_path = Path(dict_path)
info = file_util.loadfile(dict_path)
savedir = dict_path.parent
analysis = info["extrapar"]["analysis"]
# 1. Plot average traces by quantile x unexpected for each session
if analysis == "t": # traces
gen_plots.plot_traces_by_qu_unexp_sess(figpar=figpar,
savedir=savedir,
modif=True,
**info)
# 2. Plot average traces by quantile, locked to unexpected for each session
elif analysis == "l": # unexpected locked traces
gen_plots.plot_traces_by_qu_lock_sess(figpar=figpar,
savedir=savedir,
modif=True,
**info)
else:
warnings.warn(f"No modified plotting option for analysis {analysis}",
category=UserWarning,
stacklevel=1)
plot_util.cond_close_figs()
def init_param_cont(args):
"""
init_param_cont(args)
Initializes parameter containers.
Returns args:
- in the following nametuples: analyspar, sesspar, stimpar, autocorr,
permpar, quantpar
- in the following dictionary: figpar
Required args:
- args (Argument parser): parser with the following attributes:
visflow_dir (str or list): visual flow direction values to include
("right", "left", ["right", "left"])
visflow_size (int or list): visual flow size values to include
(128, 256 or [128, 256])
closest (bool) : if False, only exact session number is
retained, otherwise the closest.
error (str) : error statistic parameter ("std" or "sem")
fontdir (str) : path to directory containing additional
fonts
gabfr (int) : gabor frame at which sequences start
(0, 1, 2, 3)
gabk (int or list) : gabor kappa values to include
(4, 16 or [4, 16])
gab_ori (int or list) : gabor orientation values to include
([0, 45, 90, 135, 180, 225])
incl (str) : sessions to include ("yes", "no", "all")
keepnans (str) : if True, the original running array is
used instead of the one where NaNs
are interpolated.
lag_s (num) : lag for autocorrelation (in sec)
line (str) : line ("L23", "L5", "any")
min_rois (int) : min number of ROIs
n_perms (int) : nbr of permutations to run
n_quants (int) : number of quantiles
ncols (int) : number of columns
no_datetime (bool) : if True, figures are not saved in a
subfolder named based on the date and time.
no_sharey (bool) : if True, sharey figure parameter is set to
False.
not_save_fig (bool) : if True, figures are not saved
output (str) : general directory in which to save output
overwrite (bool) : if False, overwriting existing figures
is prevented by adding suffix numbers.
pass_fail (str or list): pass/fail values of interest ("P", "F")
plane (str) : plane ("soma", "dend", "any")
plt_bkend (str) : mpl backend to use
post (num) : range of frames to include after each
reference frame (in s)
pre (num) : range of frames to include before each
reference frame (in s)
runtype (str or list) : runtype ("pilot" or "prod")
scale (bool) : whether to scale running data
sess_n (int) : session number
stats (str) : statistic parameter ("mean" or "median")
stimtype (str) : stimulus to analyse ("visflow" or "gabors")
tails (str or int) : which tail(s) to test ("hi", "lo", 2)
Returns:
- analysis_dict (dict): dictionary of analysis parameters
["analyspar"] (AnalysPar) : named tuple of analysis parameters
["sesspar"] (SessPar) : named tuple of session parameters
["stimpar"] (StimPar) : named tuple of stimulus parameters
["autocorrpar"] (AutocorrPar): named tuple of autocorrelation
parameters
["permpar"] (PermPar) : named tuple of permutation parameters
["quantpar"] (QuantPar) : named tuple of quantile parameters
["figpar"] (dict) : dictionary containing following
subdictionaries:
["init"]: dict with following inputs as attributes:
["ncols"] (int) : number of columns in the figures
["sharex"] (bool) : if True, x axis lims are shared
across subplots
["sharey"] (bool) : if True, y axis lims are shared
across subplots
["subplot_hei"] (num): height of each subplot (inches)
["subplot_wid"] (num): width of each subplot (inches)
["save"]: dict with the following inputs as attributes:
["datetime"] (bool) : if True, figures are saved in a
subfolder named based on the date and
time.
["fig_ext"] (str) : figure extension
["overwrite"] (bool): if True, existing figures can be
overwritten
["save_fig"] (bool) : if True, figures are saved
["use_dt"] (str) : datetime folder to use
["dirs"]: dict with the following attributes:
["figdir"] (str) : main folder in which to save figures
["roi"] (str) : subdirectory name for ROI analyses
["run"] (str) : subdirectory name for running analyses
["autocorr"] (str) : subdirectory name for autocorrelation
analyses
["locori"] (str) : subdirectory name for location and
orientation responses
["oridir"] (str) : subdirectory name for
orientation/direction analyses
["unexp_qu"] (str) : subdirectory name for unexpected,
quantile analyses
["tune_curv"] (str): subdirectory name for tuning curves
["grped"] (str) : subdirectory name for ROI grps data
["mags"] (str) : subdirectory name for magnitude
analyses
["mng"]: dict with the following attributes:
["plt_bkend"] (str): mpl backend to use
["linclab"] (bool) : if True, Linclab mpl defaults are used
["fontdir"] (str) : path to directory containing
additional fonts
"""
args = copy.deepcopy(args)
analysis_dict = dict()
# analysis parameters
analysis_dict["analyspar"] = sess_ntuple_util.init_analyspar(
"n/a", not (args.keepnans), args.stats, args.error, args.scale)
# session parameters
analysis_dict["sesspar"] = sess_ntuple_util.init_sesspar(
args.sess_n, args.closest, args.plane, args.line, args.min_rois,
args.pass_fail, args.incl, args.runtype)
# stimulus parameters
analysis_dict["stimpar"] = sess_ntuple_util.init_stimpar(
args.stimtype, args.visflow_dir, args.visflow_size, args.gabfr,
args.gabk, args.gab_ori, args.pre, args.post)
# SPECIFIC ANALYSES
# autocorrelation parameters
analysis_dict["autocorrpar"] = sess_ntuple_util.init_autocorrpar(
args.lag_s, byitem=False)
# permutation parameters
analysis_dict["permpar"] = sess_ntuple_util.init_permpar(
args.n_perms, 0.05, args.tails, False)
# quantile parameters
analysis_dict["quantpar"] = sess_ntuple_util.init_quantpar(
args.n_quants, [0, -1])
# figure parameters
analysis_dict["figpar"] = sess_plot_util.init_figpar(
ncols=int(args.ncols),
datetime=not (args.no_datetime),
overwrite=args.overwrite,
save_fig=not (args.not_save_fig),
runtype=args.runtype,
output=args.output,
plt_bkend=args.plt_bkend,
fontdir=args.fontdir,
sharey=not (args.no_sharey))
return analysis_dict
def plot_glm_expl_var(analyspar, sesspar, stimpar, extrapar, glmpar,
sess_info, all_expl_var, figpar=None, savedir=None):
"""
plot_glm_expl_var(analyspar, sesspar, stimpar, extrapar,
sess_info, all_expl_var)
From dictionaries, plots explained variance for different variables for
each ROI.
Required args:
- analyspar (dict) : dictionary with keys of AnalysPar namedtuple
- sesspar (dict) : dictionary with keys of SessPar namedtuple
- stimpar (dict) : dictionary with keys of StimPar namedtuple
- glmpar (dict) : dictionary with keys of GLMPar namedtuple
- extrapar (dict) : dictionary containing additional analysis
parameters
["analysis"] (str): analysis type (e.g., "v")
- sess_info (dict) : dictionary containing information from each
session
["mouse_ns"] (list) : mouse numbers
["sess_ns"] (list) : session numbers
["lines"] (list) : mouse lines
["planes"] (list) : imaging planes
["nrois"] (list) : number of ROIs in session
- all_expl_var (list) : list of dictionaries with explained variance
for each session set, with each glm
coefficient as a key:
["full"] (list) : list of full explained variance stats for
every ROI, structured as ROI x stats
["coef_all"] (dict): max explained variance for each ROI with each
coefficient as a key, structured as ROI x stats
["coef_uni"] (dict): unique explained variance for each ROI with
each coefficient as a key,
structured as ROI x stats
["rois"] (list) : ROI numbers (-1 for GLMs fit to
mean/median ROI activity)
Optional args:
- figpar (dict): dictionary containing the following figure parameter
dictionaries
default: None
["init"] (dict): dictionary with figure initialization parameters
["save"] (dict): dictionary with figure saving parameters
["dirs"] (dict): dictionary with additional figure parameters
- savedir (str): path of directory in which to save plots.
default: None
Returns:
- fulldir (str) : final path of the directory in which the figure is
saved (may differ from input savedir, if datetime
subfolder is added.)
- savename (str): name under which the figure is saved
"""
stimstr_pr = sess_str_util.stim_par_str(
stimpar["stimtype"], stimpar["visflow_dir"], stimpar["visflow_size"],
stimpar["gabk"], "print")
dendstr_pr = sess_str_util.dend_par_str(
analyspar["dend"], sesspar["plane"], "roi", "print")
sessstr = sess_str_util.sess_par_str(
sesspar["sess_n"], stimpar["stimtype"], sesspar["plane"],
stimpar["visflow_dir"], stimpar["visflow_size"], stimpar["gabk"])
dendstr = sess_str_util.dend_par_str(
analyspar["dend"], sesspar["plane"], "roi")
# extract some info from sess_info
keys = ["mouse_ns", "sess_ns", "lines", "planes"]
[mouse_ns, sess_ns, lines, planes] = [sess_info[key] for key in keys]
n_sess = len(mouse_ns)
nroi_strs = sess_str_util.get_nroi_strs(sess_info, style="par")
plot_bools = [ev["rois"] not in [[-1], "all"] for ev in all_expl_var]
n_sess = sum(plot_bools)
if stimpar["stimtype"] == "gabors":
xyzc_dims = ["unexpected", "gabor_frame", "run_data", "pup_diam_data"]
log_dims = xyzc_dims + ["gabor_mean_orientation"]
elif stimpar["stimtype"] == "visflow":
xyzc_dims = [
"unexpected", "main_flow_direction", "run_data", "pup_diam_data"
]
log_dims = xyzc_dims
# start plotting
logger.info("Plotting GLM full and unique explained variance for "
f"{', '.join(xyzc_dims)}.", extra={"spacing": "\n"})
if n_sess > 0:
if figpar is None:
figpar = sess_plot_util.init_figpar()
figpar = copy.deepcopy(figpar)
cmap = plot_util.linclab_colormap(nbins=100, no_white=True)
if figpar["save"]["use_dt"] is None:
figpar["save"]["use_dt"] = gen_util.create_time_str()
figpar["init"]["ncols"] = n_sess
figpar["init"]["sharex"] = False
figpar["init"]["sharey"] = False
figpar["init"]["gs"] = {"wspace": 0.2, "hspace": 0.35}
figpar["save"]["fig_ext"] = "png"
fig, ax = plot_util.init_fig(2 * n_sess, **figpar["init"], proj="3d")
fig.suptitle("Explained variance per ROI", y=1)
# get colormap range
c_range = [np.inf, -np.inf]
c_key = xyzc_dims[3]
for expl_var in all_expl_var:
for var_type in ["coef_all", "coef_uni"]:
rs = np.where(np.asarray(expl_var["rois"]) != -1)[0]
if c_key in expl_var[var_type].keys():
c_data = np.asarray(expl_var[var_type][c_key])[rs, 0]
# adjust colormap range
c_range[0] = np.min([c_range[0], min(c_data)])
c_range[1] = np.max([c_range[1], max(c_data)])
if not np.isfinite(sum(c_range)):
c_range = [-0.5, 0.5] # dummy range
else:
c_range = plot_util.rounded_lims(c_range, out=True)
else:
logger.info("No plots, as only results across ROIs are included")
fig = None
i = 0
for expl_var in all_expl_var:
# collect info for plotting and logging results across ROIs
rs = np.where(np.asarray(expl_var["rois"]) != -1)[0]
all_rs = np.where(np.asarray(expl_var["rois"]) == -1)[0]
if len(all_rs) != 1:
raise RuntimeError("Expected only one result for all ROIs.")
else:
all_rs = all_rs[0]
full_ev = expl_var["full"][all_rs]
title = (f"Mouse {mouse_ns[i]} - {stimstr_pr}\n(sess {sess_ns[i]}, "
f"{lines[i]} {planes[i]}{dendstr_pr},{nroi_strs[i]})")
logger.info(title, extra={"spacing": "\n"})
math_util.log_stats(full_ev, stat_str="\nFull explained variance")
dim_length = max([len(dim) for dim in log_dims])
for v, var_type in enumerate(["coef_all", "coef_uni"]):
if var_type == "coef_all":
sub_title = "Explained variance per coefficient"
elif var_type == "coef_uni":
sub_title = "Unique explained variance\nper coefficient"
logger.info(sub_title, extra={"spacing": "\n"})
dims_all = []
for key in log_dims:
if key in xyzc_dims:
# get mean/med
if key not in expl_var[var_type].keys():
dims_all.append("dummy")
continue
dims_all.append(np.asarray(expl_var[var_type][key])[rs, 0])
math_util.log_stats(
expl_var[var_type][key][all_rs],
stat_str=key.ljust(dim_length), log_spacing=TAB
)
if not plot_bools[-1]:
continue
if v == 0:
y = 1.12
subpl_title = f"{title}\n{sub_title}"
else:
y = 1.02
subpl_title = sub_title
# retrieve values and names for each dimension, including dummy
# dimensions
use_xyzc_dims = []
n_vals = None
dummies = []
pads = [16, 16, 20]
for d, dim in enumerate(dims_all):
dim_name = xyzc_dims[d].replace("_", " ")
if " direction" in dim_name:
dim_name = dim_name.replace(" direction", "\ndirection")
pads[d] = 24
if isinstance(dim, str) and dim == "dummy":
dummies.append(d)
use_xyzc_dims.append(f"{dim_name} (dummy)")
else:
n_vals = len(dim)
use_xyzc_dims.append(dim_name)
for d in dummies:
dims_all[d] = np.zeros(n_vals)
[x_data, y_data, z_data, c_data] = dims_all
sub_ax = ax[v, i]
im = sub_ax.scatter(
x_data, y_data, z_data, c=c_data, cmap=cmap,
vmin=c_range[0], vmax=c_range[1]
)
sub_ax.set_title(subpl_title, y=y)
# sub_ax.set_zlim3d(0, 1.0)
# adjust padding for z axis
sub_ax.tick_params(axis='z', which='major', pad=10)
# add labels
sub_ax.set_xlabel(use_xyzc_dims[0], labelpad=pads[0])
sub_ax.set_ylabel(use_xyzc_dims[1], labelpad=pads[1])
sub_ax.set_zlabel(use_xyzc_dims[2], labelpad=pads[2])
if v == 0:
full_ev_lab = math_util.log_stats(
full_ev, stat_str="Full EV", ret_str_only=True
)
sub_ax.plot([], [], c="k", label=full_ev_lab)
sub_ax.legend()
i += 1
if fig is not None:
plot_util.add_colorbar(
fig, im, n_sess, label=use_xyzc_dims[3],
space_fact=np.max([2, n_sess])
)
# plot 0 planes, and lines
for sub_ax in ax.reshape(-1):
sub_ax.autoscale(False)
all_lims = [sub_ax.get_xlim(), sub_ax.get_ylim(), sub_ax.get_zlim()]
xs, ys, zs = [
[vs[0] - (vs[1] - vs[0]) * 0.02, vs[1] + (vs[1] - vs[0]) * 0.02]
for vs in all_lims
]
for plane in ["x", "y", "z"]:
if plane == "x":
xx, yy = np.meshgrid(xs, ys)
zz = xx * 0
x_flat = xs
y_flat, z_flat = [0, 0], [0, 0]
elif plane == "y":
yy, zz = np.meshgrid(ys, zs)
xx = yy * 0
y_flat = ys
z_flat, x_flat = [0, 0], [0, 0]
elif plane == "z":
zz, xx = np.meshgrid(zs, xs)
yy = zz * 0
z_flat = zs
x_flat, y_flat = [0, 0], [0, 0]
sub_ax.plot_surface(xx, yy, zz, alpha=0.05, color="k")
sub_ax.plot(
x_flat, y_flat, z_flat, alpha=0.4, color="k", ls=(0, (2, 2))
)
if savedir is None:
savedir = Path(
figpar["dirs"]["roi"],
figpar["dirs"]["glm"])
savename = (f"roi_glm_ev_{sessstr}{dendstr}")
fulldir = plot_util.savefig(fig, savename, savedir, **figpar["save"])
return fulldir, savename
def plot_autocorr(analyspar, sesspar, stimpar, extrapar, autocorrpar,
sess_info, autocorr_data, figpar=None, savedir=None):
"""
plot_autocorr(analyspar, sesspar, stimpar, extrapar, autocorrpar,
sess_info, autocorr_data)
From dictionaries, plots autocorrelation during stimulus blocks.
Required args:
- analyspar (dict) : dictionary with keys of AnalysPar namedtuple
- sesspar (dict) : dictionary with keys of SessPar namedtuple
- stimpar (dict) : dictionary with keys of StimPar namedtuple
- extrapar (dict) : dictionary containing additional analysis
parameters
["analysis"] (str): analysis type (e.g., "a")
["datatype"] (str): datatype (e.g., "run", "roi")
- autocorrpar (dict) : dictionary with keys of AutocorrPar namedtuple
- sess_info (dict) : dictionary containing information from each
session
["mouse_ns"] (list) : mouse numbers
["sess_ns"] (list) : session numbers
["lines"] (list) : mouse lines
["planes"] (list) : imaging planes
["nrois"] (list) : number of ROIs in session
- autocorr_data (dict): dictionary containing data to plot:
["xrans"] (list): list of lag values in seconds for each session
["stats"] (list): list of 3D arrays (or nested lists) of
autocorrelation statistics, structured as:
sessions stats (me, err)
x ROI or 1x and 10x lag
x lag
Optional args:
- figpar (dict): dictionary containing the following figure parameter
dictionaries
default: None
["init"] (dict): dictionary with figure initialization parameters
["save"] (dict): dictionary with figure saving parameters
["dirs"] (dict): dictionary with additional figure parameters
- savedir (str): path of directory in which to save plots.
default: None
Returns:
- fulldir (str) : final path of the directory in which the figure is
saved (may differ from input savedir, if datetime
subfolder is added.)
- savename (str): name under which the figure is saved
"""
statstr_pr = sess_str_util.stat_par_str(
analyspar["stats"], analyspar["error"], "print")
stimstr_pr = sess_str_util.stim_par_str(
stimpar["stimtype"], stimpar["visflow_dir"], stimpar["visflow_size"],
stimpar["gabk"], "print")
dendstr_pr = sess_str_util.dend_par_str(
analyspar["dend"], sesspar["plane"], extrapar["datatype"], "print")
sessstr = sess_str_util.sess_par_str(
sesspar["sess_n"], stimpar["stimtype"], sesspar["plane"],
stimpar["visflow_dir"],stimpar["visflow_size"], stimpar["gabk"])
dendstr = sess_str_util.dend_par_str(
analyspar["dend"], sesspar["plane"], extrapar["datatype"])
datatype = extrapar["datatype"]
if datatype == "roi":
fluorstr_pr = sess_str_util.fluor_par_str(
analyspar["fluor"], str_type="print")
if autocorrpar["byitem"]:
title_str = u"{}\nautocorrelation".format(fluorstr_pr)
else:
title_str = "\nautocorr. acr. ROIs" .format(fluorstr_pr)
elif datatype == "run":
datastr = sess_str_util.datatype_par_str(datatype)
title_str = u"\n{} autocorrelation".format(datastr)
if stimpar["stimtype"] == "gabors":
seq_bars = [-1.5, 1.5] # light lines
else:
seq_bars = [-1.0, 1.0] # light lines
# extract some info from sess_info
keys = ["mouse_ns", "sess_ns", "lines", "planes"]
[mouse_ns, sess_ns, lines, planes] = [sess_info[key] for key in keys]
nroi_strs = sess_str_util.get_nroi_strs(sess_info, empty=(datatype!="roi"))
n_sess = len(mouse_ns)
xrans = autocorr_data["xrans"]
stats = [np.asarray(stat) for stat in autocorr_data["stats"]]
lag_s = autocorrpar["lag_s"]
xticks = np.linspace(-lag_s, lag_s, lag_s*2+1)
yticks = np.linspace(0, 1, 6)
if figpar is None:
figpar = sess_plot_util.init_figpar()
byitemstr = ""
if autocorrpar["byitem"]:
byitemstr = "_byroi"
fig, ax = plot_util.init_fig(n_sess, **figpar["init"])
for i in range(n_sess):
sub_ax = plot_util.get_subax(ax, i)
title = (f"Mouse {mouse_ns[i]} - {stimstr_pr}, "
u"{} ".format(statstr_pr) + f"{title_str} (sess "
f"{sess_ns[i]}, {lines[i]} {planes[i]}{dendstr_pr}{nroi_strs[i]})")
# transpose to ROI/lag x stats x series
sess_stats = stats[i].transpose(1, 0, 2)
for s, sub_stats in enumerate(sess_stats):
lab = None
if not autocorrpar["byitem"]:
lab = ["actual lag", "10x lag"][s]
plot_util.plot_traces(
sub_ax, xrans[i], sub_stats[0], sub_stats[1:], xticks=xticks,
yticks=yticks, alpha=0.2, label=lab)
plot_util.add_bars(sub_ax, hbars=seq_bars)
sub_ax.set_ylim([0, 1])
sub_ax.set_title(title, y=1.02)
if sub_ax.is_last_row():
sub_ax.set_xlabel("Lag (s)")
plot_util.turn_off_extra(ax, n_sess)
if savedir is None:
savedir = Path(
figpar["dirs"][datatype],
figpar["dirs"]["autocorr"])
savename = (f"{datatype}_autocorr{byitemstr}_{sessstr}{dendstr}")
fulldir = plot_util.savefig(fig, savename, savedir, **figpar["save"])
return fulldir, savename
def plot_mag_change(analyspar, sesspar, stimpar, extrapar, permpar, quantpar,
sess_info, mags, figpar=None, savedir=None):
"""
plot_mag_change(analyspar, sesspar, stimpar, extrapar, permpar, quantpar,
sess_info, mags)
From dictionaries, plots magnitude of change in unexpected and expected
responses across quantiles.
Returns figure name and save directory path.
Required args:
- analyspar (dict): dictionary with keys of AnalysPar namedtuple
- sesspar (dict) : dictionary with keys of SessPar namedtuple
- stimpar (dict) : dictionary with keys of StimPar namedtuple
- extrapar (dict) : dictionary containing additional analysis
parameters
["analysis"] (str): analysis type (e.g., "m")
["datatype"] (str): datatype (e.g., "run", "roi")
["seed"] (int): seed value used
- permpar (dict) : dictionary with keys of PermPar namedtuple
- quantpar (dict) : dictionary with keys of QuantPar namedtuple
- roigrppar (dict): dictionary with keys of RoiGrpPar namedtuple
- sess_info (dict): dictionary containing information from each
session
["mouse_ns"] (list) : mouse numbers
["sess_ns"] (list) : session numbers
["lines"] (list) : mouse lines
["planes"] (list) : imaging planes
["nrois"] (list) : number of ROIs in session
- mags (dict) : dictionary containing magnitude data to plot
["L2"] (array-like) : nested list containing L2 norms,
structured as:
sess x scaling x unexp
["L2_sig"] (list) : L2 significance results for each session
("hi", "lo" or "no")
["mag_sig"] (list) : magnitude significance results for each
session
("hi", "lo" or "no")
["mag_st"] (array-like): array or nested list containing magnitude
stats across ROIs, structured as:
sess x scaling x unexp x stats
Optional args:
- figpar (dict): dictionary containing the following figure parameter
dictionaries
default: None
["init"] (dict): dictionary with figure initialization parameters
["save"] (dict): dictionary with figure saving parameters
["dirs"] (dict): dictionary with additional figure parameters
- savedir (str): path of directory in which to save plots.
default: None
Returns:
- fulldir (str) : final path of the directory in which the figure is
saved (may differ from input savedir, if datetime
subfolder is added.)
- savename (str): name under which the figure is saved
"""
sessstr_pr = sess_str_util.sess_par_str(
sesspar["sess_n"], stimpar["stimtype"], sesspar["plane"],
stimpar["visflow_dir"], stimpar["visflow_size"], stimpar["gabk"],
"print")
statstr_pr = sess_str_util.stat_par_str(
analyspar["stats"], analyspar["error"], "print")
dendstr_pr = sess_str_util.dend_par_str(
analyspar["dend"], sesspar["plane"], extrapar["datatype"], "print")
sessstr = sess_str_util.sess_par_str(
sesspar["sess_n"], stimpar["stimtype"], sesspar["plane"],
stimpar["visflow_dir"],stimpar["visflow_size"], stimpar["gabk"])
dendstr = sess_str_util.dend_par_str(
analyspar["dend"], sesspar["plane"], extrapar["datatype"])
datatype = extrapar["datatype"]
dimstr = sess_str_util.datatype_dim_str(datatype)
# extract some info from sess_info
keys = ["mouse_ns", "sess_ns", "lines", "planes"]
[mouse_ns, sess_ns, lines, planes] = [sess_info[key] for key in keys]
nroi_strs = sess_str_util.get_nroi_strs(
sess_info, empty=(datatype!="roi"), style="par"
)
n_sess = len(mouse_ns)
qu_ns = [gen_util.pos_idx(q, quantpar["n_quants"]) + 1
for q in quantpar["qu_idx"]]
if len(qu_ns) != 2:
raise ValueError(f"Expected 2 quantiles, not {len(qu_ns)}.")
mag_st = np.asarray(mags["mag_st"])
if figpar is None:
figpar = sess_plot_util.init_figpar()
figpar = copy.deepcopy(figpar)
if figpar["save"]["use_dt"] is None:
figpar["save"]["use_dt"] = gen_util.create_time_str()
figpar["init"]["subplot_wid"] *= n_sess/2.0
scales = [False, True]
# get plot elements
barw = 0.75
# scaling strings for printing and filenames
leg = ["exp", "unexp"]
cent, bar_pos, xlims = plot_util.get_barplot_xpos(n_sess, len(leg), barw)
title = (u"Magnitude ({}) of difference in activity".format(statstr_pr) +
f"\nbetween Q{qu_ns[0]} and {qu_ns[1]} across {dimstr} "
f"\n({sessstr_pr})")
labels = [f"Mouse {mouse_ns[i]} sess {sess_ns[i]},\n {lines[i]} {planes[i]}"
f"{dendstr_pr}{nroi_strs[i]}" for i in range(n_sess)]
figs, axs = [], []
for sc, scale in enumerate(scales):
scalestr_pr = sess_str_util.scale_par_str(scale, "print")
fig, ax = plot_util.init_fig(1, **figpar["init"])
figs.append(fig)
axs.append(ax)
sub_ax = ax[0, 0]
# always set ticks (even again) before setting labels
sub_ax.set_xticks(cent)
sub_ax.set_xticklabels(labels)
title_scale = u"{}{}".format(title, scalestr_pr)
sess_plot_util.add_axislabels(
sub_ax, fluor=analyspar["fluor"], area=True, scale=scale, x_ax="",
datatype=datatype)
for s, lab in enumerate(leg):
xpos = list(zip(*bar_pos))[s]
plot_util.plot_bars(
sub_ax, xpos, mag_st[:, sc, s, 0], err=mag_st[:, sc, s, 1:],
width=barw, xlims=xlims, xticks="None", label=lab, capsize=4,
title=title_scale, hline=0)
# add significance markers
for i in range(n_sess):
signif = mags["mag_sig"][i]
if signif in ["hi", "lo"]:
xpos = bar_pos[i]
for sc, (ax, scale) in enumerate(zip(axs, scales)):
yval = mag_st[i, sc, :, 0]
yerr = mag_st[i, sc, :, 1:]
plot_util.plot_barplot_signif(ax[0, 0], xpos, yval, yerr)
plot_util.turn_off_extra(ax, n_sess)
# figure directory
if savedir is None:
savedir = Path(
figpar["dirs"][datatype],
figpar["dirs"]["unexp_qu"],
figpar["dirs"]["mags"])
log_dir = False
for i, (fig, scale) in enumerate(zip(figs, scales)):
if i == len(figs) - 1:
log_dir = True
scalestr = sess_str_util.scale_par_str(scale)
savename = f"{datatype}_mag_diff_{sessstr}{dendstr}"
savename_full = f"{savename}{scalestr}"
fulldir = plot_util.savefig(
fig, savename_full, savedir, log_dir=log_dir, ** figpar["save"])
return fulldir, savename
def plot_traces_by_qu_lock_sess(analyspar, sesspar, stimpar, extrapar,
quantpar, sess_info, trace_stats,
figpar=None, savedir=None, modif=False):
"""
plot_traces_by_qu_lock_sess(analyspar, sesspar, stimpar, extrapar,
quantpar, sess_info, trace_stats)
From dictionaries, plots traces by quantile, locked to transitions from
unexpected to expected or v.v. with each session in a separate subplot.
Returns figure name and save directory path.
Required args:
- analyspar (dict) : dictionary with keys of AnalysPar namedtuple
- sesspar (dict) : dictionary with keys of SessPar namedtuple
- stimpar (dict) : dictionary with keys of StimPar namedtuple
- extrapar (dict) : dictionary containing additional analysis
parameters
["analysis"] (str): analysis type (e.g., "l")
["datatype"] (str): datatype (e.g., "run", "roi")
- quantpar (dict) : dictionary with keys of QuantPar namedtuple
- sess_info (dict) : dictionary containing information from each
session
["mouse_ns"] (list) : mouse numbers
["sess_ns"] (list) : session numbers
["lines"] (list) : mouse lines
["planes"] (list) : imaging planes
if datatype ==
["nrois"] (list) : number of ROIs in session
- trace_stats (dict): dictionary containing trace stats information
["xrans"] (list) : time values for the 2p frames for each
session
["all_stats"] (list) : list of 4D arrays or lists of trace
data statistics across ROIs for each
session, structured as:
(unexp_len x) quantiles x
stats (me, err) x frames
["all_counts"] (array-like): number of sequences, structured as:
sess x (unexp_len x) quantiles
["lock"] (str) : value to which segments are locked:
"unexp", "exp" or "unexp_split"
["baseline"] (num) : number of seconds used for baseline
["exp_stats"] (list) : list of 3D arrays or lists of trace
data statistics across ROIs for
expected sampled sequences,
structured as:
quantiles (1) x stats (me, err)
x frames
["exp_counts"] (array-like): number of sequences corresponding to
exp_stats, structured as:
sess x quantiles (1)
if data is by unexp_len:
["unexp_lens"] (list) : number of consecutive segments for
each unexp_len, structured by session
Optional args:
- figpar (dict): dictionary containing the following figure parameter
dictionaries
default: None
["init"] (dict): dictionary with figure initialization parameters
["save"] (dict): dictionary with figure saving parameters
["dirs"] (dict): dictionary with additional figure parameters
- savedir (str): path of directory in which to save plots.
default: None
- modif (bool) : if True, modified (slimmed-down) plots are created
instead
default: False
Returns:
- fulldir (str) : final path of the directory in which the figure is
saved (may differ from input savedir, if datetime
subfolder is added.)
- savename (str): name under which the figure is saved
"""
analyspar["dend"] = None
stimstr_pr = sess_str_util.stim_par_str(
stimpar["stimtype"], stimpar["visflow_dir"], stimpar["visflow_size"],
stimpar["gabk"], "print")
statstr_pr = sess_str_util.stat_par_str(
analyspar["stats"], analyspar["error"], "print")
dendstr_pr = sess_str_util.dend_par_str(
analyspar["dend"], sesspar["plane"], extrapar["datatype"], "print")
sessstr = sess_str_util.sess_par_str(
sesspar["sess_n"], stimpar["stimtype"], sesspar["plane"],
stimpar["visflow_dir"], stimpar["visflow_size"], stimpar["gabk"])
dendstr = sess_str_util.dend_par_str(
analyspar["dend"], sesspar["plane"], extrapar["datatype"])
basestr = sess_str_util.base_par_str(trace_stats["baseline"])
basestr_pr = sess_str_util.base_par_str(trace_stats["baseline"], "print")
datatype = extrapar["datatype"]
dimstr = sess_str_util.datatype_dim_str(datatype)
# extract some info from sess_info
keys = ["mouse_ns", "sess_ns", "lines", "planes"]
[mouse_ns, sess_ns, lines, planes] = [sess_info[key] for key in keys]
nroi_strs = sess_str_util.get_nroi_strs(sess_info, empty=(datatype!="roi"))
n_sess = len(mouse_ns)
xrans = [np.asarray(xran) for xran in trace_stats["xrans"]]
all_stats = [np.asarray(sessst) for sessst in trace_stats["all_stats"]]
exp_stats = [np.asarray(expst) for expst in trace_stats["exp_stats"]]
all_counts = trace_stats["all_counts"]
exp_counts = trace_stats["exp_counts"]
lock = trace_stats["lock"]
col_idx = 0
if "unexp" in lock:
lock = "unexp"
col_idx = 1
# plot unexp_lens default values
if stimpar["stimtype"] == "gabors":
DEFAULT_UNEXP_LEN = [3.0, 4.5, 6.0]
if stimpar["gabfr"] not in ["any", "all"]:
offset = sess_str_util.gabfr_nbrs(stimpar["gabfr"])
else:
DEFAULT_UNEXP_LEN = [2.0, 3.0, 4.0]
offset = 0
unexp_lab, len_ext = "", ""
unexp_lens = [[None]] * n_sess
unexp_len_default = True
if "unexp_lens" in trace_stats.keys():
unexp_len_default = False
unexp_lens = trace_stats["unexp_lens"]
len_ext = "_bylen"
if stimpar["stimtype"] == "gabors":
unexp_lens = [
[sl * 1.5/5 - 0.3 * offset for sl in sls] for sls in unexp_lens
]
inv = 1 if lock == "unexp" else -1
# RANGE TO PLOT
if modif:
st_val = -2.0
end_val = 6.0
n_ticks = int((end_val - st_val) // 2 + 1)
else:
n_ticks = 21
if figpar is None:
figpar = sess_plot_util.init_figpar()
figpar = copy.deepcopy(figpar)
if modif:
figpar["init"]["subplot_wid"] = 6.5
else:
figpar["init"]["subplot_wid"] *= 2
fig, ax = plot_util.init_fig(n_sess, **figpar["init"])
exp_min, exp_max = np.inf, -np.inf
for i, (stats, counts) in enumerate(zip(all_stats, all_counts)):
sub_ax = plot_util.get_subax(ax, i)
# plot expected data
if exp_stats[i].shape[0] != 1:
raise ValueError("Expected only one quantile for exp_stats.")
n_lines = quantpar["n_quants"] * len(unexp_lens[i])
cols = sess_plot_util.get_quant_cols(n_lines)[0][col_idx]
if len(cols) < n_lines:
cols = [None] * n_lines
if modif:
line = "2/3" if "23" in lines[i] else "5"
plane = "somata" if "soma" in planes[i] else "dendrites"
title = f"M{mouse_ns[i]} - layer {line} {plane}{dendstr_pr}"
lab = "exp" if i == 0 else None
y_ax = None if i == 0 else ""
st, end = 0, len(xrans[i])
st_vals = list(filter(
lambda j: xrans[i][j] <= st_val, range(len(xrans[i]))
))
end_vals = list(filter(
lambda j: xrans[i][j] >= end_val, range(len(xrans[i]))
))
if len(st_vals) != 0:
st = st_vals[-1]
if len(end_vals) != 0:
end = end_vals[0] + 1
time_slice = slice(st, end)
else:
title = (f"Mouse {mouse_ns[i]} - {stimstr_pr}, "
u"{} ".format(statstr_pr) + f"{lock} locked across {dimstr}"
f"{basestr_pr}\n(sess {sess_ns[i]}, {lines[i]} {planes[i]}"
f"{dendstr_pr}{nroi_strs[i]})")
lab = f"exp (no lock) ({exp_counts[i][0]})"
y_ax = None
st = 0
end = len(xrans[i])
time_slice = slice(None) # use all
# add length markers
use_unexp_lens = unexp_lens[i]
if unexp_len_default:
use_unexp_lens = DEFAULT_UNEXP_LEN
leng_col = sess_plot_util.get_quant_cols(1)[0][col_idx][0]
for leng in use_unexp_lens:
if leng is None:
continue
edge = leng * inv
if edge < 0:
edge = np.max([xrans[i][st], edge])
elif edge > 0:
edge = np.min([xrans[i][end - 1], edge])
plot_util.add_vshade(
sub_ax, 0, edge, color=leng_col, alpha=0.1)
sess_plot_util.add_axislabels(
sub_ax, fluor=analyspar["fluor"], datatype=datatype, y_ax=y_ax
)
plot_util.add_bars(sub_ax, hbars=0)
alpha = np.min([0.4, 0.8 / n_lines])
if stimpar["stimtype"] == "gabors":
sess_plot_util.plot_gabfr_pattern(
sub_ax, xrans[i], offset=offset, bars_omit=[0] + unexp_lens[i]
)
plot_util.plot_traces(
sub_ax, xrans[i][time_slice], exp_stats[i][0][0, time_slice],
exp_stats[i][0][1:, time_slice], n_xticks=n_ticks,
alpha=alpha, label=lab, alpha_line=0.8, color="darkgray",
xticks="auto")
# get expected data range to adjust y lims
exp_min = np.min([exp_min, np.nanmin(exp_stats[i][0][0])])
exp_max = np.max([exp_max, np.nanmax(exp_stats[i][0][0])])
n = 0 # count lines plotted
for s, unexp_len in enumerate(unexp_lens[i]):
if unexp_len is not None:
counts, stats = all_counts[i][s], all_stats[i][s]
# remove offset
unexp_lab = f"unexp len {unexp_len + 0.3 * offset}"
else:
unexp_lab = "unexp" if modif else f"{lock} lock"
for q, qu_idx in enumerate(quantpar["qu_idx"]):
qu_lab = ""
if quantpar["n_quants"] > 1:
qu_lab = "{} ".format(sess_str_util.quantile_str(
qu_idx, quantpar["n_quants"], str_type="print"
))
lab = f"{qu_lab}{unexp_lab}"
if modif:
lab = lab if i == 0 else None
else:
lab = f"{lab} ({counts[q]})"
if n == 2 and cols[n] is None:
sub_ax.plot([], []) # to advance the color cycle (past gray)
plot_util.plot_traces(sub_ax, xrans[i][time_slice],
stats[q][0, time_slice], stats[q][1:, time_slice], title,
alpha=alpha, label=lab, n_xticks=n_ticks, alpha_line=0.8,
color=cols[n], xticks="auto")
n += 1
if unexp_len is not None:
plot_util.add_bars(
sub_ax, hbars=unexp_len, color=sub_ax.lines[-1].get_color(),
alpha=1)
plot_util.turn_off_extra(ax, n_sess)
if savedir is None:
savedir = Path(
figpar["dirs"][datatype],
figpar["dirs"]["unexp_qu"],
f"{lock}_lock", basestr.replace("_", ""))
if not modif:
if stimpar["stimtype"] == "visflow":
plot_util.rel_confine_ylims(sub_ax, [exp_min, exp_max], 5)
qu_str = f"_{quantpar['n_quants']}q"
if quantpar["n_quants"] == 1:
qu_str = ""
savename = (f"{datatype}_av_{lock}_lock{len_ext}{basestr}_{sessstr}"
f"{dendstr}{qu_str}")
fulldir = plot_util.savefig(fig, savename, savedir, **figpar["save"])
return fulldir, savename
def plot_from_dict(dict_path, plt_bkend=None, fontdir=None, parallel=False,
datetime=True, overwrite=False):
"""
plot_from_dict(dict_path)
Plots data from dictionaries containing analysis parameters and results.
Required args:
- dict_path (Path): path to dictionary to plot data from
Optional_args:
- plt_bkend (str) : mpl backend to use for plotting (e.g., "agg")
default: None
- fontdir (Path) : path to directory where additional fonts are stored
default: None
- parallel (bool) : if True, some of the plotting is parallelized
across CPU cores
default: False
- datetime (bool) : figpar["save"] datatime parameter (whether to
place figures in a datetime folder)
default: True
- overwrite (bool): figpar["save"] overwrite parameter (whether to
overwrite figures)
default: False
"""
logger.info(f"Plotting from dictionary: {dict_path}",
extra={"spacing": "\n"})
figpar = sess_plot_util.init_figpar(
plt_bkend=plt_bkend, fontdir=fontdir, datetime=datetime,
overwrite=overwrite
)
plot_util.manage_mpl(cmap=False, **figpar["mng"])
dict_path = Path(dict_path)
info = file_util.loadfile(dict_path)
savedir = dict_path.parent
analysis = info["extrapar"]["analysis"]
# 0. Plots the full traces for each session
if analysis == "f": # full traces
plot_full_traces(figpar=figpar, savedir=savedir, **info)
# 1. Plot average traces by quantile x unexpected for each session
elif analysis == "t": # traces
plot_traces_by_qu_unexp_sess(figpar=figpar, savedir=savedir, **info)
# 2. Plot average traces by quantile, locked to unexpected for each session
elif analysis == "l": # unexpected locked traces
plot_traces_by_qu_lock_sess(figpar=figpar, savedir=savedir, **info)
# 3. Plot magnitude of change in dF/F area from first to last quantile of
# unexpected vs no unexpected sequences, for each session
elif analysis == "m": # mag
plot_mag_change(figpar=figpar, savedir=savedir, **info)
# 4. Plot autocorrelations
elif analysis == "a": # autocorr
plot_autocorr(figpar=figpar, savedir=savedir, **info)
else:
warnings.warn(f"No plotting function for analysis {analysis}",
category=UserWarning, stacklevel=1)
plot_util.cond_close_figs()
def plot_traces_by_qu_unexp_sess(analyspar, sesspar, stimpar, extrapar,
quantpar, sess_info, trace_stats, figpar=None,
savedir=None, modif=False):
"""
plot_traces_by_qu_unexp_sess(analyspar, sesspar, stimpar, extrapar,
quantpar, sess_info, trace_stats)
From dictionaries, plots traces by quantile/unexpected with each session in a
separate subplot.
Returns figure name and save directory path.
Required args:
- analyspar (dict) : dictionary with keys of AnalysPar namedtuple
- sesspar (dict) : dictionary with keys of SessPar namedtuple
- stimpar (dict) : dictionary with keys of StimPar namedtuple
- extrapar (dict) : dictionary containing additional analysis
parameters
["analysis"] (str): analysis type (e.g., "t")
["datatype"] (str): datatype (e.g., "run", "roi")
- quantpar (dict) : dictionary with keys of QuantPar namedtuple
- sess_info (dict) : dictionary containing information from each
session
["mouse_ns"] (list) : mouse numbers
["sess_ns"] (list) : session numbers
["lines"] (list) : mouse lines
["planes"] (list) : imaging planes
if extrapar["datatype"] == "roi":
["nrois"] (list) : number of ROIs in session
- trace_stats (dict): dictionary containing trace stats information
["xrans"] (list) : time values for the frames, for each
session
["all_stats"] (list) : list of 4D arrays or lists of trace
data statistics across ROIs for each
session, structured as:
sess x unexp x quantiles x
stats (me, err) x frames
["all_counts"] (array-like): number of sequences, structured as:
sess x unexp x quantiles
Optional args:
- figpar (dict): dictionary containing the following figure parameter
dictionaries
default: None
["init"] (dict): dictionary with figure initialization parameters
["save"] (dict): dictionary with figure saving parameters
["dirs"] (dict): dictionary with additional figure parameters
- savedir (str): path of directory in which to save plots.
default: None
- modif (bool) : if True, modified (slimmed-down) plots are created
instead
default: False
Returns:
- fulldir (str) : final path of the directory in which the figure is
saved (may differ from input savedir, if datetime
subfolder is added.)
- savename (str): name under which the figure is saved
"""
stimstr_pr = sess_str_util.stim_par_str(
stimpar["stimtype"], stimpar["visflow_dir"], stimpar["visflow_size"],
stimpar["gabk"], "print")
statstr_pr = sess_str_util.stat_par_str(
analyspar["stats"], analyspar["error"], "print")
dendstr_pr = sess_str_util.dend_par_str(
analyspar["dend"], sesspar["plane"], extrapar["datatype"], "print")
sessstr = sess_str_util.sess_par_str(
sesspar["sess_n"], stimpar["stimtype"], sesspar["plane"],
stimpar["visflow_dir"], stimpar["visflow_size"], stimpar["gabk"])
dendstr = sess_str_util.dend_par_str(
analyspar["dend"], sesspar["plane"], extrapar["datatype"])
datatype = extrapar["datatype"]
dimstr = sess_str_util.datatype_dim_str(datatype)
# extract some info from sess_info
keys = ["mouse_ns", "sess_ns", "lines", "planes"]
[mouse_ns, sess_ns, lines, planes] = [sess_info[key] for key in keys]
nroi_strs = sess_str_util.get_nroi_strs(sess_info, empty=(datatype!="roi"))
n_sess = len(mouse_ns)
xrans = [np.asarray(xran) for xran in trace_stats["xrans"]]
all_stats = [np.asarray(sessst) for sessst in trace_stats["all_stats"]]
all_counts = trace_stats["all_counts"]
cols, lab_cols = sess_plot_util.get_quant_cols(quantpar["n_quants"])
alpha = np.min([0.4, 0.8 / quantpar["n_quants"]])
unexps = ["exp", "unexp"]
n = 6
if figpar is None:
figpar = sess_plot_util.init_figpar()
fig, ax = plot_util.init_fig(n_sess, **figpar["init"])
for i in range(n_sess):
sub_ax = plot_util.get_subax(ax, i)
for s, [col, leg_ext] in enumerate(zip(cols, unexps)):
for q, qu_idx in enumerate(quantpar["qu_idx"]):
qu_lab = ""
if quantpar["n_quants"] > 1:
qu_lab = "{} ".format(sess_str_util.quantile_str(
qu_idx, quantpar["n_quants"], str_type="print"
))
if modif:
line = "2/3" if "23" in lines[i] else "5"
plane = "somata" if "soma" in planes[i] else "dendrites"
title = f"M{mouse_ns[i]} - layer {line} {plane}{dendstr_pr}"
leg = f"{qu_lab}{leg_ext}" if i == 0 else None
y_ax = None if i == 0 else ""
else:
title=(f"Mouse {mouse_ns[i]} - {stimstr_pr}, "
u"{}\n".format(statstr_pr) + f"across {dimstr} (sess "
f"{sess_ns[i]}, {lines[i]} {planes[i]}{dendstr_pr}"
f"{nroi_strs[i]})")
leg = f"{qu_lab}{leg_ext} ({all_counts[i][s][q]})"
y_ax = None
plot_util.plot_traces(
sub_ax, xrans[i], all_stats[i][s, q, 0],
all_stats[i][s, q, 1:], title, color=col[q], alpha=alpha,
label=leg, n_xticks=n, xticks="auto")
sess_plot_util.add_axislabels(
sub_ax, fluor=analyspar["fluor"], datatype=datatype,
y_ax=y_ax)
plot_util.turn_off_extra(ax, n_sess)
if stimpar["stimtype"] == "gabors":
sess_plot_util.plot_labels(
ax, stimpar["gabfr"], "both", pre=stimpar["pre"],
post=stimpar["post"], cols=lab_cols,
sharey=figpar["init"]["sharey"])
if savedir is None:
savedir = Path(
figpar["dirs"][datatype],
figpar["dirs"]["unexp_qu"])
qu_str = f"_{quantpar['n_quants']}q"
if quantpar["n_quants"] == 1:
qu_str = ""
savename = f"{datatype}_av_{sessstr}{dendstr}{qu_str}"
fulldir = plot_util.savefig(fig, savename, savedir, **figpar["save"])
return fulldir, savename
def plot_full_traces(analyspar, sesspar, extrapar, sess_info, trace_info,
roi_tr=None, figpar=None, savedir=None):
"""
plot_full_traces(analyspar, sesspar, extrapar, sess_info, trace_info)
From dictionaries, plots full traces for each session in a separate subplot.
Returns figure name and save directory path.
Required args:
- analyspar (dict) : dictionary with keys of AnalysPar namedtuple
- sesspar (dict) : dictionary with keys of SessPar namedtuple
- extrapar (dict) : dictionary containing additional analysis
parameters
["analysis"] (str): analysis type (e.g., "f")
["datatype"] (str): datatype (e.g., "run", "roi")
- sess_info (dict) : dictionary containing information from each
session
["mouse_ns"] (list) : mouse numbers
["sess_ns"] (list) : session numbers
["lines"] (list) : mouse lines
["planes"] (list) : imaging planes
["nrois"] (list) : number of ROIs in session
- trace_info (dict): dictionary containing trace information
["all_tr"] (nested list): trace values structured as
sess x
(me/err if datatype is "roi" x)
frames
["all_edges"] (list) : frame edge values for each parameter,
structured as sess x block x
edges ([start, end])
["all_pars"] (list) : stimulus parameter strings structured as
sess x block
Optional args:
- roi_tr (list): trace values for each ROI, structured as
sess x ROI x frames
default: None
- figpar (dict): dictionary containing the following figure parameter
dictionaries
default: None
["init"] (dict): dictionary with figure initialization parameters
["save"] (dict): dictionary with figure saving parameters
["dirs"] (dict): dictionary with additional figure parameters
- savedir (str): path of directory in which to save plots.
default: None
Returns:
- fulldir (str) : final path of the directory in which the figure is
saved (may differ from input savedir, if datetime
subfolder is added.)
- savename (str): name under which the figure is saved
"""
statstr_pr = sess_str_util.stat_par_str(
analyspar["stats"], analyspar["error"], "print")
dendstr_pr = sess_str_util.dend_par_str(
analyspar["dend"], sesspar["plane"], extrapar["datatype"], "print")
sessstr = f"sess{sesspar['sess_n']}_{sesspar['plane']}"
dendstr = sess_str_util.dend_par_str(
analyspar["dend"], sesspar["plane"], extrapar["datatype"])
datatype = extrapar["datatype"]
# extract some info from sess_info
keys = ["mouse_ns", "sess_ns", "lines", "planes"]
[mouse_ns, sess_ns, lines, planes] = [sess_info[key] for key in keys]
nroi_strs = sess_str_util.get_nroi_strs(sess_info, empty=(datatype!="roi"))
n_sess = len(mouse_ns)
if figpar is None:
figpar = sess_plot_util.init_figpar()
figpar = copy.deepcopy(figpar)
figpar["init"]["subplot_wid"] = 10
figpar["init"]["ncols"] = n_sess
if datatype == "roi":
figpar["save"]["fig_ext"] = "jpg"
figpar["init"]["sharex"] = False
figpar["init"]["sharey"] = False
# set subplot ratios and removes extra space between plots vertically
gs = {"height_ratios": [5, 1], "hspace": 0.1}
n_rows = 2
if roi_tr is None:
raise ValueError("Cannot plot data as ROI traces are missing "
"(not recorded in dictionary, likely due to size).")
else:
gs = None
n_rows = 1
if datatype == "roi" and not figpar["save"]["save_fig"]:
warnings.warn("Figure plotting is being skipped. Since full ROI traces "
"are not saved to dictionary, to actually plot traces, analysis "
"will have to be rerun with 'save_fig' set to True.",
stacklevel=1)
fig, ax = plot_util.init_fig(n_sess*n_rows, gs=gs, **figpar["init"])
label_height = 0.8
if datatype == "roi":
fig.subplots_adjust(top=0.92) # remove extra white space at top
label_height = 0.55
for i in range(n_sess):
title = (f"Mouse {mouse_ns[i]} (sess {sess_ns[i]}, {lines[i]} "
f"{planes[i]}{dendstr_pr}{nroi_strs[i]})")
sub_axs = ax[:, i]
sub_axs[0].set_title(title, y=1.02)
if datatype == "roi":
xran = range(len(trace_info["all_tr"][i][1]))
# each ROI (top subplot)
plot_util.plot_sep_data(sub_axs[0], np.asarray(roi_tr[i]), 0.1)
sess_plot_util.add_axislabels(
sub_axs[0], fluor=analyspar["fluor"], scale=True,
datatype=datatype, x_ax="")
# average across ROIs (bottom subplot)
av_tr = np.asarray(trace_info["all_tr"][i])
subtitle = u"{} across ROIs".format(statstr_pr)
plot_util.plot_traces(
sub_axs[1], xran, av_tr[0], av_tr[1:], lw=0.2, xticks="auto",
title=subtitle
)
else:
xran = range(len(trace_info["all_tr"][i]))
run_tr = np.asarray(trace_info["all_tr"][i])
sub_axs[0].plot(run_tr, lw=0.2)
for b, block in enumerate(trace_info["all_edges"][i]):
# all block labels to the lower plot
plot_util.add_labels(
sub_axs[-1], trace_info["all_pars"][i][b], np.mean(block),
label_height, color="k")
sess_plot_util.add_axislabels(
sub_axs[-1], fluor=analyspar["fluor"], datatype=datatype,
x_ax="")
plot_util.remove_ticks(sub_axs[-1], True, False)
plot_util.remove_graph_bars(sub_axs[-1], bars="horiz")
# add lines to both plots
for r in range(n_rows):
plot_util.add_bars(sub_axs[r], bars=block)
if savedir is None:
savedir = Path(
figpar["dirs"][datatype],
figpar["dirs"]["full"])
y = 1 if datatype == "run" else 0.98
fig.suptitle("Full traces across sessions", fontsize="xx-large", y=y)
savename = f"{datatype}_tr_{sessstr}{dendstr}"
fulldir = plot_util.savefig(
fig, savename, savedir, dpi=400, **figpar["save"])
return fulldir, savename
def plot_pup_diff_corr(analyspar, sesspar, stimpar, extrapar,
sess_info, corr_data, figpar=None, savedir=None):
"""
plot_pup_diff_corr(analyspar, sesspar, stimpar, extrapar,
sess_info, corr_data)
From dictionaries, plots correlation between unexpected-locked changes in
pupil diameter and running or ROI data for each session.
Required args:
- analyspar (dict) : dictionary with keys of AnalysPar namedtuple
- sesspar (dict) : dictionary with keys of SessPar namedtuple
- stimpar (dict) : dictionary with keys of StimPar namedtuple
- extrapar (dict) : dictionary containing additional analysis
parameters
["analysis"] (str): analysis type (e.g., "c")
["datatype"] (str): datatype (e.g., "run", "roi")
- sess_info (dict) : dictionary containing information from each
session
["mouse_ns"] (list) : mouse numbers
["sess_ns"] (list) : session numbers
["lines"] (list) : mouse lines
["planes"] (list) : imaging planes
["nrois"] (list) : number of ROIs in session
- corr_data (dict) : dictionary containing data to plot:
["corrs"] (list): list of correlation values between pupil and
running or ROI differences for each session
["diffs"] (list): list of differences for each session, structured
as [pupil, ROI/run] x trials x frames
Optional args:
- figpar (dict) : dictionary containing the following figure parameter
dictionaries
default: None
["init"] (dict): dictionary with figure initialization parameters
["save"] (dict): dictionary with figure saving parameters
["dirs"] (dict): dictionary with additional figure parameters
- savedir (Path): path of directory in which to save plots.
default: None
Returns:
- fulldir (Path): final path of the directory in which the figure is
saved (may differ from input savedir, if datetime
subfolder is added.)
- savename (str): name under which the figure is saved
"""
statstr_pr = sess_str_util.stat_par_str(
analyspar["stats"], analyspar["error"], "print")
stimstr_pr = sess_str_util.stim_par_str(
stimpar["stimtype"], stimpar["visflow_dir"], stimpar["visflow_size"],
stimpar["gabk"], "print")
dendstr_pr = sess_str_util.dend_par_str(
analyspar["dend"], sesspar["plane"], extrapar["datatype"], "print")
sessstr = sess_str_util.sess_par_str(
sesspar["sess_n"], stimpar["stimtype"], sesspar["plane"],
stimpar["visflow_dir"],stimpar["visflow_size"], stimpar["gabk"])
dendstr = sess_str_util.dend_par_str(
analyspar["dend"], sesspar["plane"], extrapar["datatype"])
datatype = extrapar["datatype"]
datastr = sess_str_util.datatype_par_str(datatype)
if datatype == "roi":
label_str = sess_str_util.fluor_par_str(
analyspar["fluor"], str_type="print")
full_label_str = u"{}, {} across ROIs".format(
label_str, analyspar["stats"])
elif datatype == "run":
label_str = datastr
full_label_str = datastr
lab_app = (f" ({analyspar['stats']} over "
f"{stimpar['pre']}/{stimpar['post']} sec)")
logger.info(f"Plotting pupil vs {datastr} changes.")
delta = "\u0394"
# extract some info from sess_info
keys = ["mouse_ns", "sess_ns", "lines", "planes"]
[mouse_ns, sess_ns, lines, planes] = [sess_info[key] for key in keys]
n_sess = len(mouse_ns)
nroi_strs = sess_str_util.get_nroi_strs(
sess_info, empty=(datatype!="roi"), style="comma"
)
if figpar is None:
figpar = sess_plot_util.init_figpar()
figpar = copy.deepcopy(figpar)
if figpar["save"]["use_dt"] is None:
figpar["save"]["use_dt"] = gen_util.create_time_str()
figpar["init"]["sharex"] = False
figpar["init"]["sharey"] = False
figpar["init"]["ncols"] = n_sess
fig, ax = plot_util.init_fig(2 * n_sess, **figpar["init"])
suptitle = (f"Relationship between pupil diam. and {datastr} changes, "
"locked to unexpected events")
for i, sess_diffs in enumerate(corr_data["diffs"]):
sub_axs = ax[:, i]
title = (f"Mouse {mouse_ns[i]} - {stimstr_pr}, " +
u"{}".format(statstr_pr) + f"\n(sess {sess_ns[i]}, {lines[i]} "
f"{planes[i]}{dendstr_pr}{nroi_strs[i]})")
# top plot: correlations
corr = f"Corr = {corr_data['corrs'][i]:.2f}"
sub_axs[0].plot(
sess_diffs[0], sess_diffs[1], marker=".", linestyle="None",
label=corr)
sub_axs[0].set_title(title, y=1.01)
sub_axs[0].set_xlabel(u"{} pupil diam.{}".format(delta, lab_app))
if i == 0:
sub_axs[0].set_ylabel(u"{} {}\n{}".format(
delta, full_label_str, lab_app))
sub_axs[0].legend()
# bottom plot: differences across occurrences
data_lab = u"{} {}".format(delta, label_str)
pup_lab = u"{} pupil diam.".format(delta)
cols = []
scaled = []
for d, lab in enumerate([pup_lab, data_lab]):
scaled.append(math_util.scale_data(
np.asarray(sess_diffs[d]), sc_type="min_max")[0])
art, = sub_axs[1].plot(scaled[-1], marker=".")
cols.append(sub_axs[-1].lines[-1].get_color())
if i == n_sess - 1: # only for last graph
art.set_label(lab)
sub_axs[1].legend()
sub_axs[1].set_xlabel("Unexpected event occurrence")
if i == 0:
sub_axs[1].set_ylabel(
u"{} response locked\nto unexpected onset (scaled)".format(delta))
# shade area between lines
plot_util.plot_btw_traces(
sub_axs[1], scaled[0], scaled[1], color=cols, alpha=0.4)
fig.suptitle(suptitle, fontsize="xx-large", y=1)
if savedir is None:
savedir = Path(
figpar["dirs"][datatype],
figpar["dirs"]["pupil"])
savename = f"{datatype}_diff_corr_{sessstr}{dendstr}"
fulldir = plot_util.savefig(fig, savename, savedir, **figpar["save"])
return fulldir, savename
def plot_pup_roi_stim_corr(analyspar, sesspar, stimpar, extrapar,
sess_info, corr_data, figpar=None, savedir=None):
"""
plot_pup_roi_stim_corr(analyspar, sesspar, stimpar, extrapar,
sess_info, corr_data)
From dictionaries, plots correlation between unexpected-locked changes in
pupil diameter and each ROI, for gabors versus visual flow responses for
each session.
Required args:
- analyspar (dict) : dictionary with keys of AnalysPar namedtuple
- sesspar (dict) : dictionary with keys of SessPar namedtuple
- stimpar (dict) : dictionary with keys of StimPar namedtuple
- extrapar (dict) : dictionary containing additional analysis
parameters
["analysis"] (str): analysis type (e.g., "r")
["datatype"] (str): datatype (e.g., "roi")
- sess_info (dict) : dictionary containing information from each
session
["mouse_ns"] (list) : mouse numbers
["sess_ns"] (list) : session numbers
["lines"] (list) : mouse lines
["planes"] (list) : imaging planes
["nrois"] (list) : number of ROIs in session
- corr_data (dict) : dictionary containing data to plot:
["stim_order"] (list): ordered list of stimtypes
["roi_corrs"] (list) : nested list of correlations between pupil
and ROI responses changes locked to
unexpected, structured as
session x stimtype x ROI
["corrs"] (list) : list of correlation between stimtype
correlations for each session
Optional args:
- figpar (dict) : dictionary containing the following figure parameter
dictionaries
default: None
["init"] (dict): dictionary with figure initialization parameters
["save"] (dict): dictionary with figure saving parameters
["dirs"] (dict): dictionary with additional figure parameters
- savedir (Path): path of directory in which to save plots.
default: None
Returns:
- fulldir (Path): final path of the directory in which the figure is
saved (may differ from input savedir, if datetime
subfolder is added.)
- savename (str): name under which the figure is saved
"""
stimstr_prs = []
for stimtype in corr_data["stim_order"]:
stimstr_pr = sess_str_util.stim_par_str(
stimtype, stimpar["visflow_dir"], stimpar["visflow_size"],
stimpar["gabk"], "print")
stimstr_pr = stimstr_pr[:-1] if stimstr_pr[-1] == "s" else stimstr_pr
stimstr_prs.append(stimstr_pr)
dendstr_pr = sess_str_util.dend_par_str(
analyspar["dend"], sesspar["plane"], extrapar["datatype"], "print")
sessstr = f"sess{sesspar['sess_n']}_{sesspar['plane']}"
dendstr = sess_str_util.dend_par_str(
analyspar["dend"], sesspar["plane"], extrapar["datatype"])
label_str = sess_str_util.fluor_par_str(
analyspar["fluor"], str_type="print")
lab_app = (f" ({analyspar['stats']} over "
f"{stimpar['pre']}/{stimpar['post']} sec)")
logger.info("Plotting pupil-ROI difference correlations for "
"{} vs {}.".format(*corr_data["stim_order"]))
# extract some info from sess_info
keys = ["mouse_ns", "sess_ns", "lines", "planes"]
[mouse_ns, sess_ns, lines, planes] = [sess_info[key] for key in keys]
n_sess = len(mouse_ns)
nroi_strs = sess_str_util.get_nroi_strs(sess_info, style="comma")
if figpar is None:
figpar = sess_plot_util.init_figpar()
figpar = copy.deepcopy(figpar)
if figpar["save"]["use_dt"] is None:
figpar["save"]["use_dt"] = gen_util.create_time_str()
figpar["init"]["sharex"] = True
figpar["init"]["sharey"] = True
fig, ax = plot_util.init_fig(n_sess, **figpar["init"])
suptitle = (u"Relationship between pupil diam. and {} changes, locked to "
"unexpected events\n{} for each ROI ({} vs {})".format(
label_str, lab_app, *corr_data["stim_order"]))
for i, sess_roi_corrs in enumerate(corr_data["roi_corrs"]):
sub_ax = plot_util.get_subax(ax, i)
title = (f"Mouse {mouse_ns[i]} (sess {sess_ns[i]}, {lines[i]} "
f"{planes[i]}{dendstr_pr}{nroi_strs[i]})")
# top plot: correlations
corr = f"Corr = {corr_data['corrs'][i]:.2f}"
sub_ax.plot(
sess_roi_corrs[0], sess_roi_corrs[1], marker=".", linestyle="None",
label=corr)
sub_ax.set_title(title, y=1.01)
if sub_ax.is_last_row():
sub_ax.set_xlabel(f"{stimstr_prs[0].capitalize()} correlations")
if sub_ax.is_first_col():
sub_ax.set_ylabel(f"{stimstr_prs[1].capitalize()} correlations")
sub_ax.legend()
plot_util.turn_off_extra(ax, n_sess)
fig.suptitle(suptitle, fontsize="xx-large", y=1)
if savedir is None:
savedir = Path(
figpar["dirs"]["roi"],
figpar["dirs"]["pupil"])
savename = f"roi_diff_corrbyroi_{sessstr}{dendstr}"
fulldir = plot_util.savefig(fig, savename, savedir, **figpar["save"])
return fulldir, savename
def init_analysis(args):
"""
init_analysis(args)
Initializes analysis parameters based on input arguments containers.
Required args:
- args (dict):
parser argument dictionary
Returns:
- analysis_dict (dict):
dictionary of analysis parameters
["analyspar"] (AnalysPar): named tuple of analysis parameters
["sesspar"] (SessPar): named tuple with session parameters
["stimpar"] (StimPar): named tuple with stimulus parameters
["basepar"] (LatPar): named tuple with latency parameters
["idxpar"] (PermPar): named tuple with unexpected event index
parameters
["logregpar"] (LogRegPar):
named tuple with logistic regression parameters
["permpar"] (PermPar): named tuple with permutation parameters
["figpar"] (dict): dictionary containing subdictionaries
(see sess_plot_util.init_figpar), with fig_panel_analysis
added under the "fig_panel_analysis" key.
"""
args = copy.deepcopy(args)
fig_panel_analysis = paper_organization.FigurePanelAnalysis(
figure=args.figure,
panel=args.panel,
datadir=args.datadir,
mouse_df_path=args.mouse_df_path,
output=args.output,
full_power=args.full_power,
seed=args.seed,
parallel=args.parallel,
plt_bkend=args.plt_bkend,
fontdir=args.fontdir,
)
specific_params = fig_panel_analysis.specific_params
sess_n = reformat_sess_n(specific_params["sess_n"])
analysis_dict = dict()
# analysis parameters
analysis_dict["analyspar"] = sess_ntuple_util.init_analyspar(
fluor="dff", # type of fluorescence data to use (dF/F)
rem_bad=specific_params[
"rem_bad"], # whether to remove bad ROIs OR interpolate bad values in run or pupil data
stats="mean", # type of statistic to measure (mean/median)
error=specific_params["error"], # type of error to measure (std/SEM)
scale=specific_params[
"scale"], # whether to scale ROIs (robust scaling)
tracked=specific_params["tracked"], # whether to use only tracked ROIs
)
# session inclusion parameters
analysis_dict["sesspar"] = sess_ntuple_util.init_sesspar(
sess_n=sess_n, # session number(s)
plane=specific_params["plane"], # recording plane(s)
line=specific_params["line"], # mouse line(s)
pass_fail="P", # include sessions that passed QC
incl="all", # include all remaining sessions
runtype="prod", # production run data
mouse_n=specific_params["mouse_n"], # mouse numbers
)
# stimulus analysis parameters
analysis_dict["stimpar"] = sess_ntuple_util.init_stimpar(
stimtype=specific_params["stimtype"], # stimulus to analyse
visflow_dir=specific_params["visflow_dir"], # visual flow directions
visflow_size=specific_params[
"visflow_size"], # visual flow square sizes
gabfr=specific_params["gabfr"], # Gabor frame to center analyses on
gabk=specific_params["gabk"], # Gabor orientation kappas
gab_ori=specific_params["gab_ori"], # mean Gabor orientations
pre=specific_params["pre"], # number of seconds pre reference frame
post=specific_params["post"] # number of seconds post reference frame
)
# baseline parameters
analysis_dict["basepar"] = sess_ntuple_util.init_basepar(
baseline=0, # sequence baselining (None)
)
# USI analysis parameters
analysis_dict["idxpar"] = sess_ntuple_util.init_idxpar(
op="d-prime", # USI measure
feature=specific_params["idx_feature"], # how to select sequences
)
# logistic regression parameters
analysis_dict["logregpar"] = sess_ntuple_util.init_logregpar(
comp=specific_params["comp"], # classes
ctrl=True, # control for dataset size
n_epochs=1000, # number of training epochs
batchsize=200, # batch size
lr=0.0001, # learning rate
train_p=0.75, # train:test split
wd=0, # weight decay to use (None)
)
# permutation analysis parameters
analysis_dict["permpar"] = sess_ntuple_util.init_permpar(
n_perms=fig_panel_analysis.n_perms, # number of permutations to run
p_val=0.05, # significance threshold to consider
tails=specific_params["tails"], # number of tails
multcomp=False # multiple comparisons
)
# figure plotting parameters
analysis_dict["figpar"] = sess_plot_util.init_figpar(
datetime=False,
overwrite=args.overwrite,
runtype="prod",
output=args.output,
plt_bkend=args.plt_bkend,
fontdir=args.fontdir,
paper=True,
)
analysis_dict["figpar"]["fig_panel_analysis"] = fig_panel_analysis
return analysis_dict
def init_param_cont(args):
"""
init_param_cont(args)
Initializes parameter containers.
Returns args:
- in the following nametuples: analyspar, sesspar, stimpar, permpar,
basepar, idxpar, latpar
- in the following dictionary: figpar
Required args:
- args (Argument parser): parser with the following attributes:
base (float) : baseline value to use
visflow_dir (str or list): visual flow direction values to include
("right", "left", ["right", "left"])
visflow_size (int or list): visual flow size values to include
(128, 256 or [128, 256])
dend (str) : type of dendrites to use
("allen" or "dend")
error (str) : error statistic parameter
("std" or "sem")
fluor (str) : if "raw", raw ROI traces are used. If
"dff", dF/F ROI traces are used.
fontdir (str) : path to directory containing additional
fonts
gabfr (int) : gabor frame at which sequences start
(0, 1, 2, 3)
gabk (int or list) : gabor kappa values to include
(4, 16 or [4, 16])
gab_ori (int or list) : gabor orientation values to include
([0, 45, 90, 135, 180, 225])
idx_feature (str) : feature used to calculate index
("by_exp", "unexp_lock", "prog_unexp")
idx_op (str) : type of index to use
("d-prime", "rel_diff", "diff")
idx_position (int) : position to use if using a "prog" feature
to calculate index (e.g., 0)
incl (str) : sessions to include ("yes", "no", "all")
keepnans (str) : if True, ROIs with NaN/Inf values are
kept in the analyses.
lag_s (num) : lag for autocorrelation (in sec)
lat_method (str) : latency calculation method
(ratio or ttest)
lat_not_unexp_resp (bool): if False, only unexpected event
responsive ROIs are used for latency
analysis
lat_p_val_thr (float) : p-value threshold for ttest latency
method
lat_std (float) : standard deviation threshold for ratio
latency method
line (str) : "L23", "L5", "any"
min_rois (int) : min number of ROIs
n_perms (int) : nbr of permutations to run
ncols (int) : number of columns
no_datetime (bool) : if True, figures are not saved in a
subfolder named based on the date and
time.
no_scale (bool) : if True, data is not scaled
not_save_fig (bool) : if True, figures are not saved
output (str) : general directory in which to save output
overwrite (bool) : if False, overwriting existing figures
is prevented by adding suffix numbers.
pass_fail (str or list) : pass/fail values of interest ("P", "F")
p_val (float) : p-value threshold for significane tests
plane (str) : plane ("soma", "dend", "any")
plt_bkend (str) : mpl backend to use
post (num) : range of frames to include after each
reference frame (in s)
pre (num) : range of frames to include before each
reference frame (in s)
rel_std (float) : relative st. dev. threshold for ratio
latency method
runtype (str or list) : runtype ("pilot" or "prod")
sess_n (int) : session number
stats (str) : statistic parameter ("mean" or "median")
stimtype (str) : stimulus to analyse
("visflow" or "gabors")
tails (str or int) : which tail(s) to test ("hi", "lo", 2)
Returns:
- analysis_dict (dict): dictionary of analysis parameters
["analyspar"] (AnalysPar): named tuple of analysis parameters
["sesspar"] (SessPar) : named tuple of session parameters
["stimpar"] (StimPar) : named tuple of stimulus parameters
["permpar"] (PermPar) : named tuple of permutation parameters
["basepar"] (BasePar) : named tuple of baseline parameters
["idxpar"] (IdxPar) : named tuple of unexpected index parameters
["latpar"] (LatPar) : named tuple of latency parameters
["figpar"] (dict) : dictionary containing following
subdictionaries:
["init"]: dict with following inputs as attributes:
["ncols"] (int) : number of columns in the figures
["sharex"] (bool) : if True, x axis lims are shared
across subplots
["sharey"] (bool) : if True, y axis lims are shared
across subplots
["subplot_hei"] (num): height of each subplot (inches)
["subplot_wid"] (num): width of each subplot (inches)
["save"]: dict with the following inputs as attributes:
["datetime"] (bool) : if True, figures are saved in a
subfolder named based on the date and
time.
["fig_ext"] (str) : figure extension
["overwrite"] (bool): if True, existing figures can be
overwritten
["save_fig"] (bool) : if True, figures are saved
["use_dt"] (str) : datetime folder to use
["dirs"]: dict with the following attributes:
["figdir"] (str) : main folder in which to save figures
["roi"] (str) : subdirectory name for ROI analyses
["run"] (str) : subdirectory name for running analyses
["autocorr"] (str) : subdirectory name for autocorrelation
analyses
["locori"] (str) : subdirectory name for location and
orientation responses
["oridir"] (str) : subdirectory name for
orientation/direction analyses
["unexp_qu"] (str) : subdirectory name for unexpected,
quantile analyses
["tune_curv"] (str): subdirectory name for tuning curves
["grped"] (str) : subdirectory name for ROI grps data
["mags"] (str) : subdirectory name for magnitude
analyses
["mng"]: dict with the following attributes:
["plt_bkend"] (str): mpl backend to use
["linclab"] (bool) : if True, Linclab mpl defaults are used
["fontdir"] (str) : path to directory containing
additional fonts
"""
args = copy.deepcopy(args)
analysis_dict = dict()
# analysis parameters
analysis_dict["analyspar"] = sess_ntuple_util.init_analyspar(
args.fluor,
not (args.keepnans),
args.stats,
args.error,
scale=not (args.no_scale),
dend=args.dend)
# session parameters
analysis_dict["sesspar"] = sess_ntuple_util.init_sesspar(
args.sess_n, False, args.plane, args.line, args.min_rois,
args.pass_fail, args.incl, args.runtype, args.mouse_ns)
# stimulus parameters
analysis_dict["stimpar"] = sess_ntuple_util.init_stimpar(
args.stimtype, args.visflow_dir, args.visflow_size, args.gabfr,
args.gabk, args.gab_ori, args.pre, args.post)
# SPECIFIC ANALYSES
analysis_dict["permpar"] = sess_ntuple_util.init_permpar(
args.n_perms, args.p_val, args.tails, False)
analysis_dict["basepar"] = sess_ntuple_util.init_basepar(args.base)
analysis_dict["idxpar"] = sess_ntuple_util.init_idxpar(
args.idx_op, args.idx_feature, args.idx_position)
analysis_dict["latpar"] = sess_ntuple_util.init_latpar(
args.lat_method, args.lat_p_val_thr, args.lat_rel_std,
not (args.lat_not_unexp_resp))
# figure parameters
analysis_dict["figpar"] = sess_plot_util.init_figpar(
ncols=int(args.ncols),
datetime=not (args.no_datetime),
overwrite=args.overwrite,
save_fig=not (args.not_save_fig),
runtype=args.runtype,
output=args.output,
plt_bkend=args.plt_bkend,
fontdir=args.fontdir)
return analysis_dict
def init_param_cont(args):
"""
init_param_cont(args)
Initializes parameter containers.
Returns args:
- in the following nametuples: analyspar, sesspar, stimpar, autocorr,
permpar, quantpar, roigrppar, tcurvpar
- in the following dictionary: figpar
Required args:
- args (Argument parser): parser with the following attributes:
visflow_dir (str or list): visual flow direction values to include
("right", "left", ["right", "left"])
visflow_size (int or list): visual flow size values to include
(128, 256 or [128, 256])
closest (bool) : if False, only exact session number is
retained, otherwise the closest.
dend (str) : type of dendrites to use ("allen" or "dend")
error (str) : error statistic parameter ("std" or "sem")
fluor (str) : if "raw", raw ROI traces are used. If
"dff", dF/F ROI traces are used.
fontdir (str) : path to directory containing additional
fonts
gabfr (int) : gabor frame at which sequences start
(0, 1, 2, 3)
gabk (int or list) : gabor kappa values to include
(4, 16 or [4, 16])
gab_ori (int or list) : gabor orientation values to include
([0, 45, 90, 135, 180, 225])
grps (str or list) : set or sets of groups to return,
("all", "change", "no_change", "reduc",
"incr".)
incl (str) : sessions to include ("yes", "no", "all")
keepnans (str) : if True, ROIs with NaN/Inf values are
kept in the analyses.
lag_s (num) : lag for autocorrelation (in sec)
line (str) : "L23", "L5", "any"
min_rois (int) : min number of ROIs
n_perms (int) : nbr of permutations to run
n_quants (int) : number of quantiles
ncols (int) : number of columns
no_add_exp (bool) : if True, the group of ROIs showing no
significance in either is not added to
the groups returned
no_datetime (bool) : if True, figures are not saved in a
subfolder named based on the date and time.
not_byitem (bool) : if True, autocorrelation statistics are
taken across items (e.g., ROIs)
not_save_fig (bool) : if True, figures are not saved
op (str) : operation on values, if plotvals if "both"
("ratio" or "diff")
output (str) : general directory in which to save output
overwrite (bool) : if False, overwriting existing figures
is prevented by adding suffix numbers.
pass_fail (str or list): pass/fail values of interest ("P", "F")
plot_vals (str) : values to plot ("unexp", "exp", "both")
plane (str) : plane ("soma", "dend", "any")
plt_bkend (str) : mpl backend to use
post (num) : range of frames to include after each
reference frame (in s)
pre (num) : range of frames to include before each
reference frame (in s)
runtype (str or list) : runtype ("pilot" or "prod")
scale (bool) : whether to scale ROI data
sess_n (int) : session number
stats (str) : statistic parameter ("mean" or "median")
stimtype (str) : stimulus to analyse ("visflow" or "gabors")
tails (str or int) : which tail(s) to test ("hi", "lo", 2)
tc_gabfr (int or str) : gabor frame at which sequences start
(0, 1, 2, 3) for tuning curve analysis
(x_x, interpreted as 2 gabfrs)
tc_grp2 (str) : second group: either unexp, exp or rand
(random subsample of exp, the size of
unexp)
tc_post (num) : range of frames to include after each
reference frame (in s) for tuning curve
analysis
tc_vm_estim (bool) : runs analysis using von Mises parameter
estimation method
tc_test (bool) : if True, tuning curve analysis is run on a
small subset of ROIs and gabors
Returns:
- analysis_dict (dict): dictionary of analysis parameters
["analyspar"] (AnalysPar) : named tuple of analysis parameters
["sesspar"] (SessPar) : named tuple of session parameters
["stimpar"] (StimPar) : named tuple of stimulus parameters
["autocorrpar"] (AutocorrPar): named tuple of autocorrelation
parameters
["permpar"] (PermPar) : named tuple of permutation parameters
["quantpar"] (QuantPar) : named tuple of quantile parameters
["roigrppar"] (RoiGrpPar) : named tuple of roi grp parameters
["tcurvpar"] (TCurvPar) : named tuple of tuning curve
parameters
["figpar"] (dict) : dictionary containing following
subdictionaries:
["init"]: dict with following inputs as attributes:
["ncols"] (int) : number of columns in the figures
["sharex"] (bool) : if True, x axis lims are shared
across subplots
["sharey"] (bool) : if True, y axis lims are shared
across subplots
["subplot_hei"] (num): height of each subplot (inches)
["subplot_wid"] (num): width of each subplot (inches)
["save"]: dict with the following inputs as attributes:
["datetime"] (bool) : if True, figures are saved in a
subfolder named based on the date and
time.
["fig_ext"] (str) : figure extension
["overwrite"] (bool): if True, existing figures can be
overwritten
["save_fig"] (bool) : if True, figures are saved
["use_dt"] (str) : datetime folder to use
["dirs"]: dict with the following attributes:
["figdir"] (str) : main folder in which to save figures
["roi"] (str) : subdirectory name for ROI analyses
["run"] (str) : subdirectory name for running analyses
["autocorr"] (str) : subdirectory name for autocorrelation
analyses
["locori"] (str) : subdirectory name for location and
orientation responses
["oridir"] (str) : subdirectory name for
orientation/direction analyses
["unexp_qu"] (str) : subdirectory name for unexpected,
quantile analyses
["tune_curv"] (str): subdirectory name for tuning curves
["grped"] (str) : subdirectory name for ROI grps data
["mags"] (str) : subdirectory name for magnitude
analyses
["mng"]: dict with the following attributes:
["plt_bkend"] (str): mpl backend to use
["linclab"] (bool) : if True, Linclab mpl defaults are used
["fontdir"] (str) : path to directory containing
additional fonts
"""
args = copy.deepcopy(args)
analysis_dict = dict()
# analysis parameters
analysis_dict["analyspar"] = sess_ntuple_util.init_analyspar(
args.fluor, not(args.keepnans), args.stats, args.error, args.scale,
dend=args.dend)
# session parameters
analysis_dict["sesspar"] = sess_ntuple_util.init_sesspar(
args.sess_n, args.closest, args.plane, args.line, args.min_rois,
args.pass_fail, args.incl, args.runtype)
# stimulus parameters
analysis_dict["stimpar"] = sess_ntuple_util.init_stimpar(
args.stimtype, args.visflow_dir, args.visflow_size, args.gabfr, args.gabk,
args.gab_ori, args.pre, args.post)
# SPECIFIC ANALYSES
# autocorrelation parameters
analysis_dict["autocorrpar"] = sess_ntuple_util.init_autocorrpar(
args.lag_s, not(args.not_byitem))
# permutation parameters
analysis_dict["permpar"] = sess_ntuple_util.init_permpar(
args.n_perms, 0.05, args.tails)
# quantile parameters
analysis_dict["quantpar"] = sess_ntuple_util.init_quantpar(
args.n_quants, [0, -1])
# roi grp parameters
analysis_dict["roigrppar"] = sess_ntuple_util.init_roigrppar(
args.grps, not(args.no_add_exp), args.op, args.plot_vals)
# tuning curve parameters
analysis_dict["tcurvpar"] = sess_ntuple_util.init_tcurvpar(
args.tc_gabfr, 0, args.tc_post, args.tc_grp2, args.tc_test,
args.tc_vm_estim)
# figure parameters
analysis_dict["figpar"] = sess_plot_util.init_figpar(
ncols=int(args.ncols), datetime=not(args.no_datetime),
overwrite=args.overwrite, save_fig=not(args.not_save_fig),
runtype=args.runtype, output=args.output, plt_bkend=args.plt_bkend,
fontdir=args.fontdir)
return analysis_dict
def init_param_cont(args):
"""
init_param_cont(args)
Returns args:
- in the following nametuples: analyspar, sesspar, stimpar, autocorr,
permpar
- in the following dictionary: figpar
Required args:
- args (Argument parser): parser with the following attributes:
visflow_dir (str or list): visual flow direction values to include
("right", "left", ["right", "left"])
visflow_size (int or list): visual flow square size values to include
(128, 256 or [128, 256])
dend (str) : type of dendrites to use ("allen" or "dend")
error (str) : error statistic parameter ("std" or "sem")
fontdir (str) : path to directory containing additional
fonts
fluor (str) : if "raw", raw ROI traces are used. If
"dff", dF/F ROI traces are used.
gabfr (int) : gabor frame at which sequences start
(0, 1, 2, 3)
gabk (int or list) : gabor kappa values to include
(4, 16 or [4, 16])
gab_ori (int or list) : gabor orientation values to include
([0, 45, 90, 135, 180, 225])
incl (str) :
lag_s (num) : lag for autocorrelation (in sec)
line (str) : line ("L23", "L5", "any")
min_rois (int) : min number of ROIs
ncols (int) : number of columns
no_datetime (bool) : if True, figures are not saved in a
subfolder named based on the date and time.
not_save_fig (bool) : if True, figures are not saved
output (str) : general directory in which to save output
overwrite (bool) : if False, overwriting existing figures
is prevented by adding suffix numbers.
pass_fail (str or list): pass/fail values of interest ("P", "F")
plane (str) : plane ("soma", "dend", "any")
plt_bkend (str) : mpl backend to use
post (num) : range of frames to include after each
reference frame (in s)
pre (num) : range of frames to include before each
reference frame (in s)
runtype (str or list) : runtype ("pilot" or "prod")
sess_n (int) : session number
stats (str) : statistic parameter ("mean" or "median")
Returns:
- analysis_dict (dict): dictionary of analysis parameters
["analyspar"] (AnalysPar): named tuple of analysis parameters
["sesspar"] (SessPar) : named tuple of session parameters
["stimpar"] (StimPar) : named tuple of stimulus parameters
["glmpar"] (GLMPar) : named tuple of GLM parameters
["figpar"] (dict) : dictionary containing following
subdictionaries:
["init"]: dict with following inputs as attributes:
["ncols"] (int) : number of columns in the figures
["sharex"] (bool) : if True, x axis lims are shared
across subplots
["sharey"] (bool) : if True, y axis lims are shared
across subplots
["subplot_hei"] (num): height of each subplot (inches)
["subplot_wid"] (num): width of each subplot (inches)
["save"]: dict with the following inputs as attributes:
["datetime"] (bool) : if True, figures are saved in a
subfolder named based on the date and
time.
["fig_ext"] (str) : figure extension
["overwrite"] (bool): if True, existing figures can be
overwritten
["save_fig"] (bool) : if True, figures are saved
["use_dt"] (str) : datetime folder to use
["dirs"]: dict with the following attributes:
["figdir"] (str) : main folder in which to save figures
["roi"] (str) : subdirectory name for ROI analyses
["run"] (str) : subdirectory name for running analyses
["autocorr"] (str) : subdirectory name for autocorrelation
analyses
["locori"] (str) : subdirectory name for location and
orientation responses
["oridir"] (str) : subdirectory name for
orientation/direction analyses
["unexp_qu"] (str) : subdirectory name for unexpected,
quantile analyses
["tune_curv"] (str): subdirectory name for tuning curves
["grped"] (str) : subdirectory name for ROI grps data
["mags"] (str) : subdirectory name for magnitude
analyses
["mng"]: dict with the following attributes:
["plt_bkend"] (str): mpl backend to use
["linclab"] (bool) : if True, Linclab mpl defaults are used
["fontdir"] (str) : path to directory containing
additional fonts
"""
args = copy.deepcopy(args)
analysis_dict = dict()
# analysis parameters
analysis_dict["analyspar"] = sess_ntuple_util.init_analyspar(
args.fluor, True, args.stats, args.error, dend=args.dend)
# session parameters
analysis_dict["sesspar"] = sess_ntuple_util.init_sesspar(args.sess_n,
False,
args.plane,
args.line,
args.min_rois,
args.pass_fail,
args.incl,
args.runtype,
mouse_n=1)
# stimulus parameters
analysis_dict["stimpar"] = sess_ntuple_util.init_stimpar(
args.stimtype, args.visflow_dir, args.visflow_size, args.gabfr,
args.gabk, args.gab_ori, args.pre, args.post)
# SPECIFIC ANALYSES
# autocorrelation parameters
analysis_dict["glmpar"] = sess_ntuple_util.init_glmpar(
args.each_roi, args.k, args.test)
# figure parameters
analysis_dict["figpar"] = sess_plot_util.init_figpar(
ncols=int(args.ncols),
datetime=not (args.no_datetime),
overwrite=args.overwrite,
save_fig=not (args.not_save_fig),
runtype=args.runtype,
output=args.output,
plt_bkend=args.plt_bkend,
fontdir=args.fontdir)
return analysis_dict
