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'))
print(probe)
from probeinterface.plotting import plot_probe
plot_probe(probe)
##############################################################################
# Using the :code:`toolkit`, you can perform preprocessing on the recordings.
# Each pre-processing function also returns a :code:`RecordingExtractor`,
# which makes it easy to build pipelines. Here, we filter the recording and
# apply common median reference (CMR).
# All theses preprocessing steps are "lazy". The computation is done on demand when we call
# `recording.get_traces(...)` or when we save the object to disk.
recording_cmr = recording
recording_f = st.bandpass_filter(recording, freq_min=300, freq_max=6000)
print(recording_f)
recording_cmr = st.common_reference(recording_f, reference='global', operator='median')
print(recording_cmr)
# this computes and saves the recording after applying the preprocessing chain
recording_preprocessed = recording_cmr.save(format='binary')
print(recording_preprocessed)
##############################################################################
# Now you are ready to spike sort using the :code:`sorters` module!
# Let's first check which sorters are implemented and which are installed
print('Available sorters', ss.available_sorters())
print('Installed sorters', ss.installed_sorters())
def _run_from_folder(cls, output_folder, params, verbose):
import herdingspikes as hs
recording = load_extractor(output_folder /
'spikeinterface_recording.json')
p = params
# Bandpass filter
if p['filter'] and p['freq_min'] is not None and p[
'freq_max'] is not None:
recording = st.bandpass_filter(recording=recording,
freq_min=p['freq_min'],
freq_max=p['freq_max'])
if p['pre_scale']:
recording = st.normalize_by_quantile(recording=recording,
scale=p['pre_scale_value'],
median=0.0,
q1=0.05,
q2=0.95)
print(
'Herdingspikes use the OLD spikeextractors with RecordingExtractorOldAPI'
)
old_api_recording = RecordingExtractorOldAPI(recording)
# this should have its name changed
Probe = hs.probe.RecordingExtractor(
old_api_recording,
masked_channels=p['probe_masked_channels'],
inner_radius=p['probe_inner_radius'],
neighbor_radius=p['probe_neighbor_radius'],
event_length=p['probe_event_length'],
peak_jitter=p['probe_peak_jitter'])
H = hs.HSDetection(Probe,
file_directory_name=str(output_folder),
left_cutout_time=p['left_cutout_time'],
right_cutout_time=p['right_cutout_time'],
threshold=p['detect_threshold'],
to_localize=True,
num_com_centers=p['num_com_centers'],
maa=p['maa'],
ahpthr=p['ahpthr'],
out_file_name=p['out_file_name'],
decay_filtering=p['decay_filtering'],
save_all=p['save_all'],
amp_evaluation_time=p['amp_evaluation_time'],
spk_evaluation_time=p['spk_evaluation_time'])
H.DetectFromRaw(load=True, tInc=int(p['t_inc']))
sorted_file = str(output_folder / 'HS2_sorted.hdf5')
if (not H.spikes.empty):
C = hs.HSClustering(H)
C.ShapePCA(pca_ncomponents=p['pca_ncomponents'],
pca_whiten=p['pca_whiten'])
C.CombinedClustering(alpha=p['clustering_alpha'],
cluster_subset=p['clustering_subset'],
bandwidth=p['clustering_bandwidth'],
bin_seeding=p['clustering_bin_seeding'],
n_jobs=p['clustering_n_jobs'],
min_bin_freq=p['clustering_min_bin_freq'])
else:
C = hs.HSClustering(H)
if p['filter_duplicates']:
uids = C.spikes.cl.unique()
for u in uids:
s = C.spikes[C.spikes.cl == u].t.diff(
) < p['spk_evaluation_time'] / 1000 * Probe.fps
C.spikes = C.spikes.drop(s.index[s])
if verbose:
print('Saving to', sorted_file)
C.SaveHDF5(sorted_file, sampling=Probe.fps)
