def test_multicomp_graph(self): msc = sc.compare_multiple_sorters([self._sorting, self._sorting, self._sorting]) sw.plot_multicomp_graph(msc, edge_cmap='viridis', node_cmap='rainbow', draw_labels=False) sw.plot_multicomp_agreement(msc) sw.plot_multicomp_agreement_by_sorter(msc) fig, axes = plt.subplots(len(msc.sorting_list), 1) sw.plot_multicomp_agreement_by_sorter(msc, axes=axes)
def test_compare_multiple_sorters(): # simple match sorting1, sorting2, sorting3 = make_sorting( [100, 200, 300, 400, 500, 600, 700, 800, 900], [0, 1, 2, 0, 1, 2, 0, 1, 2], [101, 201, 301, 400, 501, 598, 702, 801, 899, 1000, 1100, 2000, 3000], [0, 1, 2, 0, 1, 2, 0, 1, 2, 3, 3, 4, 4], [ 101, 201, 301, 400, 500, 600, 700, 800, 900, 1000, 1100, 2000, 3000, 3100, 3200, 3300 ], [0, 1, 2, 0, 1, 2, 0, 1, 2, 3, 3, 4, 4, 5, 5, 5], ) msc = compare_multiple_sorters([sorting1, sorting2, sorting3], verbose=True) msc_shuffle = compare_multiple_sorters([sorting3, sorting1, sorting2]) agr = msc._do_agreement_matrix() agr_shuffle = msc_shuffle._do_agreement_matrix() print(agr) print(agr_shuffle) assert len( msc.get_agreement_sorting( minimum_agreement_count=3).get_unit_ids()) == 3 assert len( msc.get_agreement_sorting( minimum_agreement_count=2).get_unit_ids()) == 5 assert len(msc.get_agreement_sorting().get_unit_ids()) == 6 assert len(msc.get_agreement_sorting(minimum_agreement_count=3).get_unit_ids()) == \ len(msc_shuffle.get_agreement_sorting(minimum_agreement_count=3).get_unit_ids()) assert len(msc.get_agreement_sorting(minimum_agreement_count=2).get_unit_ids()) == \ len(msc_shuffle.get_agreement_sorting(minimum_agreement_count=2).get_unit_ids()) assert len(msc.get_agreement_sorting().get_unit_ids()) == len( msc_shuffle.get_agreement_sorting().get_unit_ids()) agreement_2 = msc.get_agreement_sorting(minimum_agreement_count=2, minimum_agreement_count_only=True) assert np.all([agreement_2.get_unit_property(u, 'agreement_number')] == 2 for u in agreement_2.get_unit_ids()) msc.save_to_folder('saved_multisorting_comparison') msc = MultiSortingComparison.load_from_folder( 'saved_multisorting_comparison')
def compare_sorters(sort1, sort2): comp_KL_MS4 = sc.compare_two_sorters(sorting1=sort1, sorting2=sort2) mapped_units = comp_KL_MS4.get_mapped_sorting1().get_mapped_unit_ids() print('Klusta units:', sort1.get_unit_ids()) print('Mapped Mountainsort4 units:', mapped_units) comp_multi = sc.compare_multiple_sorters(sorting_list=[sort1, sort2], name_list=['klusta', 'ms4']) sorting_agreement = comp_multi.get_agreement_sorting(minimum_matching=2) print('Units in agreement between Klusta and Mountainsort4:', sorting_agreement.get_unit_ids()) w_multi = sw.plot_multicomp_graph(comp_multi) plt.show()
duration=20, seed=0) ############################################################################# # Then run 3 spike sorters and compare their ouput. sorting_KL = sorters.run_klusta(recording) sorting_MS4 = sorters.run_mountainsort4(recording) sorting_TDC = sorters.run_tridesclous(recording) ############################################################################# # Compare multiple spike sorter outputs # ------------------------------------------- mcmp = sc.compare_multiple_sorters( sorting_list=[sorting_KL, sorting_MS4, sorting_TDC], name_list=['KL', 'MS4', 'TDC'], verbose=True) ############################################################################# # The multiple sorters comparison internally computes pairwise comparison, # that can be accessed as follows: print(mcmp.comparisons[0].sorting1, mcmp.comparisons[0].sorting2) mcmp.comparisons[0].get_mapped_sorting1().get_mapped_unit_ids() ############################################################################# print(mcmp.comparisons[1].sorting1, mcmp.comparisons[1].sorting2) mcmp.comparisons[0].get_mapped_sorting1().get_mapped_unit_ids() ############################################################################# # The global multi caomparison can be visualized with this graph
sorting_curated_snr = st.curation.threshold_snr(sorting_KL, recording, threshold=5) snrs_above = st.validation.compute_snrs(sorting_curated_snr, recording_cmr) print('Curated SNR', snrs_above) ############################################################################## # The final part of this tutorial deals with comparing spike sorting outputs. # We can either (1) compare the spike sorting results with the ground-truth sorting :code:`sorting_true`, (2) compare # the output of two (Klusta and Mountainsor4), or (3) compare the output of multiple sorters: comp_gt_KL = sc.compare_sorter_to_ground_truth(gt_sorting=sorting_true, tested_sorting=sorting_KL) comp_KL_MS4 = sc.compare_two_sorters(sorting1=sorting_KL, sorting2=sorting_MS4) comp_multi = sc.compare_multiple_sorters( sorting_list=[sorting_MS4, sorting_KL], name_list=['klusta', 'ms4']) ############################################################################## # When comparing with a ground-truth sorting extractor (1), you can get the sorting performance and plot a confusion # matrix comp_gt_KL.get_performance() w_conf = sw.plot_confusion_matrix(comp_gt_KL) ############################################################################## # When comparing two sorters (2), we can see the matching of units between sorters. For example, this is how to extract # the unit ids of Mountainsort4 (sorting2) mapped to the units of Klusta (sorting1). Units which are not mapped has -1 # as unit id. mapped_units = comp_KL_MS4.get_mapped_sorting1().get_mapped_unit_ids()
def auto(recording_folder): os.chdir(recording_folder) #If sorter has already been run skip it. subfolders = [f.name for f in os.scandir(recording_folder) if f.is_dir()] if ('phy_AGR' in subfolders) or ('phy_MS4' in subfolders): print('Tetrode ' + recording_folder.split('_')[-1] + ' was previously sorted. Skipping') return """ Adding Matlab-based sorters to path """ #IronClust iron_path = "~/Documents/SpikeSorting/ironclust" ss.IronClustSorter.set_ironclust_path(os.path.expanduser(iron_path)) ss.IronClustSorter.ironclust_path #HDSort #ss.HDSortSorter.set_hdsort_path('/home/adrian/Documents/SpikeSorting/HDsort') #ss.HDSortSorter.hdsort_path #Waveclus #ss.WaveClusSorter.set_waveclus_path('/home/adrian/Documents/SpikeSorting/wave_clus') #ss.WaveClusSorter.waveclus_path #Check if the recording has been preprocessed before and load it. # Else proceed with preprocessing. arr = os.listdir() #Load .continuous files recording = se.OpenEphysRecordingExtractor(recording_folder) channel_ids = recording.get_channel_ids() fs = recording.get_sampling_frequency() num_chan = recording.get_num_channels() print('Channel ids:', channel_ids) print('Sampling frequency:', fs) print('Number of channels:', num_chan) #!cat tetrode9.prb #Asks for prb file # os.system('cat /home/adrian/Documents/SpikeSorting/Adrian_test_data/Irene_data/test_without_zero_main_channels/Tetrode_9_CH/tetrode9.prb') #recording_prb = recording.load_probe_file('/home/adrian/Documents/SpikeSorting/Adrian_test_data/Irene_data/test_without_zero_main_channels/Tetrode_9_CH/tetrode.prb') recording_prb = recording.load_probe_file('tetrode.prb') print('Channels after loading the probe file:', recording_prb.get_channel_ids()) print('Channel groups after loading the probe file:', recording_prb.get_channel_groups()) #For testing only: Reduce recording. #recording_prb = se.SubRecordingExtractor(recording_prb, start_frame=100*fs, end_frame=420*fs) #Bandpass filter recording_cmr = st.preprocessing.bandpass_filter(recording_prb, freq_min=300, freq_max=6000) recording_cache = se.CacheRecordingExtractor(recording_cmr) print(recording_cache.get_channel_ids()) print(recording_cache.get_channel_groups()) print(recording_cache.get_num_frames() / recording_cache.get_sampling_frequency()) #View installed sorters #ss.installed_sorters() #mylist = [f for f in glob.glob("*.txt")] #%% Run all channels. There are only a single tetrode channels anyway. #Create sub recording to avoid saving whole recording.Requirement from NWB to allow saving sorters data. recording_sub = se.SubRecordingExtractor(recording_cache, start_frame=200 * fs, end_frame=320 * fs) Sorters2Compare = [] Sorters2CompareLabel = [] SortersCount = [] #Amount of detections per sorter #Klusta if 'sorting_KL_all.nwb' in arr: print('Loading Klusta') sorting_KL_all = se.NwbSortingExtractor('sorting_KL_all.nwb') if not (not (sorting_KL_all.get_unit_ids())): Sorters2Compare.append(sorting_KL_all) Sorters2CompareLabel.append('KL') else: t = time.time() sorting_KL_all = ss.run_klusta(recording_cache, output_folder='results_all_klusta', delete_output_folder=True) print('Found', len(sorting_KL_all.get_unit_ids()), 'units') time.time() - t #Save Klusta se.NwbRecordingExtractor.write_recording(recording_sub, 'sorting_KL_all.nwb') se.NwbSortingExtractor.write_sorting(sorting_KL_all, 'sorting_KL_all.nwb') if not (not (sorting_KL_all.get_unit_ids())): Sorters2Compare.append(sorting_KL_all) Sorters2CompareLabel.append('KL') SortersCount.append(len(sorting_KL_all.get_unit_ids())) #Ironclust if 'sorting_IC_all.nwb' in arr: print('Loading Ironclust') sorting_IC_all = se.NwbSortingExtractor('sorting_IC_all.nwb') if not (not (sorting_IC_all.get_unit_ids())): Sorters2Compare.append(sorting_IC_all) Sorters2CompareLabel.append('IC') SortersCount.append(len(sorting_IC_all.get_unit_ids())) else: try: t = time.time() sorting_IC_all = ss.run_ironclust(recording_cache, output_folder='results_all_ic', delete_output_folder=True, filter=False) print('Found', len(sorting_IC_all.get_unit_ids()), 'units') time.time() - t #Save IC se.NwbRecordingExtractor.write_recording(recording_sub, 'sorting_IC_all.nwb') se.NwbSortingExtractor.write_sorting(sorting_IC_all, 'sorting_IC_all.nwb') if not (not (sorting_IC_all.get_unit_ids())): Sorters2Compare.append(sorting_IC_all) Sorters2CompareLabel.append('IC') SortersCount.append(len(sorting_IC_all.get_unit_ids())) except: print('Ironclust has failed') # #Waveclust # if 'sorting_waveclus_all.nwb' in arr: # print('Loading waveclus') # sorting_waveclus_all=se.NwbSortingExtractor('sorting_waveclus_all.nwb'); # if not(not(sorting_waveclus_all.get_unit_ids())): # Sorters2Compare.append(sorting_waveclus_all); # Sorters2CompareLabel.append('Waveclus'); # SortersCount.append(len(sorting_waveclus_all.get_unit_ids())) # else: # t = time.time() # try: # sorting_waveclus_all = ss.run_waveclus(recording_cache, output_folder='results_all_waveclus',delete_output_folder=True) # print('Found', len(sorting_waveclus_all.get_unit_ids()), 'units') # time.time() - t # #Save waveclus # se.NwbRecordingExtractor.write_recording(recording_sub, 'sorting_waveclus_all.nwb') # se.NwbSortingExtractor.write_sorting(sorting_waveclus_all, 'sorting_waveclus_all.nwb') # if not(not(sorting_waveclus_all.get_unit_ids())): # Sorters2Compare.append(sorting_waveclus_all); # Sorters2CompareLabel.append('Waveclus'); # SortersCount.append(len(sorting_waveclus_all.get_unit_ids())) # except: # print('Waveclus cannot be run') #Herdingspikes if 'sorting_herdingspikes_all.nwb' in arr: print('Loading herdingspikes') sorting_herdingspikes_all = se.NwbSortingExtractor( 'sorting_herdingspikes_all.nwb') if not (not (sorting_herdingspikes_all.get_unit_ids())): Sorters2Compare.append(sorting_herdingspikes_all) Sorters2CompareLabel.append('HS') SortersCount.append(len(sorting_herdingspikes_all.get_unit_ids())) else: try: t = time.time() sorting_herdingspikes_all = ss.run_herdingspikes( recording_cache, output_folder='results_all_herdingspikes', delete_output_folder=True) print('Found', len(sorting_herdingspikes_all.get_unit_ids()), 'units') time.time() - t #Save herdingspikes se.NwbRecordingExtractor.write_recording( recording_sub, 'sorting_herdingspikes_all.nwb') try: se.NwbSortingExtractor.write_sorting( sorting_herdingspikes_all, 'sorting_herdingspikes_all.nwb') except TypeError: print("No units detected. Can't save HerdingSpikes") os.remove("sorting_herdingspikes_all.nwb") if not (not (sorting_herdingspikes_all.get_unit_ids())): Sorters2Compare.append(sorting_herdingspikes_all) Sorters2CompareLabel.append('HS') SortersCount.append(len(sorting_herdingspikes_all.get_unit_ids())) except: print('Herdingspikes has failed') try: rmtree("results_all_herdingspikes") except: print('Removed leftover herdingspikes files') try: rmtree("results_all_herdingspikes") except: print('Removed leftover herdingspikes files') #Mountainsort4 if 'sorting_mountainsort4_all.nwb' in arr: print('Loading mountainsort4') sorting_mountainsort4_all = se.NwbSortingExtractor( 'sorting_mountainsort4_all.nwb') if not (not (sorting_mountainsort4_all.get_unit_ids())): Sorters2Compare.append(sorting_mountainsort4_all) Sorters2CompareLabel.append('MS4') else: t = time.time() sorting_mountainsort4_all = ss.run_mountainsort4( recording_cache, output_folder='results_all_mountainsort4', delete_output_folder=True, filter=False) print('Found', len(sorting_mountainsort4_all.get_unit_ids()), 'units') time.time() - t #Save mountainsort4 se.NwbRecordingExtractor.write_recording( recording_sub, 'sorting_mountainsort4_all.nwb') se.NwbSortingExtractor.write_sorting(sorting_mountainsort4_all, 'sorting_mountainsort4_all.nwb') if not (not (sorting_mountainsort4_all.get_unit_ids())): Sorters2Compare.append(sorting_mountainsort4_all) Sorters2CompareLabel.append('MS4') SortersCount.append(len(sorting_mountainsort4_all.get_unit_ids())) #Spykingcircus if 'sorting_spykingcircus_all.nwb' in arr: print('Loading spykingcircus') sorting_spykingcircus_all = se.NwbSortingExtractor( 'sorting_spykingcircus_all.nwb') if not (not (sorting_spykingcircus_all.get_unit_ids())): Sorters2Compare.append(sorting_spykingcircus_all) Sorters2CompareLabel.append('SC') SortersCount.append(len(sorting_spykingcircus_all.get_unit_ids())) else: try: t = time.time() sorting_spykingcircus_all = ss.run_spykingcircus( recording_cache, output_folder='results_all_spykingcircus', delete_output_folder=True, filter=False) print('Found', len(sorting_spykingcircus_all.get_unit_ids()), 'units') time.time() - t #Save sorting_spykingcircus se.NwbRecordingExtractor.write_recording( recording_sub, 'sorting_spykingcircus_all.nwb') se.NwbSortingExtractor.write_sorting( sorting_spykingcircus_all, 'sorting_spykingcircus_all.nwb') if not (not (sorting_spykingcircus_all.get_unit_ids())): Sorters2Compare.append(sorting_spykingcircus_all) Sorters2CompareLabel.append('SC') SortersCount.append(len(sorting_spykingcircus_all.get_unit_ids())) except: print('Spykingcircus has failed') #Tridesclous if 'sorting_tridesclous_all.nwb' in arr: print('Loading tridesclous') try: sorting_tridesclous_all = se.NwbSortingExtractor( 'sorting_tridesclous_all.nwb') except AttributeError: print("No units detected. Can't load Tridesclous so will run it.") t = time.time() sorting_tridesclous_all = ss.run_tridesclous( recording_cache, output_folder='results_all_tridesclous', delete_output_folder=True) print('Found', len(sorting_tridesclous_all.get_unit_ids()), 'units') time.time() - t os.remove("sorting_tridesclous_all.nwb") #Save sorting_tridesclous se.NwbRecordingExtractor.write_recording( recording_sub, 'sorting_tridesclous_all.nwb') se.NwbSortingExtractor.write_sorting( sorting_tridesclous_all, 'sorting_tridesclous_all.nwb') if not (not (sorting_tridesclous_all.get_unit_ids())): Sorters2Compare.append(sorting_tridesclous_all) Sorters2CompareLabel.append('TRI') SortersCount.append(len(sorting_tridesclous_all.get_unit_ids())) else: try: t = time.time() sorting_tridesclous_all = ss.run_tridesclous( recording_cache, output_folder='results_all_tridesclous', delete_output_folder=True) print('Found', len(sorting_tridesclous_all.get_unit_ids()), 'units') time.time() - t #Save sorting_tridesclous se.NwbRecordingExtractor.write_recording( recording_sub, 'sorting_tridesclous_all.nwb') se.NwbSortingExtractor.write_sorting( sorting_tridesclous_all, 'sorting_tridesclous_all.nwb') if not (not (sorting_tridesclous_all.get_unit_ids())): Sorters2Compare.append(sorting_tridesclous_all) Sorters2CompareLabel.append('TRI') SortersCount.append(len(sorting_tridesclous_all.get_unit_ids())) except: print('Tridesclous failed') try: rmtree("results_all_tridesclous") except: print('Removed leftover tridesclous files') #Consensus based curation. print(Sorters2CompareLabel) print('Comparing sorters agreement. Please wait...') mcmp = sc.compare_multiple_sorters(Sorters2Compare, Sorters2CompareLabel) w = sw.plot_multicomp_agreement_by_sorter(mcmp) # plt.show() plt.savefig('consensus.pdf', bbox_inches='tight') plt.savefig('consensus.png', bbox_inches='tight') plt.close() w = sw.plot_multicomp_agreement(mcmp) plt.savefig('consensus_spikes.pdf', bbox_inches='tight') plt.savefig('consensus_spikes.png', bbox_inches='tight') plt.close() # #Use amount of sorters which give a value closest to 10 units. # agreed_units=[]; # for x in [1,2,3,4,5]: # agreement_sorting = mcmp.get_agreement_sorting(minimum_agreement_count=x) # agreed_units.append(len(agreement_sorting.get_unit_ids())); # print(agreed_units) # print(agreed_units.index(min(agreed_units, key=lambda x:abs(x-10)))+1) # agreement_sorting = mcmp.get_agreement_sorting(minimum_agreement_count= # agreed_units.index(min(agreed_units, key=lambda x:abs(x-10)))+1); # Use units with at least 2 sorters agreeing. agreement_sorting = mcmp.get_agreement_sorting(minimum_agreement_count=2) print(agreement_sorting.get_unit_ids()) phy_folder_name = 'phy_AGR' if not (agreement_sorting.get_unit_ids()): #If there is no agreement. # print('No consensus. Finding sorter with closest to expected amount of units') # print(Sorters2CompareLabel[SortersCount.index(min(SortersCount, key=lambda x:abs(x-10)))]) # agreement_sorting=Sorters2Compare[SortersCount.index(min(SortersCount, key=lambda x:abs(x-10)))] print('No consensus. Using detections from MountainSort4') agreement_sorting = sorting_mountainsort4_all phy_folder_name = 'phy_MS4' st.postprocessing.export_to_phy(recording_cache, agreement_sorting, output_folder=phy_folder_name, grouping_property='group', verbose=True, recompute_info=True) # se.NwbRecordingExtractor.write_recording(recording_sub, 'agreement_sorting.nwb') # se.NwbSortingExtractor.write_sorting(agreement_sorting, 'agreement_sorting.nwb') # os.system('phy template-gui phy_AGR/params.py') # sorting_phy_curated = se.PhySortingExtractor('phy_AGR/', exclude_cluster_groups=['noise']); # se.NwbRecordingExtractor.write_recording(recording_sub, 'consensus_phy_curated.nwb') # se.NwbSortingExtractor.write_sorting(sorting_phy_curated, 'consensus_phy_curated.nwb') w_wf = sw.plot_unit_templates(sorting=agreement_sorting, recording=recording_cache) plt.savefig('unit_templates.pdf', bbox_inches='tight') plt.savefig('unit_templates.png', bbox_inches='tight') plt.close() #Access unit ID and firing rate. os.chdir(phy_folder_name) spike_times = np.load('spike_times.npy') spike_clusters = np.load('spike_clusters.npy') #Create a list with the unit IDs some_list = np.unique(spike_clusters) some_list = some_list.tolist() #Bin data in bins of 25ms #45 minutes bins = np.arange(start=0, stop=45 * 60 * fs + 1, step=.025 * fs) NData = np.zeros([np.unique(spike_clusters).shape[0], bins.shape[0] - 1]) cont = 0 for x in some_list: ind = (spike_clusters == x) fi = spike_times[ind] inds = np.histogram(fi, bins=bins) inds1 = inds[0] NData[cont, :] = inds1 cont = cont + 1 #Save activation matrix os.chdir("..") a = os.path.split(os.getcwd())[1] np.save('actmat_auto_' + a.split('_')[1], NData) np.save('unit_id_auto_' + a.split('_')[1], some_list)
for num in range(len(Sorters2CompareLabel)): i=Sorters2CompareLabel[num]; # print(i) if 'phy_'+i in subfolders: sorting_curated = se.PhySortingExtractor('phy_'+i+'/', exclude_cluster_groups=['noise','mua']); if not sorting_curated.get_unit_ids(): Sorters2label.remove(i) else: Sorters2Compare.append(sorting_curated); #Consensus based curation. print(Sorters2label) print('Comparing sorters agreement. Please wait...') mcmp = sc.compare_multiple_sorters(Sorters2Compare, Sorters2label) w = sw.plot_multicomp_agreement_by_sorter(mcmp) plt.savefig('consensus_curation.pdf', bbox_inches='tight'); plt.savefig('consensus_curation.png', bbox_inches='tight'); plt.close() w = sw.plot_multicomp_agreement(mcmp) plt.savefig('consensus_curation_spikes.pdf', bbox_inches='tight'); plt.savefig('consensus_curation_spikes.png', bbox_inches='tight'); plt.close() #Consider at least 2 sorters agreeing. agreement_sorting=mcmp.get_agreement_sorting(minimum_agreement_count=2);
keep_unit_ids = keep_mask[keep_mask].index.values print(keep_unit_ids) curated_sorting = sorting_TDC.select_units(keep_unit_ids) print(curated_sorting) ############################################################################## # The final part of this tutorial deals with comparing spike sorting outputs. # We can either (1) compare the spike sorting results with the ground-truth # sorting :code:`sorting_true`, (2) compare the output of two (HerdingSpikes # and Tridesclous), or (3) compare the output of multiple sorters: comp_gt_TDC = sc.compare_sorter_to_ground_truth(gt_sorting=sorting_true, tested_sorting=sorting_TDC) comp_TDC_HS = sc.compare_two_sorters(sorting1=sorting_TDC, sorting2=sorting_HS) comp_multi = sc.compare_multiple_sorters(sorting_list=[sorting_TDC, sorting_HS], name_list=['tdc', 'hs']) ############################################################################## # When comparing with a ground-truth sorting extractor (1), you can get the sorting performance and plot a confusion # matrix comp_gt_TDC.get_performance() w_conf = sw.plot_confusion_matrix(comp_gt_TDC) w_agr = sw.plot_agreement_matrix(comp_gt_TDC) ############################################################################## # When comparing two sorters (2), we can see the matching of units between sorters. # Units which are not matched has -1 as unit id: comp_TDC_HS.hungarian_match_12
chance_score=0.1, well_detected_score=0.1, exhaustive_gt=True) w_comp_SP = sw.plot_confusion_matrix(comp_SP, count_text=True) plt.show() #Computing some metrics for benchmarking-agreement matrix sw.plot_agreement_matrix(comp_MATLAB, ordered=True, count_text=True) perf_MATLAB = comp_MATLAB.get_performance() plt.show() print(perf_MATLAB) #comparing the sorting algos #We will try to compare all the three sorters mcmp = sc.compare_multiple_sorters( sorting_list=[sortingPipeline, sorting_MS4, sorting_SP], name_list=['Our', 'MS4', 'SP'], verbose=True) sw.plot_multicomp_graph(mcmp) plt.show() #Pairwise cmp_MS4_Our = sc.compare_two_sorters(sorting1=sorting_MS4, sorting2=sortingPipeline, sorting1_name='MS4', sorting2_name='Our') sw.plot_agreement_matrix(cmp_MS4_Our, ordered=True, count_text=True) plt.show() cmp_SP_Our = sc.compare_two_sorters(sorting1=sorting_SP,
# example signal-to-noise ratio. Quality metrics can be computed using the :code:`toolkit.validation` submodule import spikeinterface.toolkit as st snrs = st.validation.compute_snrs(sorting_true, recording, save_as_property=True) w_perf = sw.plot_sorting_performance(comp_MS4, property_name='snr', metric='accuracy') ############################################################################## # Widgets using MultiSortingComparison # ------------------------------------- # # We can also compare all three SortingExtractor objects, obtaining a :code:`MultiSortingComparison` object. multicomp = sc.compare_multiple_sorters( [sorting_true, sorting_MS4, sorting_KL]) ############################################################################## # plot_multicomp_graph() # ~~~~~~~~~~~~~~~~~~~~~~~~~~ w_multi = sw.plot_multicomp_graph(multicomp, edge_cmap='coolwarm', node_cmap='viridis', draw_labels=False, colorbar=True)