def spikeforest_sort(
recording_dirname, # The recording extractor
sorter,
sorting_params,
_force_run=False,
_force_save=False
):
recording_signature=kb.computeDirHash(recording_dirname)
signature_obj=dict(
sorter_name=sorter.name,
sorter_version=sorter.version,
recording=recording_signature,
sorting_params=sorting_params
)
if not _force_run:
print('Looking up in cache...')
firings=kb.realizeFile(key=signature_obj)
if firings:
print('Found')
if _force_save:
print('Saving')
kb.saveFile(fname=firings,key=signature_obj)
return si.MdaSortingExtractor(firings_file=firings)
recording=si.MdaRecordingExtractor(recording_dirname)
sorting=sorter(recording=recording,**sorting_params)
si.MdaSortingExtractor.writeSorting(sorting=sorting,save_path='tmp_firings.mda')
kb.saveFile(fname='tmp_firings.mda',key=signature_obj)
return sorting
def compare_with_truth(result):
ret={}
units_true=result.get('units_true',[])
out=GenSortingComparisonTable.execute(firings=result['firings'],firings_true=result['firings_true'],units_true=units_true,json_out={'ext':'.json'},html_out={'ext':'.html'}).outputs
ret['json']=kb.saveFile(out['json_out'],basename='table.json')
ret['html']=kb.saveFile(out['html_out'],basename='table.html')
return ret
def compute_recording_info(recording):
out = ComputeRecordingInfo.execute(recording_dir=recording['directory'],
channels=recording.get('channels', []),
json_out={
'ext': '.json'
}).outputs['json_out']
kb.saveFile(out)
return read_json_file(kb.realizeFile(out))
def create_timeseries_plot(recording):
out = CreateTimeseriesPlot.execute(recording_dir=recording['directory'],
channels=recording.get('channels', []),
jpg_out={
'ext': '.jpg'
}).outputs['jpg_out']
kb.saveFile(out)
return 'sha1://' + kb.computeFileSha1(out) + '/timeseries.jpg'
def create_waveforms_plot(recording, firings):
out = CreateWaveformsPlot.execute(recording_dir=recording['directory'],
channels=recording.get('channels', []),
units=recording.get('units_true', []),
firings=firings,
jpg_out={
'ext': '.jpg'
}).outputs['jpg_out']
kb.saveFile(out)
return 'sha1://' + kb.computeFileSha1(out) + '/waveforms.jpg'
def sort_recording(sorter, recording):
dsdir = recording['directory']
sorting_params = sorter['params']
processor_name = sorter['processor_name']
if processor_name in Processors:
SS = Processors[processor_name]
else:
raise Exception('No such sorter: ' + processor_name)
outputs = SS.execute(recording_dir=dsdir,
channels=recording.get('channels', []),
firings_out=dict(ext='.mda'),
**sorting_params).outputs
firings_out = kb.saveFile(outputs['firings_out'])
firings_true_path = recording['directory'] + '/firings_true.mda'
if not kb.findFile(firings_true_path):
firings_true_path = None
result = dict(recording_name=recording['name'],
study_name=recording['study'],
sorter_name=sorter['name'],
recording_dir=dsdir,
channels=recording.get('channels', []),
units_true=recording.get('units_true', []),
firings_true=firings_true_path,
sorting_params=sorting_params,
sorting_processor_name=SS.NAME,
sorting_processor_version=SS.VERSION,
firings=firings_out)
result['summary'] = summarize_sorting(result)
if result.get('firings_true', None):
result['comparison_with_truth'] = compare_with_truth(result)
return result
def sortDataset(*, sorter, dataset, _force_run=False):
dsdir = dataset['directory']
sorting_params = sorter['params']
sorting_processor = sorter['processor']
outputs = sorting_processor.execute(dataset_dir=dsdir,
firings_out=dict(ext='.mda'),
**sorting_params,
_force_run=_force_run).outputs
result = dict(dataset_name=dataset['name'],
dataset_dir=dsdir,
firings_true=dsdir + '/firings_true.mda',
sorting_params=sorting_params,
sorting_processor_name=sorting_processor.NAME,
sorting_processor_version=sorting_processor.VERSION,
firings=outputs['firings_out'])
kb.saveFile(outputs['firings_out'])
return result
def summarize_recording(recording):
ret = deepcopy(recording)
ret['computed_info'] = compute_recording_info(recording)
firings_true_path = recording['directory'] + '/firings_true.mda'
ret['plots'] = dict(timeseries=create_timeseries_plot(recording))
channels = recording.get('channels', None)
units = recording.get('units_true', None)
if kb.findFile(firings_true_path):
ret['firings_true'] = firings_true_path
ret['plots']['waveforms_true'] = create_waveforms_plot(
recording, ret['firings_true'])
true_units_info_fname = compute_units_info(
recording_dir=recording['directory'],
firings=firings_true_path,
return_format='filename',
channel_ids=channels,
unit_ids=units)
kb.saveFile(true_units_info_fname)
ret['true_units_info'] = 'sha1://' + kb.computeFileSha1(
true_units_info_fname) + '/true_units_info.json'
return ret
def sort_recording(sorter, recording):
dsdir = recording['directory']
sorting_params = sorter['params']
processor_name = sorter['processor_name']
if processor_name in Processors:
SS = Processors[processor_name][0]
SS_container_env_variable_name = Processors[processor_name][1]
else:
raise Exception('No such sorter: ' + processor_name)
if SS_container_env_variable_name:
if not SS_container_env_variable_name in os.environ:
raise Exception('Environment variable must be set: ' +
SS_container_env_variable_name)
container = os.environ[SS_container_env_variable_name]
else:
container = None
if container:
if not os.path.exists(container):
raise Exception('Container file does not exist: ' + container)
print('Sorting recording {} using {}'.format(dsdir, processor_name))
outputs = SS.execute(_container=container,
recording_dir=dsdir,
channels=recording.get('channels', []),
firings_out=dict(ext='.mda'),
**sorting_params).outputs
print('Saving firings_out...')
firings_out = kb.saveFile(outputs['firings_out'])
firings_true_path = recording['directory'] + '/firings_true.mda'
if not kb.findFile(firings_true_path):
firings_true_path = None
print('Assembling result...')
result = dict(recording_name=recording['name'],
study_name=recording['study'],
sorter_name=sorter['name'],
recording_dir=dsdir,
channels=recording.get('channels', []),
units_true=recording.get('units_true', []),
firings_true=firings_true_path,
sorting_params=sorting_params,
sorting_processor_name=SS.NAME,
sorting_processor_version=SS.VERSION,
firings=firings_out)
print('Summarizing sorting...')
result['summary'] = summarize_sorting(result)
if result.get('firings_true', None):
print('Comparing with truth...')
result['comparison_with_truth'] = compare_with_truth(result)
return result
def summarizeSorting(result):
ret = {'plots': {}}
unit_waveforms = PlotUnitWaveforms.execute(
recording_dir=result['recording_dir'],
channels=result.get('channels', []),
firings=result['firings'],
plot_out={
'ext': '.jpg'
}).outputs['plot_out']
unit_waveforms = kb.saveFile(unit_waveforms, basename='unit_waveforms.jpg')
ret['plots']['unit_waveforms'] = unit_waveforms
autocorrelograms = PlotAutoCorrelograms.execute(
recording_dir=result['recording_dir'],
channels=result.get('channels', []),
firings=result['firings'],
plot_out={
'ext': '.jpg'
}).outputs['plot_out']
autocorrelograms = kb.saveFile(autocorrelograms,
basename='autocorrelograms.jpg')
ret['plots']['autocorrelograms'] = autocorrelograms
return ret
def create_waveforms_plot(dataset,firings):
out=CreateWaveformsPlot.execute(recording_dir=dataset['directory'],firings=firings,jpg_out={'ext':'.jpg'}).outputs['jpg_out']
kb.saveFile(out)
return 'sha1://'+kb.computeFileSha1(out)+'/waveforms.jpg'
def create_timeseries_plot(dataset):
out=CreateTimeseriesPlot.execute(recording_dir=dataset['directory'],jpg_out={'ext':'.jpg'}).outputs['jpg_out']
kb.saveFile(out)
return 'sha1://'+kb.computeFileSha1(out)+'/timeseries.jpg'
def compute_dataset_info(dataset):
out=ComputeDatasetInfo.execute(recording_dir=dataset['directory'],json_out={'ext':'.json'}).outputs['json_out']
kb.saveFile(out)
return read_json_file(kb.realizeFile(out))
