ppc = stim_all[session][1]
for unit in m2:
firing_rate = unit.mean()
firing_rate = firing_rate.iloc[0: 1000]
baseline = firing_rate.iloc[-500: -100]
firing_rate = firing_rate - baseline
if firing_rate.max() < abs(firing_rate.min()):
np.where(firing_rate == firing_rate.min())
else:
np.where(firing_rate == firing_rate.max())
fig = spike_rate.per_unit_spike_rate(stim_all[session][rec_num], ci=ci)
name = exp[session].name
plt.suptitle(f'Session {name} - per-unit across-trials firing rate (aligned to all visual stimulations)')
utils.save(fig_dir / f'unit_spike_rate_all_visual_stim_{duration}s_{area}_{name}')
#fig = spike_rate.per_unit_spike_rate(stim_short[session][rec_num], ci=ci)
#name = exp[session].name
#plt.suptitle(f'Session {name} - per-unit across-trials firing rate (aligned to short visual stimulations)')
#utils.save(fig_dir / f'unit_spike_rate_short_visual_stim_{duration}s_{area}_{name}')
#fig = spike_rate.per_unit_spike_rate(stim_long[session][rec_num], ci=ci)
#name = exp[session].name
#plt.suptitle(f'Session {name} - per-unit across-trials firing rate (aligned to long visual stimulations)')
#utils.save(fig_dir / f'unit_spike_rate_long_visual_stim_{duration}s_{area}_{name}')
#fig = spike_rate.per_unit_spike_rate(stim_left[session][rec_num], ci=ci)
#name = exp[session].name
#plt.suptitle(f'Session {name} - per-unit across-trials firing rate (aligned to visual stimulations on the left)')
#utils.save(fig_dir / f'unit_spike_rate_left_viusal_stim_{duration}s_{area}_{name}')
#('none', len(non_responsives) / num_units),
]
for_df = []
for response, proportion in summary:
for_df.append({
'Session': session,
'Response': response,
'Proportion': proportion,
})
data[cell_type] = data[cell_type].append(pd.DataFrame(for_df))
fig, axes = plt.subplots(2, 1, sharex=True)
sns.barplot(x="Session",
y="Proportion",
hue="Response",
data=data[0],
ax=axes[0])
axes[0].set_title('Median spike width < 0.4 ms')
sns.barplot(x="Session",
y="Proportion",
hue="Response",
data=data[1],
ax=axes[1])
axes[1].set_title('Median spike width >= 0.4 ms')
plt.suptitle("Cued vs stim modulated populations as proportion of cue-active")
utils.save(fig_dir / f'cued_vs_stim_resp_pops_proportions.png')
linewidth=2.5,
color=".25",
)
biases = {
"No bias": counts_no_bias,
"Push": counts_push_bias,
"Pull": counts_pull_bias,
"Both": counts_bimodal,
"Opposite": counts_opposite,
}
bias_df = pd.DataFrame(biases).melt(value_name="Proportion", var_name="Group")
sns.boxplot(
data=bias_df,
x="Group",
y="Proportion",
ax=axes[1],
linewidth=2.5,
)
sns.swarmplot(
data=bias_df,
x="Group",
y="Proportion",
ax=axes[1],
linewidth=2.5,
color=".25",
)
axes[0].set_ylim([0, 1])
utils.save(fig_dir / "resp_groups.pdf")
"C57_1319782",
"C57_1319785",
]
exp = Experiment(
mice,
PushPull,
'~/duguidlab/Direction_Sensitivity/Data/Neuropixel',
#'~/duguidlab/CuedBehaviourAnalysis/Data/TrainingJSON',
)
sns.set(font_scale=0.4)
fig_dir = Path('~/duguidlab/visuomotor_control/figures/DS')
# all clusters
fig = clusters.depth_profile(exp, curated=False)
plt.ylim([2000, -250])
plt.suptitle('Cluster depth profile uncurated')
utils.save(fig_dir / f'cluster_depth_profile_uncurated')
#fig = clusters.depth_profile(exp, curated=True)
#plt.ylim([-250, 2000])
#plt.suptitle('Cluster depth profile curated')
#utils.save(fig_dir / f'cluster_depth_profile_curated')
# post-curation good units in the brain
#fig = clusters.depth_profile(exp, curated=True, group='good')
#plt.suptitle('Cluster depth profile good units in brain')
#plt.ylim([2000, 0])
#utils.save(fig_dir / f'cluster_depth_profile_neurons')
exp.set_cache(False)
sns.set(font_scale=0.4)
fig_dir = Path('~/duguidlab/visuomotor_control/figures')
exp.process_behaviour()
hits = exp.align_trials(
ActionLabels.rewarded_push,
Events.back_sensor_open,
'behavioural',
duration=duration,
)
fig, axes = plt.subplots(5, 1, sharex=True)
channels = hits.columns.get_level_values('unit').unique()
for i, session in enumerate(exp):
for c in range(5):
chan_name = channels[c]
sns.lineplot(
data=hits[i][rec_num][chan_name][trial],
estimator=None,
style=None,
ax=axes[c]
)
ax.set_title(chan_name)
name = session.name
utils.save(fig_dir / f'behaviour_alignment_{name}_trial{trial}_{duration}s')
centre = 1.333333
istep = p_means.index[1] - p_means.index[0]
p_roll = ((centre - p_means.loc[1:1.53].idxmin()) / istep).round()
i_roll = ((centre - i_means.loc[1:1.53].idxmin()) / istep).round()
for i in p_means:
p_means[i] = np.roll(p_means[i].values, int(p_roll[i]))
for i in i_means:
i_means[i] = np.roll(i_means[i].values, int(i_roll[i]))
left_clip = int(max(p_roll.max(), i_roll.max()))
right_clip = int(min(p_roll.min(), i_roll.min()))
p_means = p_means.iloc[left_clip:right_clip]
i_means = i_means.iloc[left_clip:right_clip]
plt.plot(p_means, color='green', alpha=0.5, lw=1)
plt.plot(i_means, color='orange', alpha=0.5, lw=1)
utils.save(fig_dir / 'cell_type_waveforms')
if by_ses:
for session in range(len(exp)):
name = exp[session].name
if pyramidals_units[session][0]:
clusters.session_waveforms(pyramidals[session][rec_num])
plt.suptitle(f'Session {name} - pyramidal cell waveforms')
utils.save(fig_dir / f'pyramidal_cell_waveforms_{name}')
else:
print("No pyramidals for session", name)
if interneuron_units[session][0]:
clusters.session_waveforms(interneurons[session][rec_num])
plt.suptitle(f'Session {name} - interneuron cell waveforms')
)
pulls = exp.align_trials(
ActionLabels.rewarded_pull_good_mi,
Events.motion_index_onset,
'spike_rate',
duration=duration,
units=units,
)
# Only one recording
rec_num = 0
# I wanted to really check that the same units list is seen in all variables
all_unit_ids = [u for s in units for r in s for u in r]
ps_units = pushes.columns.get_level_values('unit').unique().values.copy()
pl_units = pulls.columns.get_level_values('unit').unique().values.copy()
ps_units.sort()
pl_units.sort()
assert all(ps_units == np.unique(all_unit_ids))
assert all(pl_units == np.unique(all_unit_ids))
# Plot
for i, session in enumerate(exp):
name = session.name
subplots = spike_rate.per_unit_spike_rate(pushes[i][rec_num], ci='sd')
spike_rate.per_unit_spike_rate(pulls[i][rec_num], ci='sd', subplots=subplots)
plt.suptitle(f'Pushes + pulls - per-unit firing rate (aligned to MI onset)')
utils.save(fig_dir / f'pushpulls_unit_spike_rate_{duration}s_{name}.pdf')
stim_times[ses][rec_num].columns.get_level_values('trial').unique())
spike_times.single_unit_raster(hit_times[ses][rec_num][unit],
ax=ax,
sample=num_stim)
spike_times.single_unit_raster(stim_times[ses][rec_num][unit],
ax=ax,
start=num_stim)
ax.set_axis_off()
ax.xaxis.set_label_text("")
ax.yaxis.set_label_text("")
ax = axes[axbase + 1][i % 4]
spike_rate.single_unit_spike_rate(hits[ses][rec_num][unit], ax=ax)
spike_rate.single_unit_spike_rate(stim[ses][rec_num][unit], ax=ax)
ax.spines['right'].set_visible(False)
ax.spines['top'].set_visible(False)
ax.set_xticks([-2, 0, 2])
ax.xaxis.set_label_text("")
ax.yaxis.set_label_text("")
bottom, top = ax.get_ylim()
d = top / 5
bottom -= d
top += d
ax.set_ylim(bottom, top)
if i == 3:
axbase = 2
utils.save(out)
for mouse in mouse_ids:
mouse_results = results[results['mouse_id'] == mouse]
max_reward = mouse_results['correct'].max()
best_day = mouse_results[mouse_results['correct'] == max_reward]
incorrects.append(best_day['incorrect'].values[0])
max_rewards.append(max_reward)
best_days.append(best_day['day'].values[0])
# Get trial data from best days
trials = pd.DataFrame(cohort.get_trials())
trials["grasp_latency"] = trials.end - trials.start
latencies = []
for i, mouse in enumerate(mouse_ids):
mouse_trials = trials[trials['mouse_id'] == mouse]
day_trials = mouse_trials[mouse_trials['day'] == best_days[i]]
corrects = day_trials[day_trials['outcome'] == Outcomes.CORRECT]
latencies.append(corrects["grasp_latency"])
all_latencies = pd.concat(latencies, axis=1, keys=mouse_ids)
_, axes = plt.subplots(2, 2)
sns.histplot(data=all_latencies, ax=axes[0][0])
sns.boxplot(data=all_latencies, ax=axes[0][1])
sns.violinplot(data=all_latencies, ax=axes[1][0])
sns.stripplot(data=all_latencies, ax=axes[1][1])
utils.save(
"~/duguidlab/visuomotor_control/figures/srf_grant/reach_behaviour_grasp_latency.pdf"
)
sample=num_stim,
label=False)
spike_times.per_unit_raster(stim[session][rec_num][resps],
start=num_stim,
subplots=subplots)
subplots.to_label.set_xticks([-2000, 0, 2000])
subplots.to_label.set_xticklabels([-2, 0, 2])
subplots.legend.text(
0,
0.6,
'cued pushes',
transform=subplots.legend.transAxes,
color=palette[0],
)
subplots.legend.text(
0,
0.3,
'opto-stim pushes',
transform=subplots.legend.transAxes,
color=palette[1],
)
name = exp[session].name
plt.suptitle(
f'Session {name} - pyramidal - per-unit spike times (aligned to push)')
utils.save(
fig_dir /
f'unit_raster_responsive_PC_cued+stim_push_{duration}s_{name}.png')
print(name, resps)
break
elif ci_bin[97.5] < 0:
count_resp += 1
break
if as_proportions:
data.append((count_resp / count, area, name))
else:
data.append((count_resp, area, name))
if as_proportions:
df = pd.DataFrame(
data, columns=["Proportion of Neurons", "Brain Area", "Session"])
sns.boxplot(data=df, x="Brain Area", y="Proportion of Neurons")
sns.stripplot(data=df,
x="Brain Area",
y="Proportion of Neurons",
color=".25",
jitter=0)
utils.save(fig_dir / f'Proportion_of_Neurons')
else:
df = pd.DataFrame(data,
columns=["Number of Neurons", "Brain Area", "Session"])
sns.pointplot(data=df,
x="Session",
hue="Brain Area",
y="Number of Neurons",
dodge=True)
utils.save(fig_dir / f'Number_of_Neurons')
pooled.append(values)
else:
axes[-1].hist(
widths[session]['median_ms'].values,
bins=np.arange(0, 1.1, 0.05),
alpha=0.6,
)
if pool:
axes[-1].hist(
np.concatenate(pooled),
bins=np.arange(0, 1.1, 0.05),
alpha=0.6,
)
axes[-1].set_title(f"All sessions")
axes[-1].set_ylabel("Count")
axes[-1].axvline(x=0.4, c='red')
axes[-1].set_xlabel("Median spike width (ms)")
axes[-1].text(
0.95, 0.15,
f"Total: {sum(counts)}",
horizontalalignment='right',
verticalalignment='top',
transform=axes[-1].transAxes,
color='0.3',
)
plt.suptitle('Median spike widths - good units in deep layers')
utils.save(fig_dir / 'median_spike_widths_good_deep_units')
sns.set(font_scale=0.4)
fig_dir = Path('~/duguidlab/visuomotor_control/figures')
duration = 2
_, axes = plt.subplots(len(exp), 1)
hits = exp.align_trials(
ActionLabels.cued_shutter_push_full,
Events.back_sensor_open,
'spike_rate',
duration=duration,
min_depth=500,
max_depth=1200,
)
for session in range(len(exp)):
name = exp[session].name
data = hits[session].stack()
norm = StandardScaler().fit(data).transform(data)
num_components = norm.shape[1]
pca = PCA(n_components=num_components)
# probably don't need to transform
pc = pca.fit(norm).transform(norm)
axes[session].plot(np.cumsum(pca.explained_variance_ratio_))
axes[session].plot([0, num_components], [0, 1], '--', linewidth=0.4)
plt.xlabel('Components')
plt.ylabel('Cumulative explained variance')
utils.save(fig_dir / f"scree_plot_good_deep_units_{duration}s.png")
for unit in cell_type[session][rec_num]:
depth = info.loc[info["id"] == unit]["real_depth"].values[0]
if unit in both_resps:
group = "both"
elif unit in push_resps:
group = "push"
elif unit in pull_resps:
group = "pull"
else:
group = "none"
data.append((unit, depth, group, cell_type_names[c]))
df = pd.DataFrame(data, columns=["ID", "depth", "group", "cell type"])
sns.stripplot(
x="group",
order=["none", "push", "pull", "both"],
y="depth",
hue="cell type",
data=df,
ax=axes[session],
)
axes[session].set_ylim(980, 520)
if session > 0:
axes[session].get_legend().remove()
print(exp[session].name, len(non_resps), len(push_resps), len(pull_resps),
len(both_resps))
plt.gcf().set_size_inches(8, 5)
utils.save(fig_dir / f'push_pull_responsives_by_depth.pdf', nosize=True)
ax2.set_ylim([0, 1])
# Look in -300ms to +1000ms response window
if np.any(unit_acc[17:30] > unit_thresh[17:30]):
sigs.append(unit)
ax.autoscale(enable=True, tight=True)
ax.get_xaxis().get_label().set_visible(False)
ax.get_yaxis().get_label().set_visible(False)
ax2.get_xaxis().get_label().set_visible(False)
ax2.get_yaxis().get_label().set_visible(False)
for spine in ax.spines.values():
spine.set_linewidth(0.2)
spine.set_color('gray')
for spine in ax2.spines.values():
spine.set_linewidth(0.2)
spine.set_color('gray')
ax.tick_params(left=False, labelleft=True, labelbottom=False)
ax2.tick_params(right=False, labelright=False, labelbottom=False)
r = len(sigs)
a = len(units)
p = round(100 * r / a, 1)
percs.append(p)
print(f"{r} / {a} units ({p}%)")
plt.suptitle(
f'Push + pull firing rate + coding accuracy per (aligned to MI onset)')
utils.save(fig_dir / f"firing_rate+unit_coding_accuracies_{session.name}")
print(percs)
resps = [pushes[session][rec_num][unit], pulls[session][rec_num][unit]]
for action, t in enumerate(resps):
for b in range(4):
if 0 < t[b][2.5]:
pos[action].append(unit)
resp = True
break
elif t[b][97.5] < 0:
neg[action].append(unit)
resp = True
break
if not resp:
non_resps.add(unit)
push_resps = set(pos[0] + neg[0])
pull_resps = set(pos[1] + neg[1])
venn2(
[push_resps, pull_resps],
("Pushes", "Pulls"),
ax=axes[session]
)
axes[session].set_title(exp[session].name)
axes[session].text(0.05, 0.95, len(non_resps))
utils.save(fig_dir / f'push_pull_responsive_sizes.pdf')
stim_responsives = set()
stim_miss_responsives = set()
non_responsives = set()
for unit in cue_resp.index.get_level_values('unit').unique():
resp = False
if responsiveness.significant_CI(cue_resp[unit]):
resp = True
cue_responsives.add(unit)
if responsiveness.significant_CI(stim_resp[unit]):
resp = True
stim_responsives.add(unit)
if responsiveness.significant_CI(stim_miss_resp[unit]):
resp = True
stim_miss_responsives.add(unit)
if not resp:
non_responsives.add(unit)
venn3([cue_responsives, stim_responsives, stim_miss_responsives],
("Cued pushes", "Stim pushes", "Stim misses"),
ax=axes[session][depth])
axes[session][depth].set_title(
f"{exp[session].name} - {depths[depth]}")
plt.text(0.05,
0.95,
len(non_responsives),
transform=axes[session][depth].transAxes)
utils.save(fig_dir /
f'Cued vs stim push vs stim miss resp pops, different depths.png')
)
pulls = exp.align_trials(
ActionLabels.rewarded_pull,
Events.front_sensor_open,
'spike_rate',
duration=duration,
uncurated=True,
)
for session in range(len(exp)):
# per unit
fig = spike_rate.per_unit_spike_rate(pushes[session][rec_num], ci='sd')
name = exp[session].name
plt.suptitle(f'Session {name} - per-unit across-trials firing rate (aligned to cued push)')
utils.save(fig_dir / f'unit_spike_rate_cued_push_{duration}s_{name}_sd')
fig = spike_rate.per_unit_spike_rate(pulls[session][rec_num], ci='sd')
name = exp[session].name
plt.suptitle(f'Session {name} - per-unit across-trials firing rate (aligned to cued pull)')
utils.save(fig_dir / f'unit_spike_rate_cued_pull_{duration}s_{name}_sd')
# per trial
fig = spike_rate.per_trial_spike_rate(pushes[session][rec_num], ci='sd')
name = exp[session].name
plt.suptitle(f'Session {name} - per-trial across-units firing rate (aligned to cued push)')
utils.save(fig_dir / f'trial_spike_rate_cued_push_{duration}s_{name}_sd')
fig = spike_rate.per_trial_spike_rate(pulls[session][rec_num], ci='sd')
name = exp[session].name
plt.suptitle(f'Session {name} - per-trial across-units firing rate (aligned to cued pull)')
# fig = spike_times.per_unit_histogram(stim, session, bin_ms=bin_ms, duration=duration)
# name = exp[session].name
# plt.suptitle(f'Session {name} - per-unit across-trials spike times (aligned to stim push)')
# save(f'unit_spike_histograms_stim_{duration}s_{name}_in_brain.png')
#
#for session in range(len(exp)):
# fig = spike_times.per_trial_histogram(stim, session, bin_ms=bin_ms, duration=duration)
# name = exp[session].name
# plt.suptitle(f'Session {name} - per-trial across-unit spike times (aligned to stim push)')
# save(f'trial_spike_histograms_stim_{duration}s_{name}_in_brain.png')
stim_miss = exp.align_trials(
ActionLabels.uncued_laser_nopush,
Events.laser_onset,
'spike_times',
duration=duration,
)
for session in range(len(exp)):
fig = spike_times.per_unit_histogram(stim_miss, session, bin_ms=bin_ms, duration=duration)
name = exp[session].name
plt.suptitle(f'Session {name} - per-unit across-trials spike times (aligned to nopush stim)')
utils.save(fig_dir / f'unit_spike_histograms_stim-miss_{duration}s_{name}_in_brain')
for session in range(len(exp)):
fig = spike_times.per_trial_histogram(stim_miss, session, bin_ms=bin_ms, duration=duration)
name = exp[session].name
plt.suptitle(f'Session {name} - per-trial across-unit spike times (aligned to nopush stim)')
utils.save(fig_dir / f'trial_spike_histograms_stim-miss_{duration}s_{name}_in_brain')
]
exp = Experiment(
mice,
PushPull,
'~/duguidlab/Direction_Sensitivity/Data/Neuropixel',
)
hits = exp.align_trials(
ActionLabels.rewarded_push,
Events.back_sensor_open,
'motion_index',
duration=duration,
)
for i, session in enumerate(exp):
fig, axes = plt.subplots(10, 1, sharex=True)
for t in range(10):
sns.lineplot(
data=hits[i][rec_num][0][t],
estimator=None,
style=None,
ax=axes[t]
)
axes[t].set_title(f"Trial {t}")
name = session.name
utils.save(fig_dir / f'motion_index_aligned_to_tone_{name}_{duration}s')
alpha=0.8,
linewidth=0.8,
fmt='.',
)
axes[0][session].set_xlim(-10, 50)
axes[0][session].set_ylim(-10, 50)
axes[0][session].set_aspect('equal')
results[exp[session].name] = as_df
num_resp = len(pos) + len(neg)
weights.extend([1/num_resp] * num_resp)
all_results = pd.concat(results)
all_results.reset_index(level=0, inplace=True)
#sns.scatterplot(
# data=all_results,
# x='Cued',
# y='Stim',
# hue='level_0',
# ax=axes[1][0],
# legend=None,
#)
axes[1][0].set_aspect('equal')
axes[1][0].set_xlim(-10, 50)
axes[1][0].set_ylim(-10, 50)
plt.suptitle('Cued vs stim push median dHz')
for ax in axes[1][1:]:
ax.set_visible(False)
utils.save(fig_dir / f'cued_vs_stim_push_median_dHz')
else:
group = "none"
data.append((unit, depth, group, cell_type_names[c]))
labels = [
"none", "push_only", "pull_only", "push_bias", "pull_bias", "no_bias",
"both_bias"
]
df = pd.DataFrame(data, columns=["ID", "depth", "group", "cell type"])
sns.stripplot(
x="group",
order=labels,
y="depth",
hue="cell type",
data=df,
ax=axes[session],
)
axes[session].set_ylim(980, 520)
if session > 0:
axes[session].get_legend().remove()
axes[session].set_xticklabels(labels, rotation=45)
print(exp[session].name, len(non_resps), " ", len(push_only), " ",
len(pull_only), " ", len(push_bias), " ", len(pull_bias),
" ", len(no_bias), " ", len(both_bias))
plt.gcf().set_size_inches(8, 5)
utils.save(fig_dir / f'push_pull_responsives_by_depth_and_bias_{step}.pdf',
nosize=True)
sns.set(font_scale=0.4)
fig_dir = Path('~/duguidlab/visuomotor_control/figures/srf_grant')
if rates_not_rasters:
firing_rates = exp.align_trials(
ActionLabels.rewarded_push,
Events.back_sensor_open,
'spike_rate',
duration=duration,
)
# IPN
ses = exp[ses_ipn_gpi].name
spike_rate.per_unit_spike_rate(firing_rates[ses_ipn_gpi][ipn], ci='sd')
plt.suptitle(f'IPN - per-unit across-trials firing rate (aligned to push)')
utils.save(fig_dir / f'IPN_unit_spike_rate_{duration}s_{ses}.png')
# GPi
spike_rate.per_unit_spike_rate(firing_rates[ses_ipn_gpi][gpi], ci='sd')
plt.suptitle(f'GPi - per-unit across-trials firing rate (aligned to push)')
utils.save(fig_dir / f'GPi_unit_spike_rate_{duration}s_{ses}.png')
# MTh
ses = exp[ses_m1_mth].name
spike_rate.per_unit_spike_rate(firing_rates[ses_m1_mth][mth], ci='sd')
plt.suptitle(f'Motor thalamus - per-unit across-trials firing rate (aligned to push)')
utils.save(fig_dir / f'MTh_unit_spike_rate_{duration}s_{ses}.png')
else:
times = exp.align_trials(
ActionLabels.rewarded_push,
# Plot
for session in range(len(exp)):
subplots = spike_times.per_unit_raster(pushes[session][rec_num],
label=False)
num_pushes = len(
pushes[session][rec_num].columns.get_level_values('trial').unique())
spike_times.per_unit_raster(pulls[session][rec_num],
start=num_pushes,
subplots=subplots)
subplots.to_label.set_xticks([-2000, 0, 2000])
subplots.to_label.set_xticklabels([-2, 0, 2])
subplots.legend.text(
0,
0.6,
'Pushes',
transform=subplots.legend.transAxes,
color=palette[0],
)
subplots.legend.text(
0,
0.3,
'Pulls',
transform=subplots.legend.transAxes,
color=palette[1],
)
name = exp[session].name
plt.suptitle(f'Session {name} - pyramidal - per-unit spike times')
utils.save(fig_dir / f'unit_raster_PC_{duration}s_{name}.png')
import matplotlib.pyplot as plt
import seaborn as sns
from pixels import Experiment
from pixels.behaviours.reach import VisualOnly
from pixtools import clusters, utils
mice = [
## 'HFR19',
'HFR20',
## 'HFR21',
## 'HFR22',
## 'HFR23',
]
exp = Experiment(
mice,
VisualOnly,
'~/duguidlab/visuomotor_control/neuropixels',
'~/duguidlab/CuedBehaviourAnalysis/Data/TrainingJSON',
)
sns.set(font_scale=0.4)
fig_dir = Path('~/duguidlab/visuomotor_control/AZ_notes')
fig = clusters.depth_profile(exp, curated=True, in_brain=True)
plt.ylim([1750, -250])
plt.suptitle('Cluster depth profile')
utils.save(fig_dir / f'cluster_depth_profile')
else:
stim_responsives_neg.add(unit)
#res = responsiveness.significant_CI(stim_miss_resp[unit])
#if res:
# resp = True
# if res > 0:
# stim_miss_responsives_pos.add(unit)
# else:
# stim_miss_responsives_neg.add(unit)
if not resp:
non_responsives.add(unit)
print(
f"session: {exp[session].name}, {len(cue_responsives_pos)}, {len(cue_responsives_neg)}"
)
venn2([cue_responsives_pos, stim_responsives_pos],
("Cued pushes", "Stim pushes", "Stim misses"),
ax=axes[session][0])
venn2([cue_responsives_neg, stim_responsives_neg],
("Cued pushes", "Stim pushes"),
ax=axes[session][0])
axes[session][0].set_title(f"{exp[session].name} - positive")
axes[session][1].set_title(f"{exp[session].name} - negative")
plt.text(0.05,
0.95,
len(non_responsives),
transform=axes[session][0].transAxes)
utils.save(fig_dir /
f'Cued_vs_stim_push_vs_stim_miss_resp_pops_-_directions.png')
