sw.plot_unit_probe_map(we, unit_ids=unit_ids) ############################################################################## # plot_unit_waveform_density_map() # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # # This is your best friend to check over merge unit_ids = sorting.unit_ids[:4] sw.plot_unit_waveform_density_map(we, unit_ids=unit_ids, max_channels=5) ############################################################################## # plot_amplitudes_distribution() # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ sw.plot_amplitudes_distribution(we) ############################################################################## # plot_amplitudes_timeseres() # ~~~~~~~~~~~~~~~~~~~~~~~~~~~ sw.plot_amplitudes_timeseries(we) ############################################################################## # plot_units_depth_vs_amplitude() # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ sw.plot_units_depth_vs_amplitude(we) plt.show()
def test_amplitudes_distribution(self): sw.plot_amplitudes_distribution(self._we) sw.plot_amplitudes_distribution(self._we, amplitudes=self._amplitudes)
def visualize_units(recording, recording_f, sorting, wf, templates, num_channels, file_name): wf2 = st.postprocessing.get_unit_waveforms(recording, sorting, ms_before=4, ms_after=0, verbose=True) color = cm.rainbow(np.linspace(0, 1, len(wf))) output_dir = "waveform_visualization/" + file_name + "/" if not os.path.exists(output_dir): os.mkdir(output_dir) fig, axs = plt.subplots(3, 2, constrained_layout=True) axe = axs.ravel() sw.plot_timeseries(recording_f, ax=axe[0]) for i in range(len(wf)): normalized = preprocessing.normalize(np.array(templates)[i][:, :]) axe[1].plot(normalized.T, label=i + 1, color=color[i]) sw.plot_rasters(sorting, ax=axe[2]) sw.plot_pca_features(recording, sorting, colormap='rainbow', nproj=3, max_spikes_per_unit=100, axes=axe[3:6]) legend = axe[1].legend(loc='lower right') fig.set_size_inches((8.5, 11), forward=False) # name = file_name.split("_") # # acc_1_04052016_kurocoppola_pre fig.suptitle(file_name) fig.savefig(output_dir + '_full_info.png', dpi=500) for idx in range(len(wf)): for j in range(num_channels): fig, axs = plt.subplots(4, 3, constrained_layout=True) axe = axs.ravel() normalized = preprocessing.normalize(wf[idx][:, j, :]) axe[2].plot(normalized.T, lw=0.3, alpha=0.3) normalized = preprocessing.normalize( np.array(templates)[idx][:, :]) axe[2].plot(normalized.T, lw=0.8, color='black') axe[0].plot(templates[idx].T, lw=0.8) for i in range(len(wf)): normalized = preprocessing.normalize( np.array(templates)[i][:, :]) if idx == i: axe[1].plot(normalized.T, label=i + 1) else: axe[1].plot(normalized.T, label=i + 1, alpha=0.3) values = randint(0, len(wf), 3) for i, val in enumerate(values): axe[3 + i].plot(wf2[idx][val, j, :].T) sw.plot_pca_features(recording, sorting, colormap='binary', figure=fig, nproj=3, axes=axe[6:9], max_spikes_per_unit=100) sw.plot_pca_features(recording, sorting, unit_ids=[idx], figure=fig, nproj=3, axes=axe[6:9], max_spikes_per_unit=100) sw.plot_isi_distribution(sorting, unit_ids=[idx + 1], bins=100, window=1, axes=axe[9:11]) sw.plot_amplitudes_distribution(recording, sorting, max_spikes_per_unit=300, unit_ids=[idx + 1], axes=axe[10:12]) sp = sorting.get_unit_spike_train(unit_id=idx + 1) axe[11].plot(sp) legend = axe[1].legend(loc='lower right', shadow=True) axe[0].set_title('Template') axe[2].set_title('Waveforms, template') axe[3].set_title('Random waveforms') axe[6].set_title('PCA component analysis') axe[9].set_title('ISI distribution') axe[10].set_title('Amplitude distribution') axe[11].set_title('Spike frame') fig.set_size_inches((8.5, 11), forward=False) fig.suptitle("File name: " + file_name + '\nChannel: ' + str(j + 1).zfill(2) + '\nUnit: ' + str(idx + 1).zfill(2)) fig.savefig(output_dir + file_name + '_ch' + str(j + 1).zfill(2) + '_u' + str(idx + 1).zfill(2) + '.png', dpi=500) plt.close('all')
def export_report(waveform_extractor, output_folder, remove_if_exists=False, format="png", show_figures=False, peak_sign='neg', **job_kwargs): """ Exports a SI spike sorting report. The report includes summary figures of the spike sorting output (e.g. amplitude distributions, unit localization and depth VS amplitude) as well as unit-specific reports, that include waveforms, templates, template maps, ISI distributions, and more. Parameters ---------- waveform_extractor: a WaveformExtractor or None If WaveformExtractor is provide then the compute is faster otherwise output_folder: str The output folder where the report files are saved remove_if_exists: bool If True and the output folder exists, it is removed format: str 'png' (default) or 'pdf' or any format handled by matplotlib peak_sign: 'neg' or 'pos' used to compute amplitudes and metrics show_figures: bool If True, figures are shown. If False (default), figures are closed after saving. {} """ we = waveform_extractor sorting = we.sorting unit_ids = sorting.unit_ids # lets matplotlib do this check svg is also cool # assert format in ["png", "pdf"], "'format' can be 'png' or 'pdf'" if we.is_extension('spike_amplitudes'): sac = we.load_extension('spike_amplitudes') amplitudes = sac.get_amplitudes(outputs='by_unit') else: amplitudes = st.compute_spike_amplitudes(we, peak_sign=peak_sign, outputs='by_unit', **job_kwargs) output_folder = Path(output_folder).absolute() if output_folder.is_dir(): if remove_if_exists: shutil.rmtree(output_folder) else: raise FileExistsError(f'{output_folder} already exists') output_folder.mkdir(parents=True, exist_ok=True) # unit list units = pd.DataFrame( index=unit_ids) # , columns=['max_on_channel_id', 'amplitude']) units.index.name = 'unit_id' units['max_on_channel_id'] = pd.Series( st.get_template_extremum_channel(we, peak_sign='neg', outputs='id')) units['amplitude'] = pd.Series( st.get_template_extremum_amplitude(we, peak_sign='neg')) units.to_csv(output_folder / 'unit list.csv', sep='\t') # metrics if we.is_extension('quality_metrics'): qmc = we.load_extension('quality_metrics') metrics = qmc._metrics else: # compute principal_components if not done if not we.is_extension('principal_components'): pca = st.compute_principal_components(we, load_if_exists=True, n_components=5, mode='by_channel_local') metrics = st.compute_quality_metrics(we) metrics.to_csv(output_folder / 'quality metrics.csv') unit_colors = sw.get_unit_colors(sorting) # global figures fig = plt.figure(figsize=(20, 10)) w = sw.plot_unit_localization(we, figure=fig, unit_colors=unit_colors) fig.savefig(output_folder / f'unit_localization.{format}') if not show_figures: plt.close(fig) fig, ax = plt.subplots(figsize=(20, 10)) sw.plot_units_depth_vs_amplitude(we, ax=ax, unit_colors=unit_colors) fig.savefig(output_folder / f'units_depth_vs_amplitude.{format}') if not show_figures: plt.close(fig) fig = plt.figure(figsize=(20, 10)) sw.plot_amplitudes_distribution(we, figure=fig, unit_colors=unit_colors) fig.savefig(output_folder / f'amplitudes_distribution.{format}') if not show_figures: plt.close(fig) # units units_folder = output_folder / 'units' units_folder.mkdir() for unit_id in unit_ids: fig = plt.figure( constrained_layout=False, figsize=(15, 7), ) sw.plot_unit_summary(we, unit_id, figure=fig) fig.suptitle(f'unit {unit_id}') fig.savefig(units_folder / f'{unit_id}.{format}') if not show_figures: plt.close(fig)
import spikeinterface.widgets as sw ############################################################################## # First, let's create a toy example with the `extractors` module: recording, sorting = se.example_datasets.toy_example(duration=10, num_channels=4, seed=0) ############################################################################## # plot_unit_waveforms() # ~~~~~~~~~~~~~~~~~~~~~~~~ w_wf = sw.plot_unit_waveforms(recording, sorting, max_num_waveforms=100) ############################################################################## # plot_amplitudes_distribution() # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ w_ampd = sw.plot_amplitudes_distribution(recording, sorting, max_num_waveforms=300) ############################################################################## # plot_amplitudes_timeseres() # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ w_ampt = sw.plot_amplitudes_timeseries(recording, sorting, max_num_waveforms=300) ############################################################################## # plot_features() # ~~~~~~~~~~~~~~~~~~~~~~~~ w_feat = sw.plot_features(recording, sorting, colormap='rainbow', nproj=3, max_num_waveforms=100)
recording, sorting = se.example_datasets.toy_example(duration=10, num_channels=4, seed=0) ############################################################################## # plot_unit_waveforms() # ~~~~~~~~~~~~~~~~~~~~~~~~ w_wf = sw.plot_unit_waveforms(recording, sorting, max_spikes_per_unit=100) ############################################################################## # plot_amplitudes_distribution() # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ w_ampd = sw.plot_amplitudes_distribution(recording, sorting, max_spikes_per_unit=300) ############################################################################## # plot_amplitudes_timeseres() # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ w_ampt = sw.plot_amplitudes_timeseries(recording, sorting, max_spikes_per_unit=300) ############################################################################## # plot_pca_features() # ~~~~~~~~~~~~~~~~~~~~~~~~ w_feat = sw.plot_pca_features(recording,