def compare_timefreqs(s, sample_rate, win_sizes=[0.050, 0.100, 0.250, 0.500, 1.25]): """ Compare the time frequency representation of a signal using different window sizes and estimators. """ #construct different types of estimators gaussian_est = GaussianSpectrumEstimator(nstd=6) mt_est_lowbw = MultiTaperSpectrumEstimator(bandwidth=10.0, adaptive=False) mt_est_lowbw_adapt = MultiTaperSpectrumEstimator(bandwidth=10.0, adaptive=True, max_adaptive_iter=150) mt_est_lowbw_jn = MultiTaperSpectrumEstimator(bandwidth=10.0, adaptive=False, jackknife=True) mt_est_highbw = MultiTaperSpectrumEstimator(bandwidth=30.0, adaptive=False) mt_est_highbw_adapt = MultiTaperSpectrumEstimator(bandwidth=30.0, adaptive=True, max_adaptive_iter=150) mt_est_highbw_jn = MultiTaperSpectrumEstimator(bandwidth=30.0, adaptive=False, jackknife=True) wavelet = WaveletSpectrumEstimator(num_cycles_per_window=10, min_freq=1, max_freq=sample_rate/2, num_freqs=50, nstd=6) #estimators = [gaussian_est, mt_est_lowbw, mt_est_lowbw_adapt, mt_est_highbw, mt_est_highbw_adapt] estimators = [wavelet] #enames = ['gauss', 'lowbw', 'lowbw_a', 'highbw', 'highbw_a'] enames = ['wavelet'] #run each estimator for each window size and plot the amplitude of the time frequency representation plt.figure() spnum = 1 for k,win_size in enumerate(win_sizes): increment = 1.0 / sample_rate for j,est in enumerate(estimators): t,freq,tf = timefreq(s, sample_rate, win_size, increment, est) print 'freq=',freq ax = plt.subplot(len(win_sizes), len(estimators), spnum) plot_spectrogram(t, freq, np.abs(tf), ax=ax, colorbar=True, ticks=True) if k == 0: plt.title(enames[j]) #if j == 0: #plt.ylabel('%d ms' % (win_size*1000)) spnum += 1
def plotSoundSeg(fig, seg): # fig pointer to figure # seg is the segment # returns the filtered sound from the loudest of the two signals. # clear figure fig.clear() # The sound signal soundSnip = seg.analogsignals[1] fs = soundSnip.sampling_rate tvals = soundSnip.times # Calculate the rms of each mic rms0 = np.std(soundSnip[:, 0]) rms1 = np.std(soundSnip[:, 1]) # Choose the loudest to plot if rms1 > rms0: sound = np.asarray(soundSnip[:, 1]).squeeze() else: sound = np.asarray(soundSnip[:, 0]).squeeze() # Calculate envelope and spectrogram sound = sound - sound.mean() sound_env = lowpass_filter(np.abs(sound), float(fs), 250.0) # Sound Enveloppe to, fo, spect, rms = spectrogram(sound, float(fs), 1000, 50) # Plot sonogram and spectrogram gs = gridspec.GridSpec(100, 1) ax = fig.add_subplot(gs[0:20, 0]) ax.plot(tvals - tvals[0], sound / sound.max()) ax.plot(tvals - tvals[0], sound_env / sound_env.max(), color="red", linewidth=2) plt.title('%s %d' % (seg.name, seg.index)) plt.xlim(0.0, to[-1]) ax = fig.add_subplot(gs[21:, 0]) plot_spectrogram(to, fo, spect, ax=ax, ticks=True, fmin=250, fmax=8000, colormap=None, colorbar=False, log=True, dBNoise=50) plt.ylabel('Frequency') plt.tick_params(labelbottom='off') plt.xlim(0.0, to[-1]) plt.show() return sound, fs
def test_delta(self): dur = 30. sample_rate = 1e3 nt = int(dur * sample_rate) t = np.arange(nt) / sample_rate freqs = np.linspace(0.5, 1.5, nt) # freqs = np.ones_like(t)*2. s = np.sin(2 * np.pi * freqs * t) center_freqs = np.arange(0.5, 4.5, 0.5) psi = lambda _t, _f, _bw: (np.pi * _bw**2)**(-0.5) * np.exp( 2 * np.pi * complex(0, 1) * _f * _t) * np.exp(-_t**2 / _bw**2) """ scalogram = np.zeros([len(center_freqs), nt]) bandwidth = 1. nstd = 6 nwt = int(bandwidth*nstd*sample_rate) wt = np.arange(nwt) / sample_rate for k,f in enumerate(center_freqs): w = psi(wt, f, bandwidth) scalogram[k, :] = convolve1d(s, w) """ win_len = 2. spec_t, spec_freq, spec, spec_rms = gaussian_stft( s, sample_rate, win_len, 100e-3) fi = (spec_freq < 10) & (spec_freq > 0) plt.figure() gs = plt.GridSpec(100, 1) ax = plt.subplot(gs[:30, 0]) plt.plot(t, s, 'k-', linewidth=4.0, alpha=0.7) wa = WaveletAnalysis(s, dt=1. / sample_rate, frequency=True) ax = plt.subplot(gs[35:, 0]) power = wa.wavelet_power scales = wa.scales t = wa.time T, S = np.meshgrid(t, scales) # ax.contourf(T, S, power, 100) # ax.set_yscale('log') # plt.imshow(np.abs(scalogram)**2, interpolation='nearest', aspect='auto', cmap=plt.cm.afmhot_r, origin='lower', # extent=[t.min(), t.max(), min(center_freqs), max(center_freqs)]) plot_spectrogram(spec_t, spec_freq[fi], np.abs(spec[fi, :])**2, ax=ax, colorbar=False, colormap=plt.cm.afmhot_r) plt.plot(t, freqs, 'k-', alpha=0.7, linewidth=4.0) plt.axis('tight') plt.show()
def get_temporary_template(i = 17): """ Returns a spectrogram and a template, if i = 17 it's some sort of song Really just a placeholder for a better template algorithm TODO replace this with real code, like user defined sections of spectrograms """ template = mic[sound_onset[i]:sound_offset[i]] template = template[4800:18000] #shift it, particular to this template templ_t, templ_freq, templ_timefreq, templ_rms = spectrogram(template, fs_mic, spec_sample_rate = 1000, freq_spacing = 50) figure() plot_spectrogram(templ_t, templ_freq, templ_timefreq, dBNoise=80, colorbar = False) return template, templ_t, templ_freq, templ_timefreq
def compare_timefreqs(s, sample_rate, win_sizes=[0.050, 0.100, 0.250, 0.500, 1.25]): """ Compare the time frequency representation of a signal using different window sizes and estimators. """ #construct different types of estimators gaussian_est = GaussianSpectrumEstimator(nstd=6) mt_est_lowbw = MultiTaperSpectrumEstimator(bandwidth=10.0, adaptive=False) mt_est_lowbw_adapt = MultiTaperSpectrumEstimator(bandwidth=10.0, adaptive=True, max_adaptive_iter=150) mt_est_lowbw_jn = MultiTaperSpectrumEstimator(bandwidth=10.0, adaptive=False, jackknife=True) mt_est_highbw = MultiTaperSpectrumEstimator(bandwidth=30.0, adaptive=False) mt_est_highbw_adapt = MultiTaperSpectrumEstimator(bandwidth=30.0, adaptive=True, max_adaptive_iter=150) mt_est_highbw_jn = MultiTaperSpectrumEstimator(bandwidth=30.0, adaptive=False, jackknife=True) wavelet = WaveletSpectrumEstimator(num_cycles_per_window=10, min_freq=1, max_freq=sample_rate / 2, num_freqs=50, nstd=6) #estimators = [gaussian_est, mt_est_lowbw, mt_est_lowbw_adapt, mt_est_highbw, mt_est_highbw_adapt] estimators = [wavelet] #enames = ['gauss', 'lowbw', 'lowbw_a', 'highbw', 'highbw_a'] enames = ['wavelet'] #run each estimator for each window size and plot the amplitude of the time frequency representation plt.figure() spnum = 1 for k, win_size in enumerate(win_sizes): increment = 1.0 / sample_rate for j, est in enumerate(estimators): t, freq, tf = timefreq(s, sample_rate, win_size, increment, est) print 'freq=', freq ax = plt.subplot(len(win_sizes), len(estimators), spnum) plot_spectrogram(t, freq, np.abs(tf), ax=ax, colorbar=True, ticks=True) if k == 0: plt.title(enames[j]) #if j == 0: #plt.ylabel('%d ms' % (win_size*1000)) spnum += 1
def plot_high_corrs(sound_onset, high_corrs, x, y, mic, fs_mic, template_correlations, amplitude_correlations, corr_ind, amp_ind, plot_figures=0): """ Aligns and plots a given template against the microphone channel. Returns alignment points. Requires high_corrs, an array of which sounds you want to align (index of sound_onsets), and template (x, z, int), the template you are matching to. """ alignments = list() amp_alignments = list() figure(1) title('template') plot_zscore_spectrogram(template_t[x], template_freq[x], template_timefreq[x]) # plot_zscore_spectrogram(template_t[y], template_freq[y], template_timefreq[y]) for sound in high_corrs: align = corr_ind[x][sound] a_align = amp_ind[x][sound] good_align = np.int(sound_onset[sounds[sound]]) + align - np.int( np.round(.5 * len(template_correlations[x][sound]))) amp_good_align = np.int(sound_onset[sounds[sound]]) + a_align - np.int( np.round(.5 * len(amplitude_correlations[x][sound]))) sound_align_wav = mic[good_align - fs_mic:good_align + 2 * fs_mic] amp_align_wav = mic[amp_good_align - fs_mic:amp_good_align + 2 * fs_mic] if plot_figures: sound_t, sound_freq, sound_timefreq, sound_rms = spectrogram( np.squeeze(sound_align_wav), fs_mic, spec_sample_rate=1000, freq_spacing=50) figure(2) plot_spectrogram(sound_t, sound_freq, sound_timefreq) pause(.1) close(2) alignments.append(good_align) amp_alignments.append(amp_good_align) return alignments, amp_alignments
def plot_specs_with_env(ax, rp, stim_id, trial=3): # plot distance call w/ amp envelope i = (rp.event_df.stim_id == stim_id) & (rp.event_df.trial == trial) assert i.sum() == 1 stime = rp.event_df[i].start_time.values[0] etime = rp.event_df[i].end_time.values[0] si = int(stime*rp.sample_rate) ei = int(etime * rp.sample_rate) spec = rp.U[si:ei, :].T spec_freq = rp.spec_freq spec_env = spec.sum(axis=0) spec_env /= spec_env.max() spec_t = np.arange(spec.shape[1]) / rp.sample_rate spec_env *= (spec_freq.max() - spec_freq.min()) spec_env += spec_freq.min() plot_spectrogram(spec_t, spec_freq, spec, ax=ax, ticks=True, fmax=8000., colormap='SpectroColorMap', colorbar=False) plt.plot(spec_t, spec_env, 'k-', linewidth=5.0, alpha=0.7) plt.axis('tight')
high_amp_clean = np.zeros(high_amp.shape) high_amp_suppressed = np.zeros(high_amp.shape) neural_signal_env = np.zeros(high_amp.shape) neural_noise_env = np.zeros(high_amp.shape) neural_clean_env = np.zeros(high_amp.shape) GS = 6 # Gain for the sigmoid if i == 0: # update ax = fig_clean.add_subplot(gs[0:29, 0]) to, fo, spect, rms = spectrogram(mic_slice, sample_rate, 1000, 50) plot_spectrogram(to, fo, spect, ax=ax, ticks=False, fmin=250, fmax=8000, colormap=None, colorbar=False, log=True, dBNoise=50) ax = fig_raw.add_subplot(gs[0:29, 0]) to, fo, spect, rms = spectrogram(mic_slice, sample_rate, 1000, 50) plot_spectrogram(to, fo, spect, ax=ax, ticks=False, fmin=250, fmax=8000, colormap=None,
freq_index = [] iter = 0 for i in range(len(templ_freq[0])): if (templ_freq[0][i] > low_freq_corr) & (templ_freq[0][i] < high_freq_corr): freq_index.append(i) iter += iter for i in range(len(templ_timefreq)): templ_freq[i] = templ_freq[i][freq_index] templ_timefreq[i] = templ_timefreq[i][freq_index,:] templ_timefreq[i] = zscore(templ_timefreq[i], axis = None) if plot_templates: for i in range(len(templ_timefreq)): figure() plot_spectrogram(templ_t[i], templ_freq[i], templ_timefreq[i], dBNoise=80, colorbar = False) #============================================================================== # loop through every sound_onset and calculate correlations with templates template_corr = list() template_corr_peak = list() for jj in range(len(templ_freq)): corr_list = list() peak_list = list() longest_corr = 0 for i in range(len(sound_onset)): sound_wav = mic[sound_onset[i]:sound_offset[i]] spect_corr = get_spect_corr(sound_wav, templ_timefreq[jj], freq_index, fs_mic) corr_list.append(spect_corr) peaks = argrelextrema(spect_corr, np.greater, order = 100) # seems to work ok / except now it maybe doesn't peak_list = np.append(peak_list, peaks) if len(spect_corr) > longest_corr: # just keeps track of the longest corr so we can pad the others with NAN later
def draw_figures(stim_event, stim_ids, syllable_indices, e1=5, e2=2): assert isinstance(stim_event, StimEventTransform) sample_rate = stim_event.lfp_sample_rate lags_ms = get_lags_ms(sample_rate) cross_functions_total = dict() cross_functions_locked = dict() cross_functions_nonlocked = dict() specs = dict() syllable_times = dict() stim_end_time = dict() hemi = ','.join(stim_event.rcg_names) # compute all cross and auto-correlations if hemi == 'L': electrode_order = ROSTRAL_CAUDAL_ELECTRODES_LEFT else: electrode_order = ROSTRAL_CAUDAL_ELECTRODES_RIGHT freqs = None nelectrodes = None index2electrode = stim_event.index2electrode seg_uname = stim_event.seg_uname bird,block,seg = seg_uname.split('_') psd_stats = get_psd_stats(bird, stim_event.block_name, stim_event.segment_name, hemi) for stim_id,syllable_index in zip(stim_ids, syllable_indices): lfp = stim_event.lfp_reps_by_stim['raw'][stim_id] ntrials,nelectrodes,nt = lfp.shape # get the start and end time of the syllable i = (stim_event.segment_df['stim_id'] == stim_id) & (stim_event.segment_df['order'] == syllable_index) assert i.sum() > 0, "No syllable for stim_id=%d, order=%d" % (stim_id, syllable_index) assert i.sum() == 1, "More than one syllable for stim_id=%d, order=%d" % (stim_id, syllable_index) start_time = stim_event.segment_df[i]['start_time'].values[0] end_time = stim_event.segment_df[i]['end_time'].values[0] syllable_times[stim_id] = (start_time, end_time) # get the end time of the last syllable i = (stim_event.segment_df['stim_id'] == stim_id) stim_end_time[stim_id] = stim_event.segment_df[i]['end_time'].max() si = int((stim_event.pre_stim_time + start_time)*sample_rate) ei = int((stim_event.pre_stim_time + end_time)*sample_rate) # restrict the lfp to just the syllable time lfp = lfp[:, :, si:ei] specs[stim_id] = stim_event.spec_by_stim[stim_id] i1 = index2electrode.index(e1) lfp1 = lfp[:, i1, :] i2 = index2electrode.index(e2) lfp2 = lfp[:, i2, :] # compute the covariance functions pfreq, psd1, psd2, psd1_ms, psd2_ms, c12, c12_nonlocked, c12_total = compute_spectra_and_coherence_single_electrode(lfp1, lfp2, sample_rate, e1, e2, psd_stats=psd_stats) cross_functions_total[stim_id] = (psd1, psd2, c12_total) cross_functions_locked[stim_id] = (psd1, psd2, c12) cross_functions_nonlocked[stim_id] = (psd1, psd2, c12_nonlocked) # plot the cross covariance functions to overlap for each stim plot_cross_pair(stim_ids, cross_functions_total, electrode_order, freqs, lags_ms) plt.suptitle('Total Covariance') fname = os.path.join(get_this_dir(), 'cross_total.svg') plt.savefig(fname, facecolor='w', edgecolor='none') # plot_cross_mat(stim_ids, cross_functions_locked, electrode_order, freqs) plot_cross_pair(stim_ids, cross_functions_locked, electrode_order, freqs, lags_ms) plt.suptitle('Stim-locked Covariance') fname = os.path.join(get_this_dir(), 'cross_locked.svg') plt.savefig(fname, facecolor='w', edgecolor='none') # plot_cross_mat(stim_ids, cross_functions_nonlocked, electrode_order, freqs) plot_cross_pair(stim_ids, cross_functions_nonlocked, electrode_order, freqs, lags_ms) plt.suptitle('Non-locked Covariance') fname = os.path.join(get_this_dir(), 'cross_nonlocked.svg') plt.savefig(fname, facecolor='w', edgecolor='none') # plot the spectrograms fig_height = 2 fig_max_width = 6 spec_lens = np.array([stim_end_time[stim_id] for stim_id in stim_ids]) spec_ratios = spec_lens / spec_lens.max() spec_sample_rate = sample_rate for k,stim_id in enumerate(stim_ids): spec = specs[stim_id] syllable_start,syllable_end = syllable_times[stim_id] print 'stim_id=%d, syllable_start=%0.3f, syllable_end=%0.3f' % (stim_id, syllable_start, syllable_end) spec_t = np.arange(spec.shape[1]) / spec_sample_rate stim_end = stim_end_time[stim_id] figsize = (spec_ratios[k]*fig_max_width, fig_height) fig = plt.figure(figsize=figsize) ax = plt.gca() plot_spectrogram(spec_t, stim_event.spec_freq, spec, ax=ax, ticks=True, fmin=300., fmax=8000., colormap='SpectroColorMap', colorbar=False) plt.axvline(syllable_start, c='k', linestyle='dashed', linewidth=3.0) plt.axvline(syllable_end, c='k', linestyle='dashed', linewidth=3.0) plt.xlim(0, stim_end+0.005) fname = os.path.join(get_this_dir(), 'stim_spec_%d.svg' % stim_id)
import matplotlib.pyplot as plt from scipy.io.wavfile import read import numpy as np from lasp.timefreq import gaussian_stft from lasp.sound import plot_spectrogram import pdb fname = 'DCCalls16x16/fbird8call1.wav' wf = read(fname, 'r')[1] # Frames: 30870.00d, Rate: 44100.00 wl = 0.007 # 7ms ic = 0.001 # 1ms t, freq, timefreq, rms = gaussian_stft(wf, 44100, wl, ic) spec = np.abs(timefreq) spec = spec / spec.max() nz = spec > 0 spec[nz] = 20 * np.log10(spec[nz]) + 50 spec[spec < 0] = 0 plot_spectrogram(t, freq, spec) plt.show()
def draw_figures(bird, block, segment, hemi, e1, e2, stim_id, syllable_index, data_dir='/auto/tdrive/mschachter/data', exp=None): # load up the experiment if exp is None: bird_dir = os.path.join(data_dir, bird) exp_file = os.path.join(bird_dir, '%s.h5' % bird) stim_file = os.path.join(bird_dir, 'stims.h5') exp = Experiment.load(exp_file, stim_file) seg = exp.get_segment(block, segment) # get the start and end times of the stimulus etable = exp.get_epoch_table(seg) i = etable['id'] == stim_id stim_times = zip(etable[i]['start_time'].values, etable[i]['end_time'].values) stim_times.sort(key=operator.itemgetter(0)) stim_times = np.array(stim_times) stim_durs = stim_times[:, 1] - stim_times[:, 0] stim_dur = stim_durs.min() # aggregate the LFPs across trials lfps = list() sample_rate = None electrode_indices = None for start_time,end_time in stim_times: # get a slice of the LFP lfp_data = exp.get_lfp_slice(seg, start_time, end_time) electrode_indices,the_lfps,sample_rate = lfp_data[hemi] stim_dur_i = int(stim_dur*sample_rate) lfps.append(the_lfps[:, :stim_dur_i]) lfps = np.array(lfps) # rescale the LFPs to they are in uV lfps *= 1e6 # get the log spectrogram of the stimulus start_time_0 = stim_times[0][0] end_time_0 = stim_times[0][1] stim_spec_t,stim_spec_freq,stim_spec = exp.get_spectrogram_slice(seg, start_time_0, end_time_0) stim_spec_t = np.linspace(0, stim_dur, len(stim_spec_t)) stim_spec_dt = np.diff(stim_spec_t)[0] nz = stim_spec > 0 stim_spec[nz] = 20*np.log10(stim_spec[nz]) + 100 stim_spec[stim_spec < 0] = 0 # get the amplitude envelope amp_env = stim_spec.std(axis=0, ddof=1) amp_env -= amp_env.min() amp_env /= amp_env.max() # segment the amplitude envelope into syllables merge_thresh = int(0.002*sample_rate) events = break_envelope_into_events(amp_env, threshold=0.05, merge_thresh=merge_thresh) # translate the event indices into actual times events *= stim_spec_dt syllable_start,syllable_end,syllable_max_amp = events[syllable_index] syllable_start -= 0.005 syllable_end += 0.010 amp_env_rs = amp_env*(stim_spec_freq.max() - stim_spec_freq.min()) + stim_spec_freq.min() last_syllable_end = events[-1, 1] + 0.025 i1 = electrode_indices.index(e1) i2 = electrode_indices.index(e2) lfp1 = lfps[:, i1, :] lfp2 = lfps[:, i2, :] # zscore the LFP lfp1 -= lfp1.mean() lfp1 /= lfp1.std(ddof=1) lfp2 -= lfp2.mean() lfp2 /= lfp2.std(ddof=1) ntrials,nelectrodes,nt = lfps.shape ntrials_to_plot = 5 t = np.arange(nt) / sample_rate # plot the stimulus and raw LFP for two electrodes figsize = (24.0, 10) fig = plt.figure(figsize=figsize) plt.subplots_adjust(top=0.95, bottom=0.05, left=0.03, right=0.99, hspace=0.10) gs = plt.GridSpec(3, 100) ax = plt.subplot(gs[0, :60]) plot_spectrogram(stim_spec_t, stim_spec_freq, stim_spec, ax=ax, ticks=True, fmin=300, fmax=8000, colormap='SpectroColorMap', colorbar=False) # plt.plot(stim_spec_t, amp_env_rs, 'k-', linewidth=2.0, alpha=0.50) plt.axvline(syllable_start, c='k', linestyle='dashed', linewidth=3.0) plt.axvline(syllable_end, c='k', linestyle='dashed', linewidth=3.0) plt.axis('tight') plt.xlim(0, last_syllable_end) # plot the first LFP (all trials) ax = plt.subplot(gs[1, :60]) for k in range(ntrials_to_plot): plt.plot(t, lfp1[k, :], '-', linewidth=2.0, alpha=0.75) plt.plot(t, lfp1.mean(axis=0), 'k-', linewidth=3.0) plt.axvline(syllable_start, c='k', linestyle='dashed', linewidth=3.0) plt.axvline(syllable_end, c='k', linestyle='dashed', linewidth=3.0) plt.xlabel('Time (ms)') plt.ylabel('E%d (z-scored)' % e1) plt.axis('tight') plt.xlim(0, last_syllable_end) ax = plt.subplot(gs[2, :60]) for k in range(ntrials_to_plot): plt.plot(t, lfp2[k, :], '-', linewidth=2.0, alpha=0.75) plt.plot(t, lfp2.mean(axis=0), 'k-', linewidth=3.0) plt.axvline(syllable_start, c='k', linestyle='dashed', linewidth=3.0) plt.axvline(syllable_end, c='k', linestyle='dashed', linewidth=3.0) plt.xlabel('Time (ms)') plt.ylabel('E%d (z-scored)' % e2) plt.axis('tight') plt.xlim(0, last_syllable_end) # restrict the lfps to a single syllable print 'syllable_start=%f, syllable_end=%f' % (syllable_start, syllable_end) syllable_si = int(syllable_start*sample_rate) syllable_ei = int(syllable_end*sample_rate) lfp1 = lfp1[:, syllable_si:syllable_ei] lfp2 = lfp2[:, syllable_si:syllable_ei] # compute the trial averaged and mean subtracted lfps lfp1_mean,lfp1_ms = compute_avg_and_ms(lfp1) lfp2_mean,lfp2_ms = compute_avg_and_ms(lfp2) psd_stats = get_psd_stats(bird, block, segment, hemi) freqs, psd1, psd2, psd1_ms, psd2_ms, c12, c12_nonlocked, c12_total = compute_spectra_and_coherence_single_electrode(lfp1, lfp2, sample_rate, e1, e2, psd_stats=psd_stats) lags_ms = get_lags_ms(sample_rate) lfp_absmax = max(np.abs(lfp1_mean).max(), np.abs(lfp2_mean).max()) lfp_ms_absmax = max(np.abs(lfp1_ms).max(), np.abs(lfp2_ms).max()) ax = plt.subplot(gs[0, 65:80]) plt.axhline(0, c='k') plt.plot(t[syllable_si:syllable_ei], lfp1_mean, 'k-', linewidth=3.0, alpha=1.) plt.plot(t[syllable_si:syllable_ei], lfp2_mean, '-', c='#c0c0c0', linewidth=3.0) # plt.xlabel('Time (s)') plt.ylabel('Trial-avg LFP') leg = custom_legend(['k', '#c0c0c0'], ['E%d' % e1, 'E%d' % e2]) plt.legend(handles=leg, fontsize='x-small') plt.axis('tight') plt.ylim(-lfp_absmax, lfp_absmax) ax = plt.subplot(gs[0, 85:]) plt.axhline(0, c='k') plt.plot(t[syllable_si:syllable_ei], lfp1_ms, 'k-', linewidth=3.0, alpha=1.) plt.plot(t[syllable_si:syllable_ei], lfp2_ms, '-', c='#c0c0c0', linewidth=3.0) # plt.xlabel('Time (s)') plt.ylabel('Mean-sub LFP') plt.legend(handles=leg, fontsize='x-small') plt.axis('tight') plt.ylim(-lfp_ms_absmax, lfp_ms_absmax) psd_max = max(psd1.max(), psd2.max(), psd1_ms.max(), psd2_ms.max()) ax = plt.subplot(gs[1, 65:80]) plt.axhline(0, c='k') plt.plot(freqs, psd1, 'k-', linewidth=3.0) plt.plot(freqs, psd2, '-', c='#c0c0c0', linewidth=3.0) plt.xlabel('Time (s)') plt.ylabel('Trial-avg Power') plt.legend(handles=leg, fontsize='x-small', loc=2) plt.axis('tight') # plt.ylim(0, psd_max) ax = plt.subplot(gs[1, 85:]) plt.axhline(0, c='k') plt.plot(freqs, psd1_ms, 'k-', linewidth=3.0) plt.plot(freqs, psd2_ms, '-', c='#c0c0c0', linewidth=3.0) plt.xlabel('Time (s)') plt.ylabel('Mean-sub Power') plt.legend(handles=leg, fontsize='x-small', loc=2) plt.axis('tight') # plt.ylim(0, psd_max) ax = plt.subplot(gs[2, 65:80]) plt.axhline(0, c='k') plt.axvline(0, c='k') plt.plot(lags_ms, c12_total, 'k-', linewidth=3.0, alpha=0.75) plt.plot(lags_ms, c12, '-', c='r', linewidth=3.0, alpha=0.75) plt.plot(lags_ms, c12_nonlocked, '-', c='b', linewidth=3.0, alpha=0.75) plt.xlabel('Lags (ms)') plt.ylabel('Coherency') leg = custom_legend(['k', 'r', 'b'], ['Raw', 'Trial-avg', 'Mean-sub']) plt.legend(handles=leg, fontsize='x-small') plt.axis('tight') plt.ylim(-0.2, 0.3) fname = os.path.join(get_this_dir(), 'raw+coherency.svg') plt.savefig(fname, facecolor='w', edgecolor='none')
sound_onsets[0] = -1 # the case where sound onset happens on the first data point if sound_onsets[i] == 1: break # TODO Next is to iterate through vocal_density and check spectrograms, but I'm running out of time for now # the idea will be to calculate xcorrs of both amplitude waveform and the spectrogram (row by row). Both will be zscored. # this should give us #for i in range(vocal_density.shape[0]): # if vocal_density[i] > density_thresh: # t, freq, timefreq, rms = spectrogram(mic[i*(window-overlap):i*(window-overlap)+window], fs_mic, 1000, 50) # plot_spectrogram(t, freq, timefreq, dBNoise=80) # xcorr for envelope and spectrogram, then make it slide, zscore, correlate plot(vocal_density[0:200]) i = 0 t, freq, timefreq, rms = spectrogram(mic[i*(window-overlap):50*(window-overlap)+window], fs_mic, 1000, 50) plot_spectrogram(t, freq, timefreq, dBNoise=80) i = 75 t, freq, timefreq, rms = spectrogram(mic[i*(window-overlap):(i+25)*(window-overlap)+window], fs_mic, 1000, 50) plot_spectrogram(t, freq, timefreq, dBNoise=80) # mic[36600000:36750000] has a song # t, freq, timefreq, rms = spectrogram(mic[36600000:36750000], fs_mic, 1000, 50) # plot_spectrogram(t, freq, timefreq, dBNoise=80)
def draw_figures(bird, block, segment, hemi, e1, e2, stim_id, trial, syllable_index, data_dir='/auto/tdrive/mschachter/data', exp=None): # load up the experiment if exp is None: bird_dir = os.path.join(data_dir, bird) exp_file = os.path.join(bird_dir, '%s.h5' % bird) stim_file = os.path.join(bird_dir, 'stims.h5') exp = Experiment.load(exp_file, stim_file) seg = exp.get_segment(block, segment) # get the start and end times of the stimulus etable = exp.get_epoch_table(seg) i = etable['id'] == stim_id stim_times = zip(etable[i]['start_time'].values, etable[i]['end_time'].values) stim_times.sort(key=operator.itemgetter(0)) start_time,end_time = stim_times[trial] stim_dur = float(end_time - start_time) # get a slice of the LFP lfp_data = exp.get_lfp_slice(seg, start_time, end_time, zscore=True) electrode_indices,lfps,sample_rate = lfp_data[hemi] # get the log spectrogram of the stimulus stim_spec_t,stim_spec_freq,stim_spec = exp.get_spectrogram_slice(seg, start_time, end_time) stim_spec_t = np.linspace(0, stim_dur, len(stim_spec_t)) stim_spec_dt = np.diff(stim_spec_t)[0] nz = stim_spec > 0 stim_spec[nz] = 20*np.log10(stim_spec[nz]) + 100 stim_spec[stim_spec < 0] = 0 # get the amplitude envelope amp_env = stim_spec.std(axis=0, ddof=1) amp_env -= amp_env.min() amp_env /= amp_env.max() # segment the amplitude envelope into syllables merge_thresh = int(0.002*sample_rate) events = break_envelope_into_events(amp_env, threshold=0.05, merge_thresh=merge_thresh) # translate the event indices into actual times events *= stim_spec_dt syllable_start,syllable_end,syllable_max_amp = events[syllable_index] amp_env_rs = amp_env*(stim_spec_freq.max() - stim_spec_freq.min()) + stim_spec_freq.min() last_syllable_end = events[-1, 1] + 0.025 i1 = electrode_indices.index(e1) i2 = electrode_indices.index(e2) lfp1 = lfps[i1, :] lfp2 = lfps[i2, :] t = np.arange(len(lfp1)) / sample_rate legend = ['E%d' % e1, 'E%d' % e2] if hemi == 'L': electrode_order = ROSTRAL_CAUDAL_ELECTRODES_LEFT else: electrode_order = ROSTRAL_CAUDAL_ELECTRODES_RIGHT # get the power spectrum stats for this site psd_stats = get_psd_stats(bird, block, segment, hemi) # compute the power spectra and cross coherence for all electrodes lags_ms = get_lags_ms(sample_rate) spectra,cross_mat = compute_spectra_and_coherence_multi_electrode_single_trial(lfps, sample_rate, electrode_indices, electrode_order, psd_stats=psd_stats) # plot the stimulus and raw LFP for two electrodes figsize = (24.0, 10) fig = plt.figure(figsize=figsize) plt.subplots_adjust(top=0.95, bottom=0.05, left=0.03, right=0.99, hspace=0.10) ax = plt.subplot(2, 1, 1) plot_spectrogram(stim_spec_t, stim_spec_freq, stim_spec, ax=ax, ticks=True, fmin=300, fmax=8000, colormap='SpectroColorMap', colorbar=False) # plt.plot(stim_spec_t, amp_env_rs, 'k-', linewidth=2.0, alpha=0.50) plt.axvline(syllable_start, c='k', linestyle='dashed', linewidth=3.0) plt.axvline(syllable_end, c='k', linestyle='dashed', linewidth=3.0) plt.axis('tight') plt.xlim(0, last_syllable_end) ax = plt.subplot(2, 1, 2) plt.plot(t, lfp1, 'b-', linewidth=3.0) plt.plot(t, lfp2, 'r-', linewidth=3.0, alpha=0.7) plt.axvline(syllable_start, c='k', linestyle='dashed', linewidth=3.0) plt.axvline(syllable_end, c='k', linestyle='dashed', linewidth=3.0) plt.xlabel('Time (ms)') plt.ylabel('LFP (z-scored)') plt.legend(legend) plt.axis('tight') plt.xlim(0, last_syllable_end) fname = os.path.join(get_this_dir(), 'raw.svg') plt.savefig(fname, facecolor='w', edgecolor='none') # restrict the lfps to a single syllable syllable_si = int(syllable_start*sample_rate) syllable_ei = int(syllable_end*sample_rate) lfp1 = lfp1[syllable_si:syllable_ei] lfp2 = lfp2[syllable_si:syllable_ei] # plot the two power spectra psd_ub = 6 psd_lb = 0 i1 = electrode_order.index(e1) i2 = electrode_order.index(e2) a1 = spectra[i1, :] a2 = spectra[i2, :] freqs = get_freqs(sample_rate) figsize = (10.0, 4.0) fig = plt.figure(figsize=figsize) plt.subplots_adjust(top=0.90, bottom=0.10, left=0.10, right=0.99, hspace=0.10) ax = plt.subplot(1, 2, 1) plt.plot(freqs, a1, 'b-', linewidth=3.0) plt.plot(freqs, a2, 'r-', linewidth=3.0) plt.xlabel('Frequency (Hz)') plt.ylabel('Power (z-scored)') plt.title('Power Spectrum') handles = custom_legend(['b', 'r'], legend) plt.legend(handles=handles, fontsize='small') plt.axis('tight') plt.ylim(psd_lb, psd_ub) # plot the coherency cf_lb = -0.1 cf_ub = 0.3 coh = cross_mat[i1, i2, :] ax = plt.subplot(1, 2, 2) plt.axhline(0, c='k') plt.axvline(0, c='k') plt.plot(lags_ms, coh, 'g-', linewidth=3.0) plt.xlabel('Frequency (Hz)') plt.title('Coherency') plt.axis('tight') plt.ylim(cf_lb, cf_ub) fname = os.path.join(get_this_dir(), 'auto+cross.svg') plt.savefig(fname, facecolor='w', edgecolor='none') # compute all cross and auto-correlations nelectrodes = len(electrode_order) # make a plot figsize = (24.0, 13.5) fig = plt.figure(figsize=figsize) plt.subplots_adjust(top=0.95, bottom=0.05, left=0.03, right=0.99, hspace=0.10) gs = plt.GridSpec(nelectrodes, nelectrodes) for i in range(nelectrodes): for j in range(i+1): ax = plt.subplot(gs[i, j]) plt.axhline(0, c='k') plt.axvline(0, c='k') _e1 = electrode_order[i] _e2 = electrode_order[j] clr = 'k' if i == j: if _e1 == e1: clr = 'b' elif _e1 == e2: clr = 'r' else: if _e1 == e1 and _e2 == e2: clr = 'g' if i == j: plt.plot(freqs, spectra[i, :], '-', c=clr, linewidth=2.0) else: plt.plot(lags_ms, cross_mat[i, j, :], '-', c=clr, linewidth=2.0) plt.xticks([]) plt.yticks([]) plt.axis('tight') if i != j: plt.ylim(cf_lb, cf_ub) else: plt.axhline(0, c='k') plt.ylim(psd_lb, psd_ub) if j == 0: plt.ylabel('E%d' % electrode_order[i]) if i == nelectrodes-1: plt.xlabel('E%d' % electrode_order[j]) fname = os.path.join(get_this_dir(), 'cross_all.svg') plt.savefig(fname, facecolor='w', edgecolor='none')
def plot_nofund(agg, data_dir='/auto/tdrive/mschachter/data'): spec_colormap() aprops = ['fund', 'maxfund', 'minfund', 'cvfund', 'fund2', 'voice2percent', 'stdspect', 'skewspect', 'kurtosisspect', 'entropyspect', 'sal', 'meanspect', 'q1', 'q2', 'q3', 'skewtime', 'kurtosistime', 'entropytime', 'maxAmp'] Xz, good_indices = agg.remove_duplicates(acoustic_props=aprops) stim_durs = agg.df.end_time.values - agg.df.start_time.values good_indices = [gi for gi in good_indices if stim_durs[gi] > 0.040 and stim_durs[gi] < 0.450] stims = [(stim_id, order, stim_type) for stim_id, order, stim_type in zip(agg.df.stim_id[good_indices], agg.df.syllable_order[good_indices], agg.df.stim_type[good_indices])] plt.figure() plt.hist(stim_durs[good_indices], bins=25) plt.show() fund_i = agg.acoustic_props.index('fund') funds = np.array([agg.Xraw[xindex, fund_i] for xindex in agg.df.xindex[good_indices]]) print 'funds.min=%f, q1=%f, q2=%f' % (funds.min(), np.percentile(funds, 1), np.percentile(funds, 2)) no_fund = np.where(funds <= 0)[0] yes_fund = np.where(funds > 0)[0] print 'no_fund=', no_fund plt.figure() plt.hist(funds, bins=20) plt.title('funds') # plt.show() # np.random.seed(1234567) # np.random.shuffle(no_fund) # np.random.shuffle(yes_fund) # get syllable properties for some examples of syllables with and without fundamental frequencies set_font(10) figsize = (23, 10) fig = plt.figure(figsize=figsize) fig.subplots_adjust(wspace=0.35, hspace=0.35, left=0.05, right=0.95) num_syllables = 5 no_fund_i = no_fund[:num_syllables] yes_fund_i = yes_fund[:num_syllables] gs = plt.GridSpec(2, num_syllables) for k in range(num_syllables): fi = no_fund_i[k] f = funds[fi] stim_id,stim_order,stim_type = stims[fi] sprops = get_syllable_props(agg, stim_id, stim_order, data_dir) ax = plt.subplot(gs[0, k]) si = sprops['spec_si'] ei = sprops['spec_ei'] plot_spectrogram(sprops['spec_t'][si:ei], sprops['spec_freq'], sprops['spec'][:, si:ei], ax=ax, colormap='SpectroColorMap', colorbar=False) plt.title('%d_%d (%s), fund=%0.2f' % (stim_id, stim_order, stim_type, f)) fi = yes_fund_i[k] f = funds[fi] stim_id, stim_order, stim_type = stims[fi] sprops = get_syllable_props(agg, stim_id, stim_order, data_dir) ax = plt.subplot(gs[1, k]) si = sprops['spec_si'] ei = sprops['spec_ei'] plot_spectrogram(sprops['spec_t'][si:ei], sprops['spec_freq'], sprops['spec'][:, si:ei], ax=ax, colormap='SpectroColorMap', colorbar=False) plt.title('%d_%d (%s), fund=%0.2f' % (stim_id, stim_order, stim_type, f)) plt.show()
def plot_syllable_comps(agg, stim_id=43, syllable_order=1, data_dir='/auto/tdrive/mschachter/data'): sprops = get_syllable_props(agg, stim_id, syllable_order, data_dir) wave = sprops['wave'] wave_t = sprops['wave_t'] wave_si = sprops['wave_si'] wave_ei = sprops['wave_ei'] ps_freq = sprops['ps_freq'] ps = sprops['ps'] amp_env = sprops['amp_env'] aprops = sprops['aprops'] start_time = aprops['start_time'] spec = sprops['spec'] spec_t = sprops['spec_t'] spec_freq = sprops['spec_freq'] spec_si = sprops['spec_si'] spec_ei = sprops['spec_ei'] aprop_specs = dict() aprop_spec_props = ['maxAmp', 'meanspect', 'sal'] for aprop in aprop_spec_props: aprop_specs[aprop] = get_syllable_examples(agg, aprop, data_dir, bird='GreBlu9508M') figsize = (23, 13) fig = plt.figure(figsize=figsize, facecolor='w') fig.subplots_adjust(top=0.95, bottom=0.08, right=0.97, left=0.06, hspace=0.30, wspace=0.30) gs = plt.GridSpec(3, 100) sp_width = 20 ax = plt.subplot(gs[0, :sp_width]) plt.plot((wave_t[wave_si:wave_ei] - start_time)*1e3, wave[wave_si:wave_ei], 'k-', linewidth=2.) plt.plot((wave_t[wave_si:wave_ei] - start_time)*1e3, amp_env[wave_si:wave_ei], 'r-', linewidth=4., alpha=0.7) plt.xlabel('Time (ms)') plt.ylabel('Waveform') plt.axis('tight') aprops_to_get = ['skewtime', 'kurtosistime', 'entropytime', 'maxAmp'] units = ['s', '', '', 'bits', ''] ax = plt.subplot(gs[0, sp_width:(sp_width+18)]) txt_space = 0.1 for k,aprop in enumerate(aprops_to_get): aval = aprops[aprop] if aval > 10: txt = '%s: %d' % (ACOUSTIC_PROP_NAMES[aprop], aval) else: txt = '%s: %0.2f' % (ACOUSTIC_PROP_NAMES[aprop], aval) txt += ' %s' % units[k] plt.text(0.1, 1-((k+1)*txt_space), txt, fontsize=18) ax.set_axis_off() plt.xlim(0, 1) plt.ylim(0, 1) plt.xticks([]) plt.yticks([]) ax = plt.subplot(gs[1, :sp_width]) fi = (ps_freq > 0) & (ps_freq <= 8000.) plt.plot(ps_freq[fi]*1e-3, ps[fi], 'k-', linewidth=3., alpha=1.) for aprop in ['q1', 'q2', 'q3']: plt.axvline(aprops[aprop]*1e-3, color='#606060', linestyle='--', linewidth=3.0, alpha=0.9) # plt.text(aprops[aprop]*1e-3 - 0.6, 3000., aprop, fontsize=14) plt.ylabel("Power") plt.yticks([]) plt.xlabel('Frequency (kHz)') plt.axis('tight') aprops_to_get = ['meanspect', 'stdspect', 'skewspect', 'kurtosisspect', 'entropyspect', 'q1', 'q2', 'q3'] units = ['Hz', 'Hz', '', '', 'bits', 'Hz', 'Hz', 'Hz'] ax = plt.subplot(gs[1, sp_width:(sp_width+18)]) for k,aprop in enumerate(aprops_to_get): aval = aprops[aprop] if aval > 10: txt = '%s: %d' % (ACOUSTIC_PROP_NAMES[aprop], aval) else: txt = '%s: %0.2f' % (ACOUSTIC_PROP_NAMES[aprop], aval) txt += ' %s' % units[k] plt.text(0.1, 1-((k+1)*txt_space), txt, fontsize=18) ax.set_axis_off() plt.xlim(0, 1) plt.ylim(0, 1) plt.xticks([]) plt.yticks([]) spec_colormap() ax = plt.subplot(gs[2, :sp_width]) plot_spectrogram((spec_t[spec_si:spec_ei]-start_time)*1e3, spec_freq*1e-3, spec[:, spec_si:spec_ei], ax, colormap='SpectroColorMap', colorbar=False) plt.axhline(aprops['fund']*1e-3, color='k', linestyle='--', linewidth=3.0) plt.ylabel("Frequency (kHz)") plt.xlabel('Time (ms)') for k,aprop in enumerate(aprop_spec_props): full_spec_freq, full_spec, centers, propvals, stypes = aprop_specs[aprop] ax = plt.subplot(gs[k, (sp_width+20):]) full_spec_t = np.arange(full_spec.shape[1]) / sprops['spec_sample_rate'] plot_spectrogram(full_spec_t, full_spec_freq*1e-3, full_spec, ax, colormap='SpectroColorMap', colorbar=False) for c,st in zip(centers,stypes): plt.text(c/sprops['spec_sample_rate'], 7., CALL_TYPE_NAMES[st], fontsize=20) pstrs = list() for p in propvals: if p > 10: if aprop == 'meanspect': pstrs.append('%d Hz' % p) else: pstrs.append('%d' % p) else: pstrs.append('%0.3f' % p) for c,p in zip(centers,pstrs): plt.text(c, 6, p, fontsize=20) # plt.xticks(centers, pstrs) plt.xticks([]) plt.ylabel('Frequency (kHz)') scale_t = (full_spec_t.max()*0.95) - np.linspace(0, 0.050, 20) scale_y = np.zeros_like(scale_t) + 3 plt.plot(scale_t, scale_y, 'k-', linewidth=4.0) plt.text(scale_t.min(), 2.0, '50ms', fontsize=20, fontweight='bold') upper_right_x = np.percentile(full_spec_t, 80) upper_right_y = 7 plt.title(ACOUSTIC_PROP_FULLNAMES[aprop], fontsize=22) aprops_to_get = ['fund', 'fund2', 'sal', 'voice2percent', 'maxfund', 'minfund', 'cvfund'] units = ['Hz', 'Hz', '', '', 'Hz', 'Hz', 'Hz'] ax = plt.subplot(gs[2, sp_width:(sp_width + 18)]) for k, aprop in enumerate(aprops_to_get): aval = aprops[aprop] if aval > 10: txt = '%s: %d' % (ACOUSTIC_PROP_NAMES[aprop], aval) else: txt = '%s: %0.2f' % (ACOUSTIC_PROP_NAMES[aprop], aval) txt += ' %s' % units[k] plt.text(0.1, 1 - ((k + 1) * txt_space), txt, fontsize=18) ax.set_axis_off() plt.xlim(0, 1) plt.ylim(0, 1) plt.xticks([]) plt.yticks([]) fname = os.path.join(get_this_dir(), 'figure.svg') plt.savefig(fname, facecolor='w', edgecolor='none') plt.show()
# for i in range(len(sound_onset)): # t, freq, timefreq, rms = spectrogram(mic[sound_onset[i]:sound_offset[i]], fs_mic, 1000, 50) # plot_spectrogram(t, freq, timefreq, dBNoise=80, colorbar = False) # pause(.05) #============================================================================== # just a temporary template, ~ 1 motif, maybe even a playback but who cares # TODO make a template finding function i = 17 template = mic[sound_onset[i]:sound_offset[i]] template = template[4800:18000] #shift it, particular to this template templ_t, templ_freq, templ_timefreq, templ_rms = spectrogram( template, fs_mic, spec_sample_rate=1000, freq_spacing=50) plot_spectrogram(templ_t, templ_freq, templ_timefreq, dBNoise=80, colorbar=False) # Make xcorr of spectrogram - if i = 17 template is present in sound # TODO this is the part that will have to loop through for every vocal chunk # for now it is just a bout that has three motifs in it t, freq, timefreq, rms = spectrogram(mic[sound_onset[i]:sound_offset[i]], fs_mic, spec_sample_rate=1000, freq_spacing=50) # find the frequencies of interest freq_index = [0] iter = 0 for i in range(len(freq)): if (freq[i] > low_freq_corr) & (freq[i] < high_freq_corr):
import matplotlib.pyplot as plt from scipy.io.wavfile import read import numpy as np from lasp.timefreq import gaussian_stft from lasp.sound import plot_spectrogram import pdb fname = 'DCCalls16x16/fbird8call1.wav' wf = read(fname,'r')[1] # Frames: 30870.00d, Rate: 44100.00 wl = 0.007 # 7ms ic = 0.001 # 1ms t,freq,timefreq,rms = gaussian_stft(wf, 44100, wl, ic) spec = np.abs(timefreq) spec = spec/spec.max() nz = spec > 0 spec[nz] = 20*np.log10(spec[nz]) + 50 spec[spec < 0] = 0 plot_spectrogram(t, freq, spec) plt.show()
def plot_full_data(d, syllable_index): syllable_start = d['syllable_props'][syllable_index]['start_time'] - 0.020 syllable_end = d['syllable_props'][syllable_index]['end_time'] + 0.030 figsize = (24.0, 10) fig = plt.figure(figsize=figsize, facecolor='w') fig.subplots_adjust(top=0.95, bottom=0.02, right=0.97, left=0.03, hspace=0.20, wspace=0.20) gs = plt.GridSpec(100, 100) left_width = 55 top_height = 30 middle_height = 40 # bottom_height = 40 top_bottom_sep = 20 # plot the spectrogram ax = plt.subplot(gs[:top_height+1, :left_width]) spec = d['spec'] spec[spec < np.percentile(spec, 15)] = 0 plot_spectrogram(d['spec_t'], d['spec_freq']*1e-3, spec, ax=ax, colormap='SpectroColorMap', colorbar=False, ticks=True) plt.axvline(syllable_start, c='k', linestyle='--', linewidth=3.0, alpha=0.7) plt.axvline(syllable_end, c='k', linestyle='--', linewidth=3.0, alpha=0.7) plt.ylabel('Frequency (kHz)') plt.xlabel('Time (s)') # plot the LFPs sr = d['lfp_sample_rate'] # lfp_mean = d['lfp'].mean(axis=0) lfp_mean = d['lfp'][2, :, :] lfp_t = np.arange(lfp_mean.shape[1]) / sr nelectrodes,nt = lfp_mean.shape gs_i = top_height + top_bottom_sep gs_e = gs_i + middle_height + 1 ax = plt.subplot(gs[gs_i:gs_e, :left_width]) voffset = 5 for n in range(nelectrodes): plt.plot(lfp_t, lfp_mean[nelectrodes-n-1, :] + voffset*n, 'k-', linewidth=3.0, alpha=0.75) plt.axis('tight') ytick_locs = np.arange(nelectrodes) * voffset plt.yticks(ytick_locs, list(reversed(d['electrode_order']))) plt.ylabel('Electrode') plt.axvline(syllable_start, c='k', linestyle='--', linewidth=3.0, alpha=0.7) plt.axvline(syllable_end, c='k', linestyle='--', linewidth=3.0, alpha=0.7) plt.xlabel('Time (s)') # plot the PSTH """ gs_i = gs_e + 5 gs_e = gs_i + bottom_height + 1 ax = plt.subplot(gs[gs_i:gs_e, :left_width]) ncells = d['psth'].shape[0] plt.imshow(d['psth'], interpolation='nearest', aspect='auto', origin='upper', extent=(0, lfp_t.max(), ncells, 0), cmap=psth_colormap(noise_level=0.1)) cell_i2e = d['cell_index2electrode'] print 'cell_i2e=',cell_i2e last_electrode = cell_i2e[0] for k,e in enumerate(cell_i2e): if e != last_electrode: plt.axhline(k, c='k', alpha=0.5) last_electrode = e ytick_locs = list() for e in d['electrode_order']: elocs = np.array([k for k,el in enumerate(cell_i2e) if el == e]) emean = elocs.mean() ytick_locs.append(emean+0.5) plt.yticks(ytick_locs, d['electrode_order']) plt.ylabel('Electrode') plt.axvline(syllable_start, c='k', linestyle='--', linewidth=3.0, alpha=0.7) plt.axvline(syllable_end, c='k', linestyle='--', linewidth=3.0, alpha=0.7) """ # plot the biosound properties sprops = d['syllable_props'][syllable_index] aprops = USED_ACOUSTIC_PROPS vals = [sprops[a] for a in aprops] ax = plt.subplot(gs[:top_height, (left_width+5):]) plt.axhline(0, c='k') for k,(aprop,v) in enumerate(zip(aprops,vals)): bx = k rgb = np.array(ACOUSTIC_PROP_COLORS_BY_TYPE[aprop]).astype('int') clr_hex = '#%s' % "".join(map(chr, rgb)).encode('hex') plt.bar(bx, v, color=clr_hex, alpha=0.7) # plt.bar(range(len(aprops)), vals, color='#c0c0c0') plt.axis('tight') plt.ylim(-1.5, 1.5) plt.xticks(np.arange(len(aprops))+0.5, [ACOUSTIC_PROP_NAMES[aprop] for aprop in aprops], rotation=90) plt.ylabel('Z-score') # plot the LFP power spectra gs_i = top_height + top_bottom_sep gs_e = gs_i + middle_height + 1 f = d['psd_freq'] ax = plt.subplot(gs[gs_i:gs_e, (left_width+5):]) plt.imshow(sprops['lfp_psd'], interpolation='nearest', aspect='auto', origin='upper', extent=(f.min(), f.max(), nelectrodes, 0), cmap=viridis, vmin=-2., vmax=2.) plt.colorbar(label='Z-scored Log Power') plt.xlabel('Frequency (Hz)') plt.yticks(np.arange(nelectrodes)+0.5, d['electrode_order']) plt.ylabel('Electrode') fname = os.path.join(get_this_dir(), 'figure.svg') plt.savefig(fname, facecolor='w', edgecolor='none') plt.show()
def draw_figures(data_dir='/auto/tdrive/mschachter/data'): bird = 'GreBlu9508M' block = 'Site4' segment = 'Call1' hemi = 'L' fname = '%s_%s_%s_%s' % (bird, block, segment, hemi) exp_dir = os.path.join(data_dir, bird) preproc_file = os.path.join(exp_dir, 'preprocess', 'RNNPreprocess_%s.h5' % fname) rp = RNNPreprocessTransform.load(preproc_file) pred_file = os.path.join(exp_dir, 'rnn', 'LFPEnvelope_%s.h5' % fname) hf = h5py.File(pred_file, 'r') Ypred = np.array(hf['Ypred']) hf.close() assert Ypred.shape[0] == rp.U.shape[0] stim_id = 277 trial = 5 i = (rp.event_df.stim_id == stim_id) & (rp.event_df.trial == trial) assert i.sum() == 1 start_time = rp.event_df[i].start_time.values[0] end_time = rp.event_df[i].end_time.values[0] si = int(start_time*rp.sample_rate) ei = int(end_time * rp.sample_rate) spec = rp.U[si:ei, :].T spec_freq = rp.spec_freq spec_env = spec.sum(axis=0) spec_env /= spec_env.max() lfp = rp.Yraw[si:ei, :].T lfp_pred = Ypred[si:ei, :].T nt = spec.shape[1] t = np.arange(nt) / rp.sample_rate index2electrode = list(rp.index2electrode) electrode_order = ROSTRAL_CAUDAL_ELECTRODES_LEFT if hemi == 'R': electrode_order = ROSTRAL_CAUDAL_ELECTRODES_RIGHT fig = plt.figure(figsize=(23, 13), facecolor='w') gs = plt.GridSpec(100, 1) ax = plt.subplot(gs[:25, :]) spec_env *= (spec_freq.max() - spec_freq.min()) spec_env += spec_freq.min() plot_spectrogram(t, spec_freq, spec, ax=ax, ticks=True, fmax=8000., colormap='SpectroColorMap', colorbar=False) plt.plot(t, spec_env, 'k-', linewidth=5.0, alpha=0.7) plt.axis('tight') ax = plt.subplot(gs[30:, :]) nelectrodes = len(index2electrode) lfp_spacing = 5. for k in range(nelectrodes): e = electrode_order[nelectrodes-k-1] n = index2electrode.index(e) offset = k*lfp_spacing plt.plot(t, lfp[n, :] + offset, 'k-', alpha=0.7, linewidth=5.0) plt.plot(t, lfp_pred[n, :] + offset, 'r-', alpha=0.7, linewidth=5.0) plt.yticks([]) plt.axis('tight') plt.xlabel('Time (s)') plt.ylabel('LFP') fname = os.path.join(get_this_dir(), 'encoder_pred.svg') plt.savefig(fname, facecolor=fig.get_facecolor(), edgecolor='none') plt.show()
sound_lengths = (sound_offset - sound_onset) / fs_mic # in s if long_thresh > 0: long_sounds = np.squeeze(np.where(sound_lengths > long_thresh)) # in s else: long_sounds = np.squeeze(np.where(sound_lengths < -long_thresh)) # in s high_corrs = np.squeeze( np.where(np.asarray(max_corrs[template]) > corr_thresh)) long_high = common_elements(long_sounds, high_corrs) long_high_vocal = common_elements(long_sounds, nonplayback) for sound in long_high_vocal: sound_wav = mic[np.int(sound_onset[sound]):np.int(sound_offset[sound])] sound_t, sound_freq, sound_timefreq, sound_rms = spectrogram( sound_wav, fs_mic, spec_sample_rate=1000, freq_spacing=50) figure(1) plot_spectrogram(sound_t, sound_freq, sound_timefreq) pause(.2) close(1) for sound in long_sounds: sound_wav = mic[np.int(sound_onset[sound]):np.int(sound_offset[sound])] sound_t, sound_freq, sound_timefreq, sound_rms = spectrogram( sound_wav, fs_mic, spec_sample_rate=1000, freq_spacing=50) figure(1) plot_spectrogram(sound_t, sound_freq, sound_timefreq) pause(.1) close(1) fig = figure() ax = fig.add_subplot(111, projection='3d') plot(max_corrs[2][long_high_vocal], max_corrs[3][long_high_vocal],
def draw_figures(data_dir='/auto/tdrive/mschachter/data', bird='GreBlu9508M', output_dir='/auto/tdrive/mschachter/data/sounds'): spec_colormap() exp_dir = os.path.join(data_dir, bird) exp_file = os.path.join(exp_dir, '%s.h5' % bird) stim_file = os.path.join(exp_dir, 'stims.h5') exp = Experiment.load(exp_file, stim_file) bird = exp.bird_name all_stim_ids = list() # iterate through the segments and get the stim ids from each epoch table for seg in exp.get_all_segments(): etable = exp.get_epoch_table(seg) stim_ids = etable['id'].unique() all_stim_ids.extend(stim_ids) stim_ids = np.unique(all_stim_ids) stim_info = list() for stim_id in stim_ids: si = exp.stim_table['id'] == stim_id assert si.sum() == 1, "More than one stimulus defined for id=%d" % stim_id stype = exp.stim_table['type'][si].values[0] if stype == 'call': stype = exp.stim_table['callid'][si].values[0] # get sound pressure waveform sound = exp.sound_manager.reconstruct(stim_id) waveform = np.array(sound.squeeze()) sample_rate = float(sound.samplerate) stim_dur = len(waveform) / sample_rate stim_info.append( (stim_id, stype, sample_rate, waveform, stim_dur)) durations = np.array([x[-1] for x in stim_info]) max_dur = durations.max() min_dur = durations.min() max_fig_size = 15. min_fig_size = 5. for stim_id,stype,sample_rate,waveform,stim_dur in stim_info: fname = os.path.join(output_dir, '%s_stim_%d.wav' % (stype, stim_id)) print 'Writing %s...' % fname wavfile.write(fname, sample_rate, waveform) dfrac = (stim_dur - min_dur) / (max_dur - min_dur) fig_width = dfrac*(max_fig_size - min_fig_size) + min_fig_size spec_t,spec_freq,spec,rms = spectrogram(waveform, sample_rate, sample_rate, 136., min_freq=300, max_freq=8000, log=True, noise_level_db=80, rectify=True, cmplx=False) figsize = (fig_width, 5) fig = plt.figure(figsize=figsize) plot_spectrogram(spec_t, spec_freq, spec, colormap='SpectroColorMap', colorbar=False) plt.title('Stim %d: %s' % (stim_id, stype)) fname = os.path.join(output_dir, '%s_stim_%d.png' % (stype, stim_id)) plt.savefig(fname, facecolor='w') plt.close('all')