def make_sorting(times1, labels1, times2, labels2, times3, labels3):
sampling_frequency = 30000.
sorting1 = NumpySorting.from_times_labels([times1], [labels1],
sampling_frequency)
sorting2 = NumpySorting.from_times_labels([times2], [labels2],
sampling_frequency)
sorting3 = NumpySorting.from_times_labels([times3], [labels3],
sampling_frequency)
return sorting1, sorting2, sorting3
def _run_from_folder(cls, output_folder, params, verbose):
import mountainsort4
recording = load_extractor(output_folder /
'spikeinterface_recording.json')
# alias to params
p = params
samplerate = recording.get_sampling_frequency()
# Bandpass filter
if p['filter'] and p['freq_min'] is not None and p[
'freq_max'] is not None:
if verbose:
print('filtering')
recording = bandpass_filter(recording=recording,
freq_min=p['freq_min'],
freq_max=p['freq_max'])
# Whiten
if p['whiten']:
if verbose:
print('whitenning')
recording = whiten(recording=recording)
print(
'Mountainsort4 use the OLD spikeextractors mapped with RecordingExtractorOldAPI'
)
old_api_recording = RecordingExtractorOldAPI(recording)
# Check location no more needed done in basesorter
old_api_sorting = mountainsort4.mountainsort4(
recording=old_api_recording,
detect_sign=p['detect_sign'],
adjacency_radius=p['adjacency_radius'],
clip_size=p['clip_size'],
detect_threshold=p['detect_threshold'],
detect_interval=p['detect_interval'],
num_workers=p['num_workers'],
verbose=verbose)
# Curate
if p['noise_overlap_threshold'] is not None and p['curation'] is True:
if verbose:
print('Curating')
old_api_sorting = mountainsort4.mountainsort4_curation(
recording=old_api_recording,
sorting=old_api_sorting,
noise_overlap_threshold=p['noise_overlap_threshold'])
# convert sorting to new API and save it
unit_ids = old_api_sorting.get_unit_ids()
units_dict_list = [{
u: old_api_sorting.get_unit_spike_train(u)
for u in unit_ids
}]
new_api_sorting = NumpySorting.from_dict(units_dict_list, samplerate)
NpzSortingExtractor.write_sorting(new_api_sorting,
str(output_folder / 'firings.npz'))
def toy_example(duration=10,
num_channels=4,
num_units=10,
sampling_frequency=30000.0,
num_segments=2,
average_peak_amplitude=-100,
upsample_factor=13,
dumpable=False,
dump_folder=None,
seed=None):
'''
Creates toy recording and sorting extractors.
Parameters
----------
duration: float (or list if multi segment)
Duration in s (default 10)
num_channels: int
Number of channels (default 4)
num_units: int
Number of units (default 10)
sampling_frequency: float
Sampling frequency (default 30000)
num_segments: int default 2
Number of segments.
dumpable: bool
If True, objects are dumped to file and become 'dumpable'
dump_folder: str or Path
Path to dump folder (if None, 'test' is used
seed: int
Seed for random initialization
Returns
-------
recording: RecordingExtractor
The output recording extractor. If dumpable is False it's a NumpyRecordingExtractor, otherwise it's an
MdaRecordingExtractor
sorting: SortingExtractor
The output sorting extractor. If dumpable is False it's a NumpyRecordingExtractor, otherwise it's an
NpzSortingExtractor
'''
if isinstance(duration, int):
duration = float(duration)
if isinstance(duration, float):
durations = [duration] * num_segments
else:
durations = duration
assert isinstance(duration, list)
assert len(durations) == num_segments
assert all(isinstance(d, float) for d in durations)
assert num_channels > 0
assert num_units > 0
waveforms, geometry = synthesize_random_waveforms(
num_units=num_units,
num_channels=num_channels,
average_peak_amplitude=average_peak_amplitude,
upsample_factor=upsample_factor,
seed=seed)
unit_ids = np.arange(num_units, dtype='int64')
traces_list = []
times_list = []
labels_list = []
for segment_index in range(num_segments):
times, labels = synthesize_random_firings(
num_units=num_units,
duration=durations[segment_index],
sampling_frequency=sampling_frequency,
seed=seed)
times_list.append(times)
labels_list.append(labels)
traces = synthesize_timeseries(
times,
labels,
unit_ids,
waveforms,
sampling_frequency,
durations[segment_index],
noise_level=10,
waveform_upsample_factor=upsample_factor,
seed=seed)
traces_list.append(traces)
sorting = NumpySorting.from_times_labels(times_list, labels_list,
sampling_frequency)
recording = NumpyRecording(traces_list, sampling_frequency)
recording.annotate(is_filtered=True)
probe = Probe(ndim=2)
probe.set_contacts(positions=geometry,
shapes='circle',
shape_params={'radius': 5})
probe.create_auto_shape(probe_type='rect', margin=20)
probe.set_device_channel_indices(np.arange(num_channels, dtype='int64'))
recording = recording.set_probe(probe)
return recording, sorting
def make_sorting(times1, labels1, times2, labels2):
sampling_frequency = 30000.
gt_sorting = NumpySorting.from_times_labels([times1], [labels1], sampling_frequency)
tested_sorting = NumpySorting.from_times_labels([times2], [labels2], sampling_frequency)
return gt_sorting, tested_sorting