raab/GP2023_chirp_detection
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

new introplot

Browse Source
This commit is contained in:
weygoldt 2023-01-26 12:45:14 +01:00
parent 449bc130a0
commit b0447b8ab3
3 changed files with 328 additions and 270 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

103
code/plot_introduction_specs.py
View File

@ -17,7 +17,7 @@ def main():
data = LoadData(datapath) data = LoadData(datapath)
# good chirp times for data: 2022-06-02-10_00 # good chirp times for data: 2022-06-02-10_00
window_start_seconds = 3 * 60 * 60 + 6 * 60 + 43.5 + 9 + 6.25 window_start_seconds = 3 * 60 * 60 + 6 * 60 + 43.5 + 9 + 6.24
window_start_index = window_start_seconds * data.raw_rate window_start_index = window_start_seconds * data.raw_rate
window_duration_seconds = 0.2 window_duration_seconds = 0.2
window_duration_index = window_duration_seconds * data.raw_rate window_duration_index = window_duration_seconds * data.raw_rate
@ -27,8 +27,8 @@ def main():
raw = data.raw[window_start_index:window_start_index + raw = data.raw[window_start_index:window_start_index +
window_duration_index, 10] window_duration_index, 10]
fig, (ax1, ax2, ax3) = plt.subplots( fig, ax = plt.subplots(
3, 1, figsize=(12 * ps.cm, 10*ps.cm), sharex=True, sharey=True) 1, 1, figsize=(14 * ps.cm, 6*ps.cm), sharex=True, sharey=True)
# plot instantaneous frequency # plot instantaneous frequency
filtered1 = bandpass_filter( filtered1 = bandpass_filter(
@ -41,13 +41,14 @@ def main():
freqtime2, freq2 = instantaneous_frequency( freqtime2, freq2 = instantaneous_frequency(
filtered2, data.raw_rate, smoothing_window=3) filtered2, data.raw_rate, smoothing_window=3)
ax1.plot(freqtime1*timescaler, freq1, color=ps.red, ax.plot(freqtime1*timescaler, freq1, color=ps.gblue1,
lw=2, label=f"fish 1, {np.median(freq1):.0f} Hz") lw=2, label="fish 1")
ax1.plot(freqtime2*timescaler, freq2, color=ps.orange, ax.plot(freqtime2*timescaler, freq2, color=ps.gblue2,
lw=2, label=f"fish 2, {np.median(freq2):.0f} Hz") lw=2, label="fish 2")
ax1.legend(bbox_to_anchor=(0, 1.02, 1, 0.2), loc="lower center", ax.legend(bbox_to_anchor=(0, 1.02, 1, 0.2), loc="lower center",
mode="normal", borderaxespad=0, ncol=2) mode="normal", borderaxespad=0, ncol=2)
ps.hide_xax(ax1) # ax.legend(bbox_to_anchor=(1.04, 1), borderaxespad=0)
# # ps.hide_xax(ax1)
# plot fine spectrogram # plot fine spectrogram
spec_power, spec_freqs, spec_times = spectrogram( spec_power, spec_freqs, spec_times = spectrogram(
@ -57,11 +58,11 @@ def main():
overlap_frac=0.2, overlap_frac=0.2,
) )
ylims = [300, 1200] ylims = [300, 1300]
fmask = np.zeros(spec_freqs.shape, dtype=bool) fmask = np.zeros(spec_freqs.shape, dtype=bool)
fmask[(spec_freqs > ylims[0]) & (spec_freqs < ylims[1])] = True fmask[(spec_freqs > ylims[0]) & (spec_freqs < ylims[1])] = True
ax2.imshow( ax.imshow(
decibel(spec_power[fmask, :]), decibel(spec_power[fmask, :]),
extent=[ extent=[
spec_times[0]*timescaler, spec_times[0]*timescaler,
@ -73,45 +74,47 @@ def main():
origin="lower", origin="lower",
interpolation="gaussian", interpolation="gaussian",
alpha=1, alpha=1,
vmin=-100,
vmax=-80,
) )
ps.hide_xax(ax2) # ps.hide_xax(ax2)
# plot coarse spectrogram # # plot coarse spectrogram
spec_power, spec_freqs, spec_times = spectrogram( # spec_power, spec_freqs, spec_times = spectrogram(
raw, # raw,
ratetime=data.raw_rate, # ratetime=data.raw_rate,
freq_resolution=10, # freq_resolution=10,
overlap_frac=0.3, # overlap_frac=0.3,
) # )
fmask = np.zeros(spec_freqs.shape, dtype=bool) # fmask = np.zeros(spec_freqs.shape, dtype=bool)
fmask[(spec_freqs > ylims[0]) & (spec_freqs < ylims[1])] = True # fmask[(spec_freqs > ylims[0]) & (spec_freqs < ylims[1])] = True
ax3.imshow( # ax3.imshow(
decibel(spec_power[fmask, :]), # decibel(spec_power[fmask, :]),
extent=[ # extent=[
spec_times[0]*timescaler, # spec_times[0]*timescaler,
spec_times[-1]*timescaler, # spec_times[-1]*timescaler,
spec_freqs[fmask][0], # spec_freqs[fmask][0],
spec_freqs[fmask][-1], # spec_freqs[fmask][-1],
], # ],
aspect="auto", # aspect="auto",
origin="lower", # origin="lower",
interpolation="gaussian", # interpolation="gaussian",
alpha=1, # alpha=1,
) # )
# ps.hide_xax(ax3) # # ps.hide_xax(ax3)
ax3.set_xlabel("time [ms]") ax.set_xlabel("time [ms]")
ax2.set_ylabel("frequency [Hz]") ax.set_ylabel("frequency [Hz]")
ax1.set_yticks(np.arange(400, 1201, 400)) # ax.set_yticks(np.arange(400, 1201, 400))
ax1.spines.left.set_bounds((400, 1200)) # ax.spines.left.set_bounds((400, 1200))
ax2.set_yticks(np.arange(400, 1201, 400)) # ax2.set_yticks(np.arange(400, 1201, 400))
ax2.spines.left.set_bounds((400, 1200)) # ax2.spines.left.set_bounds((400, 1200))
ax3.set_yticks(np.arange(400, 1201, 400)) # ax3.set_yticks(np.arange(400, 1201, 400))
ax3.spines.left.set_bounds((400, 1200)) # ax3.spines.left.set_bounds((400, 1200))
plt.subplots_adjust(left=0.17, right=0.98, top=0.9, plt.subplots_adjust(left=0.17, right=0.98, top=0.87,
bottom=0.14, hspace=0.35) bottom=0.24, hspace=0.35)
plt.savefig('../poster/figs/introplot.pdf') plt.savefig('../poster/figs/introplot.pdf')
plt.show() plt.show()

495
code/plot_kdes.py
View File

@ -1,18 +1,18 @@
from extract_chirps import get_valid_datasets
import os
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from tqdm import tqdm from modules.plotstyle import PlotStyle
from IPython import embed
from pandas import read_csv
from modules.logger import makeLogger
from modules.datahandling import flatten, causal_kde1d, acausal_kde1d
from modules.behaviour_handling import ( from modules.behaviour_handling import (
Behavior, correct_chasing_events, center_chirps) Behavior, correct_chasing_events, center_chirps)
from modules.plotstyle import PlotStyle from modules.datahandling import flatten, causal_kde1d, acausal_kde1d
from modules.logger import makeLogger
from pandas import read_csv
from IPython import embed
from tqdm import tqdm
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
import os
from extract_chirps import get_valid_datasets
logger = makeLogger(__name__) logger = makeLogger(__name__)
ps = PlotStyle() ps = PlotStyle()
@ -23,16 +23,16 @@ def bootstrap(data, nresamples, kde_time, kernel_width, event_times, time_before
bootstrapped_kdes = [] bootstrapped_kdes = []
data = data[data <= 3*60*60] # only night time data = data[data <= 3*60*60] # only night time
# diff_data = np.diff(np.sort(data), prepend=0) diff_data = np.diff(np.sort(data), prepend=0)
# if len(data) != 0: # if len(data) != 0:
# mean_chirprate = (len(data) - 1) / (data[-1] - data[0]) # mean_chirprate = (len(data) - 1) / (data[-1] - data[0])
for i in tqdm(range(nresamples)): for i in tqdm(range(nresamples)):
# np.random.shuffle(diff_data) np.random.shuffle(diff_data)
# bootstrapped_data = np.cumsum(diff_data) bootstrapped_data = np.cumsum(diff_data)
bootstrapped_data = data + np.random.randn(len(data)) * 10 # bootstrapped_data = data + np.random.randn(len(data)) * 10
bootstrap_data_centered = center_chirps( bootstrap_data_centered = center_chirps(
bootstrapped_data, event_times, time_before, time_after) bootstrapped_data, event_times, time_before, time_after)
@ -40,8 +40,8 @@ def bootstrap(data, nresamples, kde_time, kernel_width, event_times, time_before
bootstrapped_kde = acausal_kde1d( bootstrapped_kde = acausal_kde1d(
bootstrap_data_centered, time=kde_time, width=kernel_width) bootstrap_data_centered, time=kde_time, width=kernel_width)
# bootstrapped_kdes = list(np.asarray( bootstrapped_kde = list(np.asarray(
# bootstrapped_kdes) / len(event_times)) bootstrapped_kde) / len(event_times))
bootstrapped_kdes.append(bootstrapped_kde) bootstrapped_kdes.append(bootstrapped_kde)
@ -58,20 +58,20 @@ def jackknife(data, nresamples, subsetsize, kde_time, kernel_width, event_times,
for i in tqdm(range(nresamples)): for i in tqdm(range(nresamples)):
bootstrapped_data = np.random.sample(data, subsetsize, replace=False) jackknifed_data = np.random.choice(data, subsetsize, replace=False)
bootstrapped_data = np.cumsum(diff_data) jackknifed_data = np.cumsum(diff_data)
bootstrap_data_centered = center_chirps( jackknifed_data_centered = center_chirps(
bootstrapped_data, event_times, time_before, time_after) jackknifed_data, event_times, time_before, time_after)
bootstrapped_kde = acausal_kde1d( jackknifed_kde = acausal_kde1d(
bootstrap_data_centered, time=kde_time, width=kernel_width) jackknifed_data_centered, time=kde_time, width=kernel_width)
# bootstrapped_kdes = list(np.asarray( jackknifed_kde = list(np.asarray(
# bootstrapped_kdes) / len(event_times)) jackknifed_kde) / len(event_times))
jackknife_kdes.append(bootstrapped_kde) jackknife_kdes.append(jackknifed_kde)
return jackknife_kdes return jackknife_kdes
@ -102,14 +102,14 @@ def get_chirp_winner_loser(folder_name, Behavior, order_meta_df):
def main(dataroot): def main(dataroot):
foldernames, _ = get_valid_datasets(dataroot) foldernames, _ = np.asarray(get_valid_datasets(dataroot))
plot_all = True plot_all = True
time_before = 60 time_before = 90
time_after = 60 time_after = 90
dt = 0.001 dt = 0.001
kernel_width = 1 kernel_width = 2
kde_time = np.arange(-time_before, time_after, dt) kde_time = np.arange(-time_before, time_after, dt)
nbootstraps = 2 nbootstraps = 50
meta_path = ( meta_path = (
'/').join(foldernames[0].split('/')[:-2]) + '/order_meta.csv' '/').join(foldernames[0].split('/')[:-2]) + '/order_meta.csv'
@ -135,9 +135,19 @@ def main(dataroot):
onset_count = 0 onset_count = 0
offset_count = 0 offset_count = 0
physical_count = 0 physical_count = 0
# winner_count = 0
# loser_count = 0
# winner_onset_chirpcount = 0
# winner_offset_chirpcount = 0
# winner_physical_chirpcount = 0
# loser_onset_chirpcount = 0
# loser_offset_chirpcount = 0
# loser_physical_chirpcount = 0
fig, ax = plt.subplots(1, 2, figsize=(
14 * ps.cm, 7*ps.cm), sharey=True, sharex=True)
# Iterate over all recordings and save chirp- and event-timestamps # Iterate over all recordings and save chirp- and event-timestamps
for folder in tqdm(foldernames): good_recs = np.asarray([0, 15])
for i, folder in tqdm(enumerate(foldernames[good_recs])):
foldername = folder.split('/')[-2] foldername = folder.split('/')[-2]
# logger.info('Loading data from folder: {}'.format(foldername)) # logger.info('Loading data from folder: {}'.format(foldername))
@ -153,9 +163,10 @@ def main(dataroot):
timestamps = timestamps[timestamps < 3*60*60] # only night time timestamps = timestamps[timestamps < 3*60*60] # only night time
winner, loser = get_chirp_winner_loser(folder, bh, meta) winner, loser = get_chirp_winner_loser(folder, bh, meta)
if winner is None: if winner is None:
continue continue
# winner_count += len(winner)
# loser_count += len(loser)
onsets = (timestamps[category == 0]) onsets = (timestamps[category == 0])
offsets = (timestamps[category == 1]) offsets = (timestamps[category == 1])
@ -179,42 +190,48 @@ def main(dataroot):
loser_physicals.append(center_chirps( loser_physicals.append(center_chirps(
loser, physicals, time_before, time_after)) loser, physicals, time_before, time_after))
# winner_onset_chirpcount += len(winner_onsets[-1])
# winner_offset_chirpcount += len(winner_offsets[-1])
# winner_physical_chirpcount += len(winner_physicals[-1])
# loser_onset_chirpcount += len(loser_onsets[-1])
# loser_offset_chirpcount += len(loser_offsets[-1])
# loser_physical_chirpcount += len(loser_physicals[-1])
# bootstrap # bootstrap
# chirps = [winner, winner, winner, loser, loser, loser] # chirps = [winner, winner, winner, loser, loser, loser]
winner_onsets_boot.append(bootstrap( # winner_onsets_boot.append(bootstrap(
winner, # winner,
nresamples=nbootstraps, # nresamples=nbootstraps,
kde_time=kde_time, # kde_time=kde_time,
kernel_width=kernel_width, # kernel_width=kernel_width,
event_times=onsets, # event_times=onsets,
time_before=time_before, # time_before=time_before,
time_after=time_after)) # time_after=time_after))
winner_offsets_boot.append(bootstrap( # winner_offsets_boot.append(bootstrap(
winner, # winner,
nresamples=nbootstraps, # nresamples=nbootstraps,
kde_time=kde_time, # kde_time=kde_time,
kernel_width=kernel_width, # kernel_width=kernel_width,
event_times=offsets, # event_times=offsets,
time_before=time_before, # time_before=time_before,
time_after=time_after)) # time_after=time_after))
winner_physicals_boot.append(bootstrap( # winner_physicals_boot.append(bootstrap(
winner, # winner,
nresamples=nbootstraps, # nresamples=nbootstraps,
kde_time=kde_time, # kde_time=kde_time,
kernel_width=kernel_width, # kernel_width=kernel_width,
event_times=physicals, # event_times=physicals,
time_before=time_before, # time_before=time_before,
time_after=time_after)) # time_after=time_after))
loser_onsets_boot.append(bootstrap( # loser_onsets_boot.append(bootstrap(
loser, # loser,
nresamples=nbootstraps, # nresamples=nbootstraps,
kde_time=kde_time, # kde_time=kde_time,
kernel_width=kernel_width, # kernel_width=kernel_width,
event_times=onsets, # event_times=onsets,
time_before=time_before, # time_before=time_before,
time_after=time_after)) # time_after=time_after))
loser_offsets_boot.append(bootstrap( loser_offsets_boot.append(bootstrap(
loser, loser,
nresamples=nbootstraps, nresamples=nbootstraps,
@ -223,61 +240,99 @@ def main(dataroot):
event_times=offsets, event_times=offsets,
time_before=time_before, time_before=time_before,
time_after=time_after)) time_after=time_after))
loser_physicals_boot.append(bootstrap( # loser_physicals_boot.append(bootstrap(
# loser,
# nresamples=nbootstraps,
# kde_time=kde_time,
# kernel_width=kernel_width,
# event_times=physicals,
# time_before=time_before,
# time_after=time_after))
loser_offsets_jackknife = jackknife(
loser, loser,
nresamples=nbootstraps, nresamples=nbootstraps,
subsetsize=0.5,
kde_time=kde_time, kde_time=kde_time,
kernel_width=kernel_width, kernel_width=kernel_width,
event_times=physicals, event_times=offsets,
time_before=time_before, time_before=time_before,
time_after=time_after)) time_after=time_after)
if plot_all: if plot_all:
winner_onsets_conv = acausal_kde1d( # winner_onsets_conv = acausal_kde1d(
winner_onsets[-1], kde_time, kernel_width) # winner_onsets[-1], kde_time, kernel_width)
winner_offsets_conv = acausal_kde1d( # winner_offsets_conv = acausal_kde1d(
winner_offsets[-1], kde_time, kernel_width) # winner_offsets[-1], kde_time, kernel_width)
winner_physicals_conv = acausal_kde1d( # winner_physicals_conv = acausal_kde1d(
winner_physicals[-1], kde_time, kernel_width) # winner_physicals[-1], kde_time, kernel_width)
loser_onsets_conv = acausal_kde1d( # loser_onsets_conv = acausal_kde1d(
loser_onsets[-1], kde_time, kernel_width) # loser_onsets[-1], kde_time, kernel_width)
loser_offsets_conv = acausal_kde1d( loser_offsets_conv = acausal_kde1d(
loser_offsets[-1], kde_time, kernel_width) loser_offsets[-1], kde_time, kernel_width)
loser_physicals_conv = acausal_kde1d( # loser_physicals_conv = acausal_kde1d(
loser_physicals[-1], kde_time, kernel_width) # loser_physicals[-1], kde_time, kernel_width)
fig, ax = plt.subplots(2, 3, figsize=( ax[i].plot(kde_time, loser_offsets_conv/len(offsets))
21*ps.cm, 10*ps.cm), sharey=True, sharex=True)
ax[0, 0].set_title( ax[i].fill_between(
f"{foldername}, onsets {len(onsets)}, offsets {len(offsets)}, physicals {len(physicals)},winner {len(winner)}, looser {len(loser)} , onsets") kde_time,
ax[0, 0].plot(kde_time, winner_onsets_conv/len(onsets)) np.percentile(loser_offsets_boot[-1], 5, axis=0),
ax[0, 1].plot(kde_time, winner_offsets_conv/len(offsets)) np.percentile(loser_offsets_boot[-1], 95, axis=0),
ax[0, 2].plot(kde_time, winner_physicals_conv/len(physicals)) color=ps.gray,
ax[1, 0].plot(kde_time, loser_onsets_conv/len(onsets)) alpha=0.5)
ax[1, 1].plot(kde_time, loser_offsets_conv/len(offsets))
ax[1, 2].plot(kde_time, loser_physicals_conv/len(physicals)) ax[i].plot(kde_time, np.median(loser_offsets_boot[-1], axis=0),
color=ps.black, linewidth=2)
ax[i].fill_between(
kde_time,
np.percentile(loser_offsets_jackknife, 5, axis=0),
np.percentile(loser_offsets_jackknife, 95, axis=0),
color=ps.blue,
alpha=0.5)
ax[i].plot(kde_time, np.median(loser_offsets_jackknife, axis=0),
color=ps.white, linewidth=2)
ax[i].set_xlim(-60, 60)
embed()
# fig, ax = plt.subplots(2, 3, figsize=(
# 21*ps.cm, 10*ps.cm), sharey=True, sharex=True)
# ax[0, 0].set_title(
# f"{foldername}, onsets {len(onsets)}, offsets {len(offsets)}, physicals {len(physicals)},winner {len(winner)}, looser {len(loser)} , onsets")
# ax[0, 0].plot(kde_time, winner_onsets_conv/len(onsets))
# ax[0, 1].plot(kde_time, winner_offsets_conv /
# len(offsets))
# ax[0, 2].plot(kde_time, winner_physicals_conv /
# len(physicals))
# ax[1, 0].plot(kde_time, loser_onsets_conv/len(onsets))
# ax[1, 1].plot(kde_time, loser_offsets_conv/len(offsets))
# ax[1, 2].plot(kde_time, loser_physicals_conv /
# len(physicals))
# # plot bootstrap lines # # plot bootstrap lines
for kde in winner_onsets_boot[-1]: # for kde in winner_onsets_boot[-1]:
ax[0, 0].plot(kde_time, kde/len(onsets), # ax[0, 0].plot(kde_time, kde,
color='gray') # color='gray')
for kde in winner_offsets_boot[-1]: # for kde in winner_offsets_boot[-1]:
ax[0, 1].plot(kde_time, kde/len(offsets), # ax[0, 1].plot(kde_time, kde,
color='gray') # color='gray')
for kde in winner_physicals_boot[-1]: # for kde in winner_physicals_boot[-1]:
ax[0, 2].plot(kde_time, kde/len(physicals), # ax[0, 2].plot(kde_time, kde,
color='gray') # color='gray')
for kde in loser_onsets_boot[-1]: # for kde in loser_onsets_boot[-1]:
ax[1, 0].plot(kde_time, kde/len(onsets), # ax[1, 0].plot(kde_time, kde,
color='gray') # color='gray')
for kde in loser_offsets_boot[-1]: # for kde in loser_offsets_boot[-1]:
ax[1, 1].plot(kde_time, kde/len(offsets), # ax[1, 1].plot(kde_time, kde,
color='gray') # color='gray')
for kde in loser_physicals_boot[-1]: # for kde in loser_physicals_boot[-1]:
ax[1, 2].plot(kde_time, kde/len(physicals), # ax[1, 2].plot(kde_time, kde,
color='gray') # color='gray')
# plot bootstrap percentiles # plot bootstrap percentiles
# ax[0, 0].fill_between( # ax[0, 0].fill_between(
@ -335,79 +390,79 @@ def main(dataroot):
# ax[1, 2].plot(kde_time, np.median(loser_physicals_boot[-1], axis=0), # ax[1, 2].plot(kde_time, np.median(loser_physicals_boot[-1], axis=0),
# color='black', linewidth=2) # color='black', linewidth=2)
ax[0, 0].set_xlim(-30, 30) # ax[0, 0].set_xlim(-30, 30)
plt.show() plt.show()
winner_onsets = np.sort(flatten(winner_onsets)) # winner_onsets = np.sort(flatten(winner_onsets))
winner_offsets = np.sort(flatten(winner_offsets)) # winner_offsets = np.sort(flatten(winner_offsets))
winner_physicals = np.sort(flatten(winner_physicals)) # winner_physicals = np.sort(flatten(winner_physicals))
loser_onsets = np.sort(flatten(loser_onsets)) # loser_onsets = np.sort(flatten(loser_onsets))
loser_offsets = np.sort(flatten(loser_offsets)) # loser_offsets = np.sort(flatten(loser_offsets))
loser_physicals = np.sort(flatten(loser_physicals)) # loser_physicals = np.sort(flatten(loser_physicals))
winner_onsets_conv = acausal_kde1d( # winner_onsets_conv = acausal_kde1d(
winner_onsets, kde_time, kernel_width) # winner_onsets, kde_time, kernel_width)
winner_offsets_conv = acausal_kde1d( # winner_offsets_conv = acausal_kde1d(
winner_offsets, kde_time, kernel_width) # winner_offsets, kde_time, kernel_width)
winner_physicals_conv = acausal_kde1d( # winner_physicals_conv = acausal_kde1d(
winner_physicals, kde_time, kernel_width) # winner_physicals, kde_time, kernel_width)
loser_onsets_conv = acausal_kde1d( # loser_onsets_conv = acausal_kde1d(
loser_onsets, kde_time, kernel_width) # loser_onsets, kde_time, kernel_width)
loser_offsets_conv = acausal_kde1d( # loser_offsets_conv = acausal_kde1d(
loser_offsets, kde_time, kernel_width) # loser_offsets, kde_time, kernel_width)
loser_physicals_conv = acausal_kde1d( # loser_physicals_conv = acausal_kde1d(
loser_physicals, kde_time, kernel_width) # loser_physicals, kde_time, kernel_width)
winner_onsets_conv = winner_onsets_conv / onset_count # winner_onsets_conv = winner_onsets_conv / onset_count
winner_offsets_conv = winner_offsets_conv / offset_count # winner_offsets_conv = winner_offsets_conv / offset_count
winner_physicals_conv = winner_physicals_conv / physical_count # winner_physicals_conv = winner_physicals_conv / physical_count
loser_onsets_conv = loser_onsets_conv / onset_count # loser_onsets_conv = loser_onsets_conv / onset_count
loser_offsets_conv = loser_offsets_conv / offset_count # loser_offsets_conv = loser_offsets_conv / offset_count
loser_physicals_conv = loser_physicals_conv / physical_count # loser_physicals_conv = loser_physicals_conv / physical_count
winner_onsets_boot = np.concatenate( # winner_onsets_boot = np.concatenate(
winner_onsets_boot) # winner_onsets_boot)
winner_offsets_boot = np.concatenate( # winner_offsets_boot = np.concatenate(
winner_offsets_boot) # winner_offsets_boot)
winner_physicals_boot = np.concatenate( # winner_physicals_boot = np.concatenate(
winner_physicals_boot) # winner_physicals_boot)
loser_onsets_boot = np.concatenate( # loser_onsets_boot = np.concatenate(
loser_onsets_boot) # loser_onsets_boot)
loser_offsets_boot = np.concatenate( # loser_offsets_boot = np.concatenate(
loser_offsets_boot) # loser_offsets_boot)
loser_physicals_boot = np.concatenate( # loser_physicals_boot = np.concatenate(
loser_physicals_boot) # loser_physicals_boot)
percs = [5, 50, 95] # percs = [5, 50, 95]
winner_onsets_boot_quarts = np.percentile( # winner_onsets_boot_quarts = np.percentile(
winner_onsets_boot, percs, axis=0) # winner_onsets_boot, percs, axis=0)
winner_offsets_boot_quarts = np.percentile( # winner_offsets_boot_quarts = np.percentile(
winner_offsets_boot, percs, axis=0) # winner_offsets_boot, percs, axis=0)
winner_physicals_boot_quarts = np.percentile( # winner_physicals_boot_quarts = np.percentile(
winner_physicals_boot, percs, axis=0) # winner_physicals_boot, percs, axis=0)
loser_onsets_boot_quarts = np.percentile( # loser_onsets_boot_quarts = np.percentile(
loser_onsets_boot, percs, axis=0) # loser_onsets_boot, percs, axis=0)
loser_offsets_boot_quarts = np.percentile( # loser_offsets_boot_quarts = np.percentile(
loser_offsets_boot, percs, axis=0) # loser_offsets_boot, percs, axis=0)
loser_physicals_boot_quarts = np.percentile( # loser_physicals_boot_quarts = np.percentile(
loser_physicals_boot, percs, axis=0) # loser_physicals_boot, percs, axis=0)
fig, ax = plt.subplots(2, 3, figsize=( # fig, ax = plt.subplots(2, 3, figsize=(
21*ps.cm, 10*ps.cm), sharey=True, sharex=True) # 21*ps.cm, 10*ps.cm), sharey=True, sharex=True)
ax[0, 0].plot(kde_time, winner_onsets_conv) # ax[0, 0].plot(kde_time, winner_onsets_conv)
ax[0, 1].plot(kde_time, winner_offsets_conv) # ax[0, 1].plot(kde_time, winner_offsets_conv)
ax[0, 2].plot(kde_time, winner_physicals_conv) # ax[0, 2].plot(kde_time, winner_physicals_conv)
ax[1, 0].plot(kde_time, loser_onsets_conv) # ax[1, 0].plot(kde_time, loser_onsets_conv)
ax[1, 1].plot(kde_time, loser_offsets_conv) # ax[1, 1].plot(kde_time, loser_offsets_conv)
ax[1, 2].plot(kde_time, loser_physicals_conv) # ax[1, 2].plot(kde_time, loser_physicals_conv)
ax[0, 0].plot(kde_time, winner_onsets_boot_quarts[1], c=ps.black) # ax[0, 0].plot(kde_time, winner_onsets_boot_quarts[1], c=ps.black)
ax[0, 1].plot(kde_time, winner_offsets_boot_quarts[1], c=ps.black) # ax[0, 1].plot(kde_time, winner_offsets_boot_quarts[1], c=ps.black)
ax[0, 2].plot(kde_time, winner_physicals_boot_quarts[1], c=ps.black) # ax[0, 2].plot(kde_time, winner_physicals_boot_quarts[1], c=ps.black)
ax[1, 0].plot(kde_time, loser_onsets_boot_quarts[1], c=ps.black) # ax[1, 0].plot(kde_time, loser_onsets_boot_quarts[1], c=ps.black)
ax[1, 1].plot(kde_time, loser_offsets_boot_quarts[1], c=ps.black) # ax[1, 1].plot(kde_time, loser_offsets_boot_quarts[1], c=ps.black)
ax[1, 2].plot(kde_time, loser_physicals_boot_quarts[1], c=ps.black) # ax[1, 2].plot(kde_time, loser_physicals_boot_quarts[1], c=ps.black)
# for kde in winner_onsets_boot: # for kde in winner_onsets_boot:
# ax[0, 0].plot(kde_time, kde, # ax[0, 0].plot(kde_time, kde,
@ -428,43 +483,43 @@ def main(dataroot):
# ax[1, 2].plot(kde_time, kde, # ax[1, 2].plot(kde_time, kde,
# color='gray') # color='gray')
ax[0, 0].fill_between(kde_time, # ax[0, 0].fill_between(kde_time,
winner_onsets_boot_quarts[0], # winner_onsets_boot_quarts[0],
winner_onsets_boot_quarts[2], # winner_onsets_boot_quarts[2],
color=ps.gray, # color=ps.gray,
alpha=0.5) # alpha=0.5)
ax[0, 1].fill_between(kde_time, # ax[0, 1].fill_between(kde_time,
winner_offsets_boot_quarts[0], # winner_offsets_boot_quarts[0],
winner_offsets_boot_quarts[2], # winner_offsets_boot_quarts[2],
color=ps.gray, # color=ps.gray,
alpha=0.5) # alpha=0.5)
ax[0, 2].fill_between(kde_time, # ax[0, 2].fill_between(kde_time,
loser_physicals_boot_quarts[0], # loser_physicals_boot_quarts[0],
loser_physicals_boot_quarts[2], # loser_physicals_boot_quarts[2],
color=ps.gray, # color=ps.gray,
alpha=0.5) # alpha=0.5)
ax[1, 0].fill_between(kde_time, # ax[1, 0].fill_between(kde_time,
loser_onsets_boot_quarts[0], # loser_onsets_boot_quarts[0],
loser_onsets_boot_quarts[2], # loser_onsets_boot_quarts[2],
color=ps.gray, # color=ps.gray,
alpha=0.5) # alpha=0.5)
ax[1, 1].fill_between(kde_time, # ax[1, 1].fill_between(kde_time,
loser_offsets_boot_quarts[0], # loser_offsets_boot_quarts[0],
loser_offsets_boot_quarts[2], # loser_offsets_boot_quarts[2],
color=ps.gray, # color=ps.gray,
alpha=0.5) # alpha=0.5)
ax[1, 2].fill_between(kde_time, # ax[1, 2].fill_between(kde_time,
loser_physicals_boot_quarts[0], # loser_physicals_boot_quarts[0],
loser_physicals_boot_quarts[2], # loser_physicals_boot_quarts[2],
color=ps.gray, # color=ps.gray,
alpha=0.5) # alpha=0.5)
plt.show() # plt.show()
if __name__ == '__main__': if __name__ == '__main__':

BIN
poster/figs/introplot.pdf
View File

Binary file not shown.