def automated_curation(*, firings, cluster_metrics, firings_out, opts={}):
# Automated curation
label_map = mlp.addProcess(
'ms4alg.create_label_map',
{
'metrics': cluster_metrics
},
{
'label_map_out': True
},
{},
opts
)['outputs']['label_map_out']
return mlp.addProcess(
'ms4alg.apply_label_map',
{
'label_map': label_map,
'firings': firings
},
{
'firings_out': firings_out
},
{},
opts
)
def gen_recording(templates, spiketrains, recording_out, params):
#ml_mearec.gen_recording()(templates=templates,spiketrains=spiketrains,recording_out=recording_out,**params)
mlp.addProcess('mearec.gen_recording',
inputs=dict(templates=templates, spiketrains=spiketrains),
outputs=dict(recording_out=recording_out),
parameters=params,
opts={})
def sort_dataset(dataset_dir, output_dir):
if not os.path.exists(output_dir):
os.mkdir(output_dir)
# Dataset parameters
ds_params = read_dataset_params(dataset_dir)
detect_sign = 1
if 'spike_sign' in ds_params:
detect_sign = ds_params['spike_sign']
if 'detect_sign' in ds_params:
detect_sign = ds_params['detect_sign']
mlp.addProcess(
'ironclust.sort',
{
'timeseries': dataset_dir + '/raw.mda',
'geom': dataset_dir + '/geom.csv',
},
{'firings_out': output_dir + '/firings.mda'},
{
'samplerate': ds_params['samplerate'],
'detect_sign': detect_sign,
'prm_template_name': 'tetrode_template.prm'
#'should_cause_error':123
},
{})
def ms4alg_sort(*,
timeseries,
geom,
firings_out,
detect_sign,
adjacency_radius,
detect_threshold=3,
opts={}):
pp = {}
pp['detect_sign'] = detect_sign
pp['adjacency_radius'] = adjacency_radius
pp['detect_threshold'] = detect_threshold
mlp.addProcess('ms4alg.sort', {
'timeseries': timeseries,
'geom': geom
}, {'firings_out': firings_out}, pp, opts)
def compute_cluster_metrics(*,
timeseries,
firings,
metrics_out,
samplerate,
opts={}):
metrics1 = mlp.addProcess('ms3.cluster_metrics', {
'timeseries': timeseries,
'firings': firings
}, {'cluster_metrics_out': True}, {'samplerate': samplerate},
opts)['outputs']['cluster_metrics_out']
metrics2 = mlp.addProcess('ms3.isolation_metrics', {
'timeseries': timeseries,
'firings': firings
}, {'metrics_out': True}, {'compute_bursting_parents': 'true'},
opts)['outputs']['metrics_out']
return mlp.addProcess('ms3.combine_cluster_metrics',
{'metrics_list': [metrics1, metrics2]},
{'metrics_out': metrics_out}, {}, opts)
def out_artifacts(*,
timeseries,
threshold,
interval_size,
timeseries_out,
opts={}):
return mlp.addProcess('ms3.mask_out_artifacts', {'timeseries': timeseries},
{'timeseries_out': timeseries_out}, {
'threshold': threshold,
'interval_size': interval_size
}, opts)
def whiten(*, timeseries, timeseries_out, opts={}):
return mlp.addProcess(
'ephys.whiten',
{
'timeseries': timeseries
},
{
'timeseries_out': timeseries_out
},
{},
opts
)
def synthesize_dataset(dsdir, *, M, duration, average_snr, K=20):
if not os.path.exists(dsdir):
os.mkdir(dsdir)
noise_level = 10
average_peak_amplitude = 10 * average_snr
upsamplefac = 13
samplerate = 30000
mlp.addProcess(
'ephys.synthesize_random_waveforms', dict(),
dict(waveforms_out=dsdir + '/waveforms_true.mda.prv',
geometry_out=dsdir + '/geom.csv'),
dict(upsamplefac=upsamplefac,
M=M,
K=K,
average_peak_amplitude=average_peak_amplitude))
mlp.addProcess('ephys.synthesize_random_firings', dict(),
dict(firings_out=dsdir + '/firings_true.mda.prv'),
dict(duration=duration, samplerate=samplerate, K=K))
mlp.addProcess(
'ephys.synthesize_timeseries',
dict(firings=dsdir + '/firings_true.mda',
waveforms=dsdir + '/waveforms_true.mda'),
dict(timeseries_out=dsdir + '/raw.mda.prv'),
dict(duration=duration,
waveform_upsamplefac=upsamplefac,
noise_level=noise_level,
samplerate=samplerate))
params = dict(samplerate=samplerate, spike_sign=1)
with open(dsdir + '/params.json', 'w') as f:
json.dump(params, f)
def synthesize_sample_dataset(*,
dataset_dir,
samplerate=30000,
duration=600,
num_channels=4,
opts={}):
if not os.path.exists(dataset_dir):
os.mkdir(dataset_dir)
M = num_channels
mlp.addProcess('ephys.synthesize_random_waveforms', {}, {
'geometry_out': dataset_dir + '/geom.csv',
'waveforms_out': dataset_dir + '/waveforms_true.mda'
}, {
'upsamplefac': 13,
'M': M,
'average_peak_amplitude': 100
}, opts)
mlp.addProcess('ephys.synthesize_random_firings', {},
{'firings_out': dataset_dir + '/firings_true.mda'},
{'duration': duration}, opts)
mlp.addProcess(
'ephys.synthesize_timeseries', {
'firings': dataset_dir + '/firings_true.mda',
'waveforms': dataset_dir + '/waveforms_true.mda'
}, {'timeseries_out': dataset_dir + '/raw.mda.prv'}, {
'duration': duration,
'waveform_upsamplefac': 13,
'noise_level': 10
}, opts)
params = {'samplerate': samplerate, 'spike_sign': 1}
with open(dataset_dir + '/params.json', 'w') as outfile:
json.dump(params, outfile, indent=4)
def compute_templates(*,timeseries,firings,templates_out,opts={}):
return mlp.addProcess(
'ephys.compute_templates',
{
'timeseries':timeseries,
'firings':firings
},
{
'templates_out':templates_out
},
{},
opts
)['outputs']['templates_out']
def compute_templates(*,timeseries,firings,templates_out=True,opts={}):
return mlp.addProcess(
'ephys.compute_templates',
dict(
firings=firings,
timeseries=timeseries
),
dict(
templates_out=templates_out
),
dict(),
opts
)['outputs']['templates_out']
def compare_ground_truth(*,firings,firings_true,json_out,opts={}):
return mlp.addProcess(
'ephys.compare_ground_truth',
dict(
firings=firings,
firings_true=firings_true
),
dict(
json_out=json_out
),
dict(),
opts
)['outputs']['json_out']
def bandpass_filter(*,
timeseries,
timeseries_out,
samplerate,
freq_min,
freq_max,
opts={}):
return mlp.addProcess('ephys.bandpass_filter', {'timeseries': timeseries},
{'timeseries_out': timeseries_out}, {
'samplerate': samplerate,
'freq_min': freq_min,
'freq_max': freq_max
}, opts)
def gen_spiketrains(spiketrains_out, params):
mlp.addProcess('mearec.gen_spiketrains',
inputs=dict(),
outputs=dict(spiketrains_out=spiketrains_out),
parameters=params,
opts={})
