def test_export_to_phy():
repo = 'https://gin.g-node.org/NeuralEnsemble/ephy_testing_data'
remote_path = 'mearec/mearec_test_10s.h5'
local_path = download_dataset(repo=repo,
remote_path=remote_path,
local_folder=None)
recording = se.MEArecRecordingExtractor(local_path)
sorting = se.MEArecSortingExtractor(local_path)
waveform_folder = Path('waveforms')
output_folder = Path('phy_output')
for f in (waveform_folder, output_folder):
if f.is_dir():
shutil.rmtree(f)
waveform_extractor = extract_waveforms(recording, sorting, waveform_folder)
export_to_phy(recording,
sorting,
output_folder,
waveform_extractor,
compute_pc_features=True,
compute_amplitudes=True,
max_channels_per_template=8,
n_jobs=1,
chunk_size=10000,
progress_bar=True)
def test_get_unit_amplitudes():
repo = 'https://gin.g-node.org/NeuralEnsemble/ephy_testing_data'
remote_path = 'mearec/mearec_test_10s.h5'
local_path = download_dataset(repo=repo,
remote_path=remote_path,
local_folder=None)
recording = se.MEArecRecordingExtractor(local_path)
sorting = se.MEArecSortingExtractor(local_path)
we = extract_waveforms(recording,
sorting,
'mearec_waveforms',
ms_before=1.,
ms_after=2.,
max_spikes_per_unit=500,
n_jobs=1,
chunk_size=30000,
load_if_exists=True)
amplitudes = get_unit_amplitudes(we,
peak_sign='neg',
outputs='concatenated',
chunk_size=10000,
n_jobs=1)
# print(amplitudes)
amplitudes = get_unit_amplitudes(we,
peak_sign='neg',
outputs='by_units',
chunk_size=10000,
n_jobs=1)
def load_data(filepath):
'''
Parameters
-----------
filepath: str
Returns
-----------
prep_recording: RecordingExtractor
preprocessed RecordingExtractor
sorting_GT: SortingExtractor
'''
recording = se.MEArecRecordingExtractor(filepath)
sorting_GT = se.MEArecSortingExtractor(filepath)
# recording info
fs = recording.get_sampling_frequency()
channel_ids = recording.get_channel_ids()
channel_loc = recording.get_channel_locations()
num_frames = recording.get_num_frames()
duration = recording.frame_to_time(num_frames)
print(f'Sampling frequency:{fs}')
print(f'Channel ids:{channel_ids}')
print(f'channel location:{channel_loc}')
print(f'frame num:{num_frames}')
print(f'recording duration:{duration}')
# sorting_GT info
unit_ids = sorting_GT.get_unit_ids()
print(f'unit ids:{unit_ids}')
return recording, sorting_GT
def test_get_unit_colors():
local_path = download_dataset(remote_path='mearec/mearec_test_10s.h5')
rec = se.MEArecRecordingExtractor(local_path)
sorting = se.MEArecSortingExtractor(local_path)
colors = get_unit_colors(sorting)
print(colors)
def generate_a_dataset(self, config:dict=None):
"""
Generate a dataset (recording, sorting_true) with parameter from config file.
TODO: currently, the config file is out-of-operation.
"""
# return se.example_datasets.toy_example(num_channels=10, duration=50)
recording = se.MEArecRecordingExtractor(config['file_path'])
sorting_true = se.MEArecSortingExtractor(config['file_path'])
return recording, sorting_true
def test_compute_correlograms():
repo = 'https://gin.g-node.org/NeuralEnsemble/ephy_testing_data'
remote_path = 'mearec/mearec_test_10s.h5'
local_path = download_dataset(repo=repo,
remote_path=remote_path,
local_folder=None)
# ~ recording = se.MEArecRecordingExtractor(local_path)
sorting = se.MEArecSortingExtractor(local_path)
unit_ids = sorting.unit_ids
sorting2 = sorting.select_units(unit_ids[:3])
correlograms, bins = compute_correlograms(sorting2)
def setUp(self):
#~ self._rec, self._sorting = se.toy_example(num_channels=10, duration=10, num_segments=1)
#~ self._rec = self._rec.save()
#~ self._sorting = self._sorting.save()
local_path = download_dataset(remote_path='mearec/mearec_test_10s.h5')
self._rec = se.MEArecRecordingExtractor(local_path)
self._sorting = se.MEArecSortingExtractor(local_path)
self.num_units = len(self._sorting.get_unit_ids())
# self._we = extract_waveforms(self._rec, self._sorting, './toy_example', load_if_exists=True)
self._we = extract_waveforms(self._rec, self._sorting, './mearec_test', load_if_exists=True)
self._amplitudes = st.get_spike_amplitudes(self._we, peak_sign='neg', outputs='by_unit')
self._gt_comp = sc.compare_sorter_to_ground_truth(self._sorting, self._sorting)
def test_export_to_phy_by_sparsity():
repo = 'https://gin.g-node.org/NeuralEnsemble/ephy_testing_data'
remote_path = 'mearec/mearec_test_10s.h5'
local_path = download_dataset(repo=repo,
remote_path=remote_path,
local_folder=None)
recording = se.MEArecRecordingExtractor(local_path)
sorting = se.MEArecSortingExtractor(local_path)
waveform_folder = Path('waveforms')
output_folder_radius = Path('phy_output_radius')
output_folder_thr = Path('phy_output_thr')
for f in (waveform_folder, output_folder_radius, output_folder_thr):
if f.is_dir():
shutil.rmtree(f)
waveform_extractor = extract_waveforms(recording, sorting, waveform_folder)
export_to_phy(waveform_extractor,
output_folder_radius,
compute_pc_features=True,
compute_amplitudes=True,
max_channels_per_template=None,
sparsity_dict=dict(method="radius", radius_um=50),
n_jobs=1,
chunk_size=10000,
progress_bar=True)
template_ind = np.load(output_folder_radius / "template_ind.npy")
# templates have different shapes!
assert -1 in template_ind
export_to_phy(waveform_extractor,
output_folder_thr,
compute_pc_features=True,
compute_amplitudes=True,
max_channels_per_template=None,
sparsity_dict=dict(method="threshold", threshold=2),
n_jobs=1,
chunk_size=10000,
progress_bar=True)
template_ind = np.load(output_folder_thr / "template_ind.npy")
# templates have different shapes!
assert -1 in template_ind
def test_compute_spike_amplitudes_parallel():
repo = 'https://gin.g-node.org/NeuralEnsemble/ephy_testing_data'
remote_path = 'mearec/mearec_test_10s.h5'
local_path = download_dataset(repo=repo,
remote_path=remote_path,
local_folder=None)
recording = se.MEArecRecordingExtractor(local_path)
sorting = se.MEArecSortingExtractor(local_path)
folder = Path('mearec_waveforms_all')
we = extract_waveforms(recording,
sorting,
folder,
ms_before=1.,
ms_after=2.,
max_spikes_per_unit=None,
n_jobs=1,
chunk_size=30000,
load_if_exists=True)
amplitudes1 = compute_spike_amplitudes(we,
peak_sign='neg',
load_if_exists=False,
outputs='concatenated',
chunk_size=10000,
n_jobs=1)
# TODO : fix multi processing for spike amplitudes!!!!!!!
amplitudes2 = compute_spike_amplitudes(we,
peak_sign='neg',
load_if_exists=False,
outputs='concatenated',
chunk_size=10000,
n_jobs=2)
assert np.array_equal(amplitudes1[0], amplitudes2[0])
import spikeinterface as si
import spikeinterface.extractors as se
import spikeinterface.toolkit as st
import spikeinterface.sorters as ss
##############################################################################
# First, let's download a simulated dataset
# on the repo 'https://gin.g-node.org/NeuralEnsemble/ephy_testing_data'
#
# Let's imagine that that sorting is in fact the output of a sorters.
#
local_path = si.download_dataset(remote_path='mearec/mearec_test_10s.h5')
recording = se.MEArecRecordingExtractor(local_path)
sorting = se.MEArecSortingExtractor(local_path)
print(recording)
print(sorting)
##############################################################################
# Firt, we extractor waveforms and compute PC on it.
folder = 'waveforms_mearec'
we = si.extract_waveforms(recording, sorting, folder,
load_if_exists=True,
ms_before=1, ms_after=2., max_spikes_per_unit=500,
n_jobs=1, chunk_size=30000)
print(we)
pc = st.compute_principal_components(we, load_if_exists=True,
n_components=3, mode='by_channel_local')
############################################################################## # Read MEArec give 2 object recording, sorting = se.read_mearec(mearec_folder_path) print(recording) print(type(recording)) print() print(sorting) print(type(sorting)) ############################################################################## # This equivalent to do this recording = se.MEArecRecordingExtractor(mearec_folder_path) sorting = se.MEArecSortingExtractor(mearec_folder_path) ############################################################################## # recording and sorting object can be plot quickly with the widgets submodule import spikeinterface.widgets as sw w_ts = sw.plot_timeseries(recording, time_range=(0, 5)) w_rs = sw.plot_rasters(sorting, time_range=(0, 5)) plt.show()
def _loading_sorting(file_path):
return se.MEArecSortingExtractor(file_path)
def test_compute_spike_amplitudes():
repo = 'https://gin.g-node.org/NeuralEnsemble/ephy_testing_data'
remote_path = 'mearec/mearec_test_10s.h5'
local_path = download_dataset(repo=repo,
remote_path=remote_path,
local_folder=None)
recording = se.MEArecRecordingExtractor(local_path)
sorting = se.MEArecSortingExtractor(local_path)
folder = Path('mearec_waveforms')
we = extract_waveforms(recording,
sorting,
folder,
ms_before=1.,
ms_after=2.,
max_spikes_per_unit=500,
n_jobs=1,
chunk_size=30000,
load_if_exists=False,
overwrite=True)
amplitudes = compute_spike_amplitudes(we,
peak_sign='neg',
outputs='concatenated',
chunk_size=10000,
n_jobs=1)
amplitudes = compute_spike_amplitudes(we,
peak_sign='neg',
outputs='by_unit',
chunk_size=10000,
n_jobs=1)
gain = 0.1
recording.set_channel_gains(gain)
recording.set_channel_offsets(0)
folder = Path('mearec_waveforms_scaled')
we_scaled = extract_waveforms(recording,
sorting,
folder,
ms_before=1.,
ms_after=2.,
max_spikes_per_unit=500,
n_jobs=1,
chunk_size=30000,
load_if_exists=False,
overwrite=True,
return_scaled=True)
amplitudes_scaled = compute_spike_amplitudes(we_scaled,
peak_sign='neg',
outputs='concatenated',
chunk_size=10000,
n_jobs=1,
return_scaled=True)
amplitudes_unscaled = compute_spike_amplitudes(we_scaled,
peak_sign='neg',
outputs='concatenated',
chunk_size=10000,
n_jobs=1,
return_scaled=False)
assert np.allclose(amplitudes_scaled[0], amplitudes_unscaled[0] * gain)
# reload as an extension from we
assert SpikeAmplitudesCalculator in we.get_available_extensions()
assert we_scaled.is_extension('spike_amplitudes')
sac = we.load_extension('spike_amplitudes')
assert isinstance(sac, SpikeAmplitudesCalculator)
assert sac._amplitudes is not None
qmc = SpikeAmplitudesCalculator.load_from_folder(folder)
assert sac._amplitudes is not None
ax.yaxis.set_tick_params(labelsize=12)
ax.set_xticklabels(sorters, fontsize=15, rotation=45, ha='center')
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
fig = ax.get_figure()
fig.subplots_adjust(bottom=0.2)
fig.set_size_inches(8, 7)
p = Path('.')
study_folder = p / 'study_mearec_SqMEA1015um'
mearec_filename = p / 'recordings_50cells_SqMEA-10-15um_60.0_10.0uV_27-03-2019_13-31.h5'
rec0 = se.MEArecRecordingExtractor(mearec_filename)
gt_sorting0 = se.MEArecSortingExtractor(mearec_filename)
study = None
# Setup study folder
if not study_folder.is_dir():
print('Setting up study folder:', study_folder)
gt_dict = {'rec0': (rec0, gt_sorting0)}
study = GroundTruthStudy.create(study_folder, gt_dict)
if study is None:
study = GroundTruthStudy(study_folder)
# Run sorters
sorter_list = [
'herdingspikes', 'kilosort2', 'ironclust', 'spykingcircus', 'tridesclous',
'mountainsort4'
def test_get_spike_amplitudes():
repo = 'https://gin.g-node.org/NeuralEnsemble/ephy_testing_data'
remote_path = 'mearec/mearec_test_10s.h5'
local_path = download_dataset(repo=repo,
remote_path=remote_path,
local_folder=None)
recording = se.MEArecRecordingExtractor(local_path)
sorting = se.MEArecSortingExtractor(local_path)
folder = Path('mearec_waveforms')
we = extract_waveforms(recording,
sorting,
folder,
ms_before=1.,
ms_after=2.,
max_spikes_per_unit=500,
n_jobs=1,
chunk_size=30000,
load_if_exists=False,
overwrite=True)
amplitudes = get_spike_amplitudes(we,
peak_sign='neg',
outputs='concatenated',
chunk_size=10000,
n_jobs=1)
amplitudes = get_spike_amplitudes(we,
peak_sign='neg',
outputs='by_unit',
chunk_size=10000,
n_jobs=1)
gain = 0.1
recording.set_channel_gains(gain)
recording.set_channel_offsets(0)
folder = Path('mearec_waveforms_scaled')
we_scaled = extract_waveforms(recording,
sorting,
folder,
ms_before=1.,
ms_after=2.,
max_spikes_per_unit=500,
n_jobs=1,
chunk_size=30000,
load_if_exists=False,
overwrite=True,
return_scaled=True)
amplitudes_scaled = get_spike_amplitudes(we_scaled,
peak_sign='neg',
outputs='concatenated',
chunk_size=10000,
n_jobs=1,
return_scaled=True)
amplitudes_unscaled = get_spike_amplitudes(we_scaled,
peak_sign='neg',
outputs='concatenated',
chunk_size=10000,
n_jobs=1,
return_scaled=False)
assert np.allclose(amplitudes_scaled[0], amplitudes_unscaled[0] * gain)
