API

Module spikeinterface.extractors

class spikeextractors.baseextractor.BaseExtractor
allocate_array(memmap, shape=None, dtype=None, name=None, array=None)

Allocates a memory or memmap array

memmap: bool
If True, a memmap array is created in the sorting temporary folder
shape: tuple
Shape of the array. If None array must be given
dtype: dtype
Dtype of the array. If None array must be given
name: str or None
Name (root) of the file (if memmap is True). If None, a random name is generated
array: np.array
If array is given, shape and dtype are initialized based on the array. If memmap is True, the array is then deleted to clear memory
arr: np.array or np.memmap
The allocated memory or memmap array
dump_to_dict()

Dumps recording to a dictionary. The dictionary be used to re-initialize an extractor with spikeextractors.load_extractor_from_dict(dump_dict)

dump_dict: dict
Serialized dictionary
dump_to_json(file_path=None)

Dumps recording extractor to json file. The extractor can be re-loaded with spikeextractors.load_extractor_from_json(json_file)

file_path: str
Path of the json file
dump_to_pickle(file_path=None, include_properties=True, include_features=True)

Dumps recording extractor to a pickle file. The extractor can be re-loaded with spikeextractors.load_extractor_from_json(json_file)

file_path: str
Path of the json file
include_properties: bool
If True, all properties are dumped
include_features: bool
If True, all features are dumped
get_tmp_folder()

Returns temporary folder associated to the extractor

temp_folder: Path
The temporary folder
static load_extractor_from_dict(d)

Instantiates extractor from dictionary

d: dictionary
Python dictionary
extractor: RecordingExtractor or SortingExtractor
The loaded extractor object
static load_extractor_from_json(json_file)

Instantiates extractor from json file

json_file: str or Path
Path to json file
extractor: RecordingExtractor or SortingExtractor
The loaded extractor object
static load_extractor_from_pickle(pkl_file)

Instantiates extractor from json file

json_file: str or Path
Path to json file
extractor: RecordingExtractor or SortingExtractor
The loaded extractor object
make_serialized_dict()

Makes a nested serialized dictionary out of the extractor. The dictionary be used to re-initialize an extractor with spikeextractors.load_extractor_from_dict(dump_dict)

dump_dict: dict
Serialized dictionary
set_tmp_folder(folder)

Sets temporary folder of the extractor

folder: str or Path
The temporary folder
class spikeextractors.RecordingExtractor

A class that contains functions for extracting important information from recorded extracellular data. It is an abstract class so all functions with the @abstractmethod tag must be implemented for the initialization to work.

add_epoch(epoch_name, start_frame, end_frame)

This function adds an epoch to your recording extractor that tracks a certain time period in your recording. It is stored in an internal dictionary of start and end frame tuples.

epoch_name: str
The name of the epoch to be added
start_frame: int
The start frame of the epoch to be added (inclusive)
end_frame: int
The end frame of the epoch to be added (exclusive). If set to None, it will include the entire recording after the start_frame
clear_channel_property(channel_id, property_name)

This function clears the channel property for the given property.

channel_id: int
The id that specifies a channel in the recording
property_name: string
The name of the property to be cleared
clear_channels_property(property_name, channel_ids=None)

This function clears the channels’ properties for the given property.

property_name: string
The name of the property to be cleared
channel_ids: list
A list of ids that specifies a set of channels in the recording. If None all channels ar cleared
copy_channel_properties(recording, channel_ids=None)

Copy channel properties from another recording extractor to the current recording extractor.

recording: RecordingExtractor
The recording extractor from which the properties will be copied
channel_ids: (array_like, int)
The list (or single value) of channel_ids for which the properties will be copied
frame_to_time(frame)

This function converts a user-inputted frame index to a time with units of seconds.

frame: float
The frame to be converted to a time
time: float
The corresponding time in seconds
get_channel_gains(channel_ids=None)

This function returns the gain of each channel specifed by channel_ids.

channel_ids: array_like
The channel ids (ints) for which the gains will be returned
gains: array_like
Returns a list of corresonding gains (floats) for the given channel_ids
get_channel_groups(channel_ids=None)

This function returns the group of each channel specifed by channel_ids

channel_ids: array-like or int
The channel ids (ints) for which the groups will be returned
groups: array_like
Returns a list of corresonding groups (ints) for the given channel_ids
get_channel_ids()

Returns the list of channel ids. If not specified, the range from 0 to num_channels - 1 is returned.

channel_ids: list
Channel list
get_channel_locations(channel_ids=None, locations_2d=True)

This function returns the location of each channel specifed by channel_ids

channel_ids: array-like or int
The channel ids (ints) for which the locations will be returned
locations_2s: bool
If True (default), first two dimensions are returned
locations: array_like
Returns a list of corresponding locations (floats) for the given channel_ids
get_channel_property(channel_id, property_name)

This function returns the data stored under the property name from the given channel.

channel_id: int
The channel id for which the property will be returned
property_name: str
A property stored by the RecordingExtractor (location, etc.)
property_data
The data associated with the given property name. Could be many formats as specified by the user
get_channel_property_names(channel_id)
Get a list of property names for a given channel.
Parameters
channel_id: int
The channel id for which the property names will be returned If None (default), will return property names for all channels
property_names
The list of property names
get_epoch(epoch_name)

This function returns a SubRecordingExtractor which is a view to the given epoch

epoch_name: str
The name of the epoch to be returned
epoch_extractor: SubRecordingExtractor
A SubRecordingExtractor which is a view to the given epoch
get_epoch_info(epoch_name)

This function returns the start frame and end frame of the epoch in a dict.

epoch_name: str
The name of the epoch to be returned
epoch_info: dict
A dict containing the start frame and end frame of the epoch
get_epoch_names()

This function returns a list of all the epoch names in your recording

epoch_names: list
List of epoch names in the recording extractor
get_num_channels()

This function returns the number of channels in the recording.

num_channels: int
Number of channels in the recording
get_num_frames()

This function returns the number of frames in the recording

num_frames: int
Number of frames in the recording (duration of recording)
get_sampling_frequency()

This function returns the sampling frequency in units of Hz.

fs: float
Sampling frequency of the recordings in Hz
get_shared_channel_property_names(channel_ids=None)
Get the intersection of channel property names for a given set of channels or for all channels if channel_ids is None.
Parameters
channel_ids: array_like
The channel ids for which the shared property names will be returned. If None (default), will return shared property names for all channels
property_names
The list of shared property names
get_snippets(reference_frames, snippet_len, channel_ids=None)

This function returns data snippets from the given channels that are starting on the given frames and are the length of the given snippet lengths before and after.

snippet_len: int or tuple
If int, the snippet will be centered at the reference frame and and return half before and half after of the length. If tuple, it will return the first value of before frames and the second value of after frames around the reference frame (allows for asymmetry)
reference_frames: array_like
A list or array of frames that will be used as the reference frame of each snippet
channel_ids: array_like
A list or array of channel ids (ints) from which each trace will be extracted
snippets: numpy.ndarray
Returns a list of the snippets as numpy arrays. The length of the list is len(reference_frames) Each array has dimensions: (num_channels x snippet_len) Out-of-bounds cases should be handled by filling in zeros in the snippet
get_sub_extractors_by_property(property_name, return_property_list=False)

Returns a list of SubRecordingExtractors from this RecordingExtractor based on the given property_name (e.g. group)

property_name: str
The property used to subdivide the extractor
return_property_list: bool
If True the property list is returned
sub_list: list
The list of subextractors to be returned

OR sub_list, prop_list

If return_property_list is True, the property list will be returned as well
get_traces(channel_ids=None, start_frame=None, end_frame=None)

This function extracts and returns a trace from the recorded data from the given channels ids and the given start and end frame. It will return traces from within three ranges:

[start_frame, start_frame+1, …, end_frame-1] [start_frame, start_frame+1, …, final_recording_frame - 1] [0, 1, …, end_frame-1] [0, 1, …, final_recording_frame - 1]

if both start_frame and end_frame are given, if only start_frame is given, if only end_frame is given, or if neither start_frame or end_frame are given, respectively. Traces are returned in a 2D array that contains all of the traces from each channel with dimensions (num_channels x num_frames). In this implementation, start_frame is inclusive and end_frame is exclusive conforming to numpy standards.

start_frame: int
The starting frame of the trace to be returned (inclusive)
end_frame: int
The ending frame of the trace to be returned (exclusive)
channel_ids: array_like
A list or 1D array of channel ids (ints) from which each trace will be extracted
traces: numpy.ndarray
A 2D array that contains all of the traces from each channel. Dimensions are: (num_channels x num_frames)
load_probe_file(probe_file, channel_map=None, channel_groups=None, verbose=False)

This function returns a SubRecordingExtractor that contains information from the given probe file (channel locations, groups, etc.) If a .prb file is given, then ‘location’ and ‘group’ information for each channel is added to the SubRecordingExtractor. If a .csv file is given, then it will only add ‘location’ to the SubRecordingExtractor.

recording: RecordingExtractor
The recording extractor to channel information
probe_file: str
Path to probe file. Either .prb or .csv
verbose: bool
If True, output is verbose
subrecording = SubRecordingExtractor
The extractor containing all of the probe information.
remove_epoch(epoch_name)

This function removes an epoch from your recording extractor.

epoch_name: str
The name of the epoch to be removed
save_to_probe_file(probe_file, grouping_property=None, radius=None, graph=True, geometry=True, verbose=False)

Saves probe file from the channel information of this recording extractor.

probe_file: str
file name of .prb or .csv file to save probe information to
grouping_property: str (default None)
If grouping_property is a shared_channel_property, different groups are saved based on the property.
radius: float (default None)
Adjacency radius (used by some sorters). If None it is not saved to the probe file.
graph: bool
If True, the adjacency graph is saved (default=True)
geometry: bool
If True, the geometry is saved (default=True)
verbose: bool
If True, output is verbose
set_channel_gains(channel_ids, gains)

This function sets the gain property of each specified channel id with the corresponding group of the passed in gains float/list.

channel_ids: array_like
The channel ids (ints) for which the groups will be specified
gains: float/array_like
If a float, each channel will be assigned the corresponding gain. If a list, each channel will be given a gain from the list
set_channel_groups(groups, channel_ids=None)

This function sets the group property of each specified channel id with the corresponding group of the passed in groups list.

groups: array-like or int
A list of groups (ints) for the channel_ids
channel_ids: array_like or None
The channel ids (ints) for which the groups will be specified. If None, all channel ids are assumed
set_channel_locations(locations, channel_ids=None)

This function sets the location properties of each specified channel id with the corresponding locations of the passed in locations list.

channel_ids: array-like or int
The channel ids (ints) for which the locations will be specified
locations: array_like
A list of corresponding locations (array_like) for the given channel_ids
set_channel_property(channel_id, property_name, value)

This function adds a property dataset to the given channel under the property name.

channel_id: int
The channel id for which the property will be added
property_name: str
A property stored by the RecordingExtractor (location, etc.)
value:
The data associated with the given property name. Could be many formats as specified by the user
time_to_frame(time)

This function converts a user-inputted time (in seconds) to a frame index.

time: float
The time (in seconds) to be converted to frame index
frame: float
The corresponding frame index
static write_recording(recording, save_path)

This function writes out the recorded file of a given recording extractor to the file format of this current recording extractor. Allows for easy conversion between recording file formats. It is a static method so it can be used without instantiating this recording extractor.

recording: RecordingExtractor
An RecordingExtractor that can extract information from the recording file to be converted to the new format.
save_path: string
A path to where the converted recorded data will be saved, which may either be a file or a folder, depending on the format.
write_to_binary_dat_format(save_path, time_axis=0, dtype=None, chunk_size=None, chunk_mb=500)

Saves the traces of this recording extractor into binary .dat format.

save_path: str
The path to the file.
time_axis: 0 (default) or 1
If 0 then traces are transposed to ensure (nb_sample, nb_channel) in the file. If 1, the traces shape (nb_channel, nb_sample) is kept in the file.
dtype: dtype
Type of the saved data. Default float32
chunk_size: None or int
If not None then the file is saved in chunks. This avoid to much memory consumption for big files. If ‘auto’ the file is saved in chunks of ~ 500Mb
chunk_mb: None or int
Chunk size in Mb (default 500Mb)
class spikeextractors.SortingExtractor

A class that contains functions for extracting important information from spiked sorted data given a spike sorting software. It is an abstract class so all functions with the @abstractmethod tag must be implemented for the initialization to work.

add_epoch(epoch_name, start_frame, end_frame)

This function adds an epoch to your sorting extractor that tracks a certain time period in your sorting. It is stored in an internal dictionary of start and end frame tuples.

epoch_name: str
The name of the epoch to be added
start_frame: int
The start frame of the epoch to be added (inclusive)
end_frame: int
The end frame of the epoch to be added (exclusive). If set to None, it will include the entire sorting after the start_frame
clear_unit_property(unit_id, property_name)

This function clears the unit property for the given property.

unit_id: int
The id that specifies a unit in the sorting
property_name: string
The name of the property to be cleared
clear_unit_spike_features(unit_id, feature_name)

This function clears the unit spikes features for the given feature.

unit_id: int
The id that specifies a unit in the sorting
feature_name: string
The name of the feature to be cleared
clear_units_property(property_name, unit_ids=None)

This function clears the units’ properties for the given property.

property_name: string
The name of the property to be cleared
unit_ids: list
A list of ids that specifies a set of units in the sorting. If None, all units are cleared
clear_units_spike_features(feature_name, unit_ids=None)

This function clears the units’ spikes features for the given feature.

feature_name: string
The name of the feature to be cleared
unit_ids: list
A list of ids that specifies a set of units in the sorting. If None, all units are cleared
copy_unit_properties(sorting, unit_ids=None)

Copy unit properties from another sorting extractor to the current sorting extractor.

sorting: SortingExtractor
The sorting extractor from which the properties will be copied
unit_ids: (array_like, int)
The list (or single value) of unit_ids for which the properties will be copied
copy_unit_spike_features(sorting, unit_ids=None)

Copy unit spike features from another sorting extractor to the current sorting extractor.

sorting: SortingExtractor
The sorting extractor from which the spike features will be copied
unit_ids: (array_like, int)
The list (or single value) of unit_ids for which the spike features will be copied
get_epoch(epoch_name)

This function returns a SubSortingExtractor which is a view to the given epoch

epoch_name: str
The name of the epoch to be returned
epoch_extractor: SubRecordingExtractor
A SubRecordingExtractor which is a view to the given epoch
get_epoch_info(epoch_name)

This function returns the start frame and end frame of the epoch in a dict.

epoch_name: str
The name of the epoch to be returned
epoch_info: dict
A dict containing the start frame and end frame of the epoch
get_epoch_names()

This function returns a list of all the epoch names in your sorting

epoch_names: list
List of epoch names in the recording extractor
get_sampling_frequency()

It returns the sampling frequency.

sampling_frequency: float
The sampling frequency
get_shared_unit_property_names(unit_ids=None)
Get the intersection of unit property names for a given set of units or for all units if unit_ids is None.
Parameters
unit_ids: array_like
The unit ids for which the shared property names will be returned. If None (default), will return shared property names for all units
property_names
The list of shared property names
get_shared_unit_spike_feature_names(unit_ids=None)
Get the intersection of unit feature names for a given set of units or for all units if unit_ids is None.
Parameters
unit_ids: array_like
The unit ids for which the shared feature names will be returned. If None (default), will return shared feature names for all units
property_names
The list of shared feature names
get_sub_extractors_by_property(property_name, return_property_list=False)

Returns a list of SubSortingExtractors from this SortingExtractor based on the given property_name (e.g. group)

property_name: str
The property used to subdivide the extractor
return_property_list: bool
If True the property list is returned
sub_list: list
The list of subextractors to be returned
get_unit_ids()

This function returns a list of ids (ints) for each unit in the sorsted result.

unit_ids: array_like
A list of the unit ids in the sorted result (ints).
get_unit_property(unit_id, property_name)

This function returns the data stored under the property name given from the given unit.

unit_id: int
The unit id for which the property will be returned
property_name: str
The name of the property
value
The data associated with the given property name. Could be many formats as specified by the user
get_unit_property_names(unit_id)
Get a list of property names for a given unit.
Parameters
unit_id: int
The unit id for which the property names will be returned
property_names
The list of property names
get_unit_spike_feature_names(unit_id)

This function returns the list of feature names for the given unit Parameters ———- unit_id: int

The unit id for which the feature names will be returned
property_names
The list of feature names.
get_unit_spike_features(unit_id, feature_name, start_frame=None, end_frame=None)

This function extracts the specified spike features from the specified unit. It will return spike features from within three ranges:

[start_frame, t_start+1, …, end_frame-1] [start_frame, start_frame+1, …, final_unit_spike_frame - 1] [0, 1, …, end_frame-1] [0, 1, …, final_unit_spike_frame - 1]

if both start_frame and end_frame are given, if only start_frame is given, if only end_frame is given, or if neither start_frame or end_frame are given, respectively. Spike features are returned in the form of an array_like of spike features. In this implementation, start_frame is inclusive and end_frame is exclusive conforming to numpy standards.

unit_id: int
The id that specifies a unit in the recording
feature_name: string
The name of the feature to be returned
start_frame: int
The frame above which a spike frame is returned (inclusive)
end_frame: int
The frame below which a spike frame is returned (exclusive)
spike_features: numpy.ndarray
An array containing all the features for each spike in the specified unit given the range of start and end frames
get_unit_spike_train(unit_id, start_frame=None, end_frame=None)

This function extracts spike frames from the specified unit. It will return spike frames from within three ranges:

[start_frame, t_start+1, …, end_frame-1] [start_frame, start_frame+1, …, final_unit_spike_frame - 1] [0, 1, …, end_frame-1] [0, 1, …, final_unit_spike_frame - 1]

if both start_frame and end_frame are given, if only start_frame is given, if only end_frame is given, or if neither start_frame or end_frame are given, respectively. Spike frames are returned in the form of an array_like of spike frames. In this implementation, start_frame is inclusive and end_frame is exclusive conforming to numpy standards.

unit_id: int
The id that specifies a unit in the recording
start_frame: int
The frame above which a spike frame is returned (inclusive)
end_frame: int
The frame below which a spike frame is returned (exclusive)
spike_train: numpy.ndarray
An 1D array containing all the frames for each spike in the specified unit given the range of start and end frames
get_units_property(*, unit_ids=None, property_name)

Returns a list of values stored under the property name corresponding to a list of units

unit_ids: list
The unit ids for which the property will be returned Defaults to get_unit_ids()
property_name: str
The name of the property
values
The list of values
get_units_spike_train(unit_ids=None, start_frame=None, end_frame=None)

This function extracts spike frames from the specified units. Parameters ———- unit_ids: array_like

The unit ids from which to return spike trains. If None, all unit spike trains will be returned
start_frame: int
The frame above which a spike frame is returned (inclusive)
end_frame: int
The frame below which a spike frame is returned (exclusive)
spike_train: numpy.ndarray
An 2D array containing all the frames for each spike in the specified units given the range of start and end frames
remove_epoch(epoch_name)

This function removes an epoch from your sorting extractor.

epoch_name: str
The name of the epoch to be removed
set_sampling_frequency(sampling_frequency)

It sets the sorting extractor sampling frequency.

sampling_frequency: float
The sampling frequency
set_unit_property(unit_id, property_name, value)

This function adds a unit property data set under the given property name to the given unit.

unit_id: int
The unit id for which the property will be set
property_name: str
The name of the property to be stored
value
The data associated with the given property name. Could be many formats as specified by the user
set_unit_spike_features(unit_id, feature_name, value, indexes=None)

This function adds a unit features data set under the given features name to the given unit.

unit_id: int
The unit id for which the features will be set
feature_name: str
The name of the feature to be stored
value: array_like
The data associated with the given feature name. Could be many formats as specified by the user.
indexes: array_like
The indices of the specified spikes (if the number of spike features is less than the length of the uint’s spike train). If None, it is assumed that value has the same length as the spike train.
set_units_property(*, unit_ids=None, property_name, values)

Sets unit property data for a list of units

unit_ids: list
The list of unit ids for which the property will be set Defaults to get_unit_ids()
property_name: str
The name of the property
value: list
The list of values to be set
static write_sorting(sorting, save_path)

This function writes out the spike sorted data file of a given sorting extractor to the file format of this current sorting extractor. Allows for easy conversion between spike sorting file formats. It is a static method so it can be used without instantiating this sorting extractor.

sorting: SortingExtractor
A SortingExtractor that can extract information from the sorted data file to be converted to the new format
save_path: string
A path to where the converted sorted data will be saved, which may either be a file or a folder, depending on the format
class spikeextractors.SubRecordingExtractor(parent_recording, *, channel_ids=None, renamed_channel_ids=None, start_frame=None, end_frame=None)
copy_channel_properties(recording, channel_ids=None)

Copy channel properties from another recording extractor to the current recording extractor.

recording: RecordingExtractor
The recording extractor from which the properties will be copied
channel_ids: (array_like, int)
The list (or single value) of channel_ids for which the properties will be copied
frame_to_time(frame)

This function converts a user-inputted frame index to a time with units of seconds.

frame: float
The frame to be converted to a time
time: float
The corresponding time in seconds
get_channel_ids()

Returns the list of channel ids. If not specified, the range from 0 to num_channels - 1 is returned.

channel_ids: list
Channel list
get_num_frames()

This function returns the number of frames in the recording

num_frames: int
Number of frames in the recording (duration of recording)
get_sampling_frequency()

This function returns the sampling frequency in units of Hz.

fs: float
Sampling frequency of the recordings in Hz
get_snippets(*, reference_frames, snippet_len, channel_ids=None)

This function returns data snippets from the given channels that are starting on the given frames and are the length of the given snippet lengths before and after.

snippet_len: int or tuple
If int, the snippet will be centered at the reference frame and and return half before and half after of the length. If tuple, it will return the first value of before frames and the second value of after frames around the reference frame (allows for asymmetry)
reference_frames: array_like
A list or array of frames that will be used as the reference frame of each snippet
channel_ids: array_like
A list or array of channel ids (ints) from which each trace will be extracted
snippets: numpy.ndarray
Returns a list of the snippets as numpy arrays. The length of the list is len(reference_frames) Each array has dimensions: (num_channels x snippet_len) Out-of-bounds cases should be handled by filling in zeros in the snippet
get_traces(channel_ids=None, start_frame=None, end_frame=None)

This function extracts and returns a trace from the recorded data from the given channels ids and the given start and end frame. It will return traces from within three ranges:

[start_frame, start_frame+1, …, end_frame-1] [start_frame, start_frame+1, …, final_recording_frame - 1] [0, 1, …, end_frame-1] [0, 1, …, final_recording_frame - 1]

if both start_frame and end_frame are given, if only start_frame is given, if only end_frame is given, or if neither start_frame or end_frame are given, respectively. Traces are returned in a 2D array that contains all of the traces from each channel with dimensions (num_channels x num_frames). In this implementation, start_frame is inclusive and end_frame is exclusive conforming to numpy standards.

start_frame: int
The starting frame of the trace to be returned (inclusive)
end_frame: int
The ending frame of the trace to be returned (exclusive)
channel_ids: array_like
A list or 1D array of channel ids (ints) from which each trace will be extracted
traces: numpy.ndarray
A 2D array that contains all of the traces from each channel. Dimensions are: (num_channels x num_frames)
time_to_frame(time)

This function converts a user-inputted time (in seconds) to a frame index.

time: float
The time (in seconds) to be converted to frame index
frame: float
The corresponding frame index
class spikeextractors.SubSortingExtractor(parent_sorting, *, unit_ids=None, renamed_unit_ids=None, start_frame=None, end_frame=None)
copy_unit_properties(sorting, unit_ids=None)

Copy unit properties from another sorting extractor to the current sorting extractor.

sorting: SortingExtractor
The sorting extractor from which the properties will be copied
unit_ids: (array_like, int)
The list (or single value) of unit_ids for which the properties will be copied
copy_unit_spike_features(sorting, unit_ids=None, start_frame=None, end_frame=None)

Copy unit spike features from another sorting extractor to the current sorting extractor.

sorting: SortingExtractor
The sorting extractor from which the spike features will be copied
unit_ids: (array_like, int)
The list (or single value) of unit_ids for which the spike features will be copied
get_sampling_frequency()

It returns the sampling frequency.

sampling_frequency: float
The sampling frequency
get_unit_ids()

This function returns a list of ids (ints) for each unit in the sorsted result.

unit_ids: array_like
A list of the unit ids in the sorted result (ints).
get_unit_spike_train(unit_id, start_frame=None, end_frame=None)

This function extracts spike frames from the specified unit. It will return spike frames from within three ranges:

[start_frame, t_start+1, …, end_frame-1] [start_frame, start_frame+1, …, final_unit_spike_frame - 1] [0, 1, …, end_frame-1] [0, 1, …, final_unit_spike_frame - 1]

if both start_frame and end_frame are given, if only start_frame is given, if only end_frame is given, or if neither start_frame or end_frame are given, respectively. Spike frames are returned in the form of an array_like of spike frames. In this implementation, start_frame is inclusive and end_frame is exclusive conforming to numpy standards.

unit_id: int
The id that specifies a unit in the recording
start_frame: int
The frame above which a spike frame is returned (inclusive)
end_frame: int
The frame below which a spike frame is returned (exclusive)
spike_train: numpy.ndarray
An 1D array containing all the frames for each spike in the specified unit given the range of start and end frames
class spikeextractors.MultiRecordingChannelExtractor(recordings, groups=None)
get_channel_ids()

Returns the list of channel ids. If not specified, the range from 0 to num_channels - 1 is returned.

channel_ids: list
Channel list
get_channel_property(channel_id, property_name)

This function returns the data stored under the property name from the given channel.

channel_id: int
The channel id for which the property will be returned
property_name: str
A property stored by the RecordingExtractor (location, etc.)
property_data
The data associated with the given property name. Could be many formats as specified by the user
get_channel_property_names(channel_id)
Get a list of property names for a given channel.
Parameters
channel_id: int
The channel id for which the property names will be returned If None (default), will return property names for all channels
property_names
The list of property names
get_num_frames()

This function returns the number of frames in the recording

num_frames: int
Number of frames in the recording (duration of recording)
get_sampling_frequency()

This function returns the sampling frequency in units of Hz.

fs: float
Sampling frequency of the recordings in Hz
get_traces(channel_ids=None, start_frame=None, end_frame=None)

This function extracts and returns a trace from the recorded data from the given channels ids and the given start and end frame. It will return traces from within three ranges:

[start_frame, start_frame+1, …, end_frame-1] [start_frame, start_frame+1, …, final_recording_frame - 1] [0, 1, …, end_frame-1] [0, 1, …, final_recording_frame - 1]

if both start_frame and end_frame are given, if only start_frame is given, if only end_frame is given, or if neither start_frame or end_frame are given, respectively. Traces are returned in a 2D array that contains all of the traces from each channel with dimensions (num_channels x num_frames). In this implementation, start_frame is inclusive and end_frame is exclusive conforming to numpy standards.

start_frame: int
The starting frame of the trace to be returned (inclusive)
end_frame: int
The ending frame of the trace to be returned (exclusive)
channel_ids: array_like
A list or 1D array of channel ids (ints) from which each trace will be extracted
traces: numpy.ndarray
A 2D array that contains all of the traces from each channel. Dimensions are: (num_channels x num_frames)
set_channel_property(channel_id, property_name, value)

This function adds a property dataset to the given channel under the property name.

channel_id: int
The channel id for which the property will be added
property_name: str
A property stored by the RecordingExtractor (location, etc.)
value:
The data associated with the given property name. Could be many formats as specified by the user
class spikeextractors.MultiRecordingTimeExtractor(recordings, epoch_names=None)
frame_to_time(frame)

This function converts a user-inputted frame index to a time with units of seconds.

frame: float
The frame to be converted to a time
time: float
The corresponding time in seconds
get_channel_ids()

Returns the list of channel ids. If not specified, the range from 0 to num_channels - 1 is returned.

channel_ids: list
Channel list
get_num_frames()

This function returns the number of frames in the recording

num_frames: int
Number of frames in the recording (duration of recording)
get_sampling_frequency()

This function returns the sampling frequency in units of Hz.

fs: float
Sampling frequency of the recordings in Hz
get_traces(channel_ids=None, start_frame=None, end_frame=None)

This function extracts and returns a trace from the recorded data from the given channels ids and the given start and end frame. It will return traces from within three ranges:

[start_frame, start_frame+1, …, end_frame-1] [start_frame, start_frame+1, …, final_recording_frame - 1] [0, 1, …, end_frame-1] [0, 1, …, final_recording_frame - 1]

if both start_frame and end_frame are given, if only start_frame is given, if only end_frame is given, or if neither start_frame or end_frame are given, respectively. Traces are returned in a 2D array that contains all of the traces from each channel with dimensions (num_channels x num_frames). In this implementation, start_frame is inclusive and end_frame is exclusive conforming to numpy standards.

start_frame: int
The starting frame of the trace to be returned (inclusive)
end_frame: int
The ending frame of the trace to be returned (exclusive)
channel_ids: array_like
A list or 1D array of channel ids (ints) from which each trace will be extracted
traces: numpy.ndarray
A 2D array that contains all of the traces from each channel. Dimensions are: (num_channels x num_frames)
time_to_frame(time)

This function converts a user-inputted time (in seconds) to a frame index.

time: float
The time (in seconds) to be converted to frame index
frame: float
The corresponding frame index
class spikeextractors.MultiSortingExtractor(sortings)
clear_unit_property(unit_id, property_name)

This function clears the unit property for the given property.

unit_id: int
The id that specifies a unit in the sorting
property_name: string
The name of the property to be cleared
clear_unit_spike_features(unit_id, feature_name)

This function clears the unit spikes features for the given feature.

unit_id: int
The id that specifies a unit in the sorting
feature_name: string
The name of the feature to be cleared
get_sampling_frequency()

It returns the sampling frequency.

sampling_frequency: float
The sampling frequency
get_unit_ids()

This function returns a list of ids (ints) for each unit in the sorsted result.

unit_ids: array_like
A list of the unit ids in the sorted result (ints).
get_unit_property(unit_id, property_name)

This function returns the data stored under the property name given from the given unit.

unit_id: int
The unit id for which the property will be returned
property_name: str
The name of the property
value
The data associated with the given property name. Could be many formats as specified by the user
get_unit_property_names(unit_id)
Get a list of property names for a given unit.
Parameters
unit_id: int
The unit id for which the property names will be returned
property_names
The list of property names
get_unit_spike_feature_names(unit_id)

This function returns the list of feature names for the given unit Parameters ———- unit_id: int

The unit id for which the feature names will be returned
property_names
The list of feature names.
get_unit_spike_features(unit_id, feature_name, start_frame=None, end_frame=None)

This function extracts the specified spike features from the specified unit. It will return spike features from within three ranges:

[start_frame, t_start+1, …, end_frame-1] [start_frame, start_frame+1, …, final_unit_spike_frame - 1] [0, 1, …, end_frame-1] [0, 1, …, final_unit_spike_frame - 1]

if both start_frame and end_frame are given, if only start_frame is given, if only end_frame is given, or if neither start_frame or end_frame are given, respectively. Spike features are returned in the form of an array_like of spike features. In this implementation, start_frame is inclusive and end_frame is exclusive conforming to numpy standards.

unit_id: int
The id that specifies a unit in the recording
feature_name: string
The name of the feature to be returned
start_frame: int
The frame above which a spike frame is returned (inclusive)
end_frame: int
The frame below which a spike frame is returned (exclusive)
spike_features: numpy.ndarray
An array containing all the features for each spike in the specified unit given the range of start and end frames
get_unit_spike_train(unit_id, start_frame=None, end_frame=None)

This function extracts spike frames from the specified unit. It will return spike frames from within three ranges:

[start_frame, t_start+1, …, end_frame-1] [start_frame, start_frame+1, …, final_unit_spike_frame - 1] [0, 1, …, end_frame-1] [0, 1, …, final_unit_spike_frame - 1]

if both start_frame and end_frame are given, if only start_frame is given, if only end_frame is given, or if neither start_frame or end_frame are given, respectively. Spike frames are returned in the form of an array_like of spike frames. In this implementation, start_frame is inclusive and end_frame is exclusive conforming to numpy standards.

unit_id: int
The id that specifies a unit in the recording
start_frame: int
The frame above which a spike frame is returned (inclusive)
end_frame: int
The frame below which a spike frame is returned (exclusive)
spike_train: numpy.ndarray
An 1D array containing all the frames for each spike in the specified unit given the range of start and end frames
set_sampling_frequency(sampling_frequency)

It sets the sorting extractor sampling frequency.

sampling_frequency: float
The sampling frequency
set_unit_property(unit_id, property_name, value)

This function adds a unit property data set under the given property name to the given unit.

unit_id: int
The unit id for which the property will be set
property_name: str
The name of the property to be stored
value
The data associated with the given property name. Could be many formats as specified by the user
set_unit_spike_features(unit_id, feature_name, value, indexes=None)

This function adds a unit features data set under the given features name to the given unit.

unit_id: int
The unit id for which the features will be set
feature_name: str
The name of the feature to be stored
value: array_like
The data associated with the given feature name. Could be many formats as specified by the user.
indexes: array_like
The indices of the specified spikes (if the number of spike features is less than the length of the uint’s spike train). If None, it is assumed that value has the same length as the spike train.
spikeextractors.load_extractor_from_dict(d)

Instantiates extractor from dictionary

d: dictionary
Python dictionary
extractor: RecordingExtractor or SortingExtractor
The loaded extractor object
spikeextractors.load_extractor_from_json(json_file)

Instantiates extractor from json file

json_file: str or Path
Path to json file
extractor: RecordingExtractor or SortingExtractor
The loaded extractor object
spikeextractors.load_extractor_from_pickle(pkl_file)

Instantiates extractor from pickle file

pkl_file: str or Path
Path to pickle file
extractor: RecordingExtractor or SortingExtractor
The loaded extractor object
spikeextractors.load_probe_file(recording, probe_file, channel_map=None, channel_groups=None, verbose=False)

This function returns a SubRecordingExtractor that contains information from the given probe file (channel locations, groups, etc.) If a .prb file is given, then ‘location’ and ‘group’ information for each channel is added to the SubRecordingExtractor. If a .csv file is given, then it will only add ‘location’ to the SubRecordingExtractor.

recording: RecordingExtractor
The recording extractor to channel information
probe_file: str
Path to probe file. Either .prb or .csv
verbose: bool
If True, output is verbose
subrecording = SubRecordingExtractor
The extractor containing all of the probe information.
spikeextractors.save_to_probe_file(recording, probe_file, grouping_property=None, radius=None, graph=True, geometry=True, verbose=False)

Saves probe file from the channel information of the given recording extractor.

recording: RecordingExtractor
The recording extractor to save probe file from
probe_file: str
file name of .prb or .csv file to save probe information to
grouping_property: str (default None)
If grouping_property is a shared_channel_property, different groups are saved based on the property.
radius: float (default None)
Adjacency radius (used by some sorters). If None it is not saved to the probe file.
graph: bool
If True, the adjacency graph is saved (default=True)
geometry: bool
If True, the geometry is saved (default=True)
verbose: bool
If True, output is verbose
spikeextractors.write_to_binary_dat_format(recording, save_path=None, file_handle=None, time_axis=0, dtype=None, chunk_size=None, chunk_mb=500)

Saves the traces of a recording extractor in binary .dat format.

recording: RecordingExtractor
The recording extractor object to be saved in .dat format
save_path: str
The path to the file.
file_handle: file handle
The file handle to dump data. This can be used to append data to an header. In case file_handle is given, the file is NOT closed after writing the binary data.
time_axis: 0 (default) or 1
If 0 then traces are transposed to ensure (nb_sample, nb_channel) in the file. If 1, the traces shape (nb_channel, nb_sample) is kept in the file.
dtype: dtype
Type of the saved data. Default float32.
chunk_size: None or int
Number of chunks to save the file in. This avoid to much memory consumption for big files. If None and ‘chunk_mb’ is given, the file is saved in chunks of ‘chunk_mb’ Mb (default 500Mb)
chunk_mb: None or int
Chunk size in Mb (default 500Mb)
spikeextractors.get_sub_extractors_by_property(extractor, property_name, return_property_list=False)

Returns a list of SubRecordingExtractors from this RecordingExtractor based on the given property_name (e.g. group)

property_name: str
The property used to subdivide the extractor
return_property_list: bool
If True the property list is returned
sub_list: list
The list of subextractors to be returned.

OR sub_list, prop_list

If return_property_list is True, the property list will be returned as well.

Module spikeinterface.toolkit

Preprocessing

spiketoolkit.preprocessing.bandpass_filter(recording, freq_min=300, freq_max=6000, freq_wid=1000, filter_type='fft', order=3, chunk_size=30000, cache_to_file=False, cache_chunks=False)

Performs a lazy filter on the recording extractor traces.

recording: RecordingExtractor
The recording extractor to be filtered.
freq_min: int or float
High-pass cutoff frequency.
freq_max: int or float
Low-pass cutoff frequency.
freq_wid: int or float
Width of the filter (when type is ‘fft’).
type: str
‘fft’ or ‘butter’. The ‘fft’ filter uses a kernel in the frequency domain. The ‘butter’ filter uses scipy butter and filtfilt functions.
order: int
Order of the filter (if ‘butter’).
chunk_size: int
The chunk size to be used for the filtering.
cache_to_file: bool (default False).
If True, filtered traces are computed and cached all at once on disk in temp file
cache_chunks: bool (default False).
If True then each chunk is cached in memory (in a dict)
filter_recording: BandpassFilterRecording
The filtered recording extractor object
spiketoolkit.preprocessing.blank_saturation(recording, threshold=None, seed=0)

Find and remove parts of the signal with extereme values. Some arrays may produce these when amplifiers enter saturation, typically for short periods of time. To remove these artefacts, values below or above a threshold are set to the median signal value. The threshold is either be estimated automatically, using the lower and upper 0.1 signal percentile with the largest deviation from the median, or specificed. Use this function with caution, as it may clip uncontaminated signals. A warning is printed if the data range suggests no artefacts.

recording: RecordingExtractor
The recording extractor to be transformed Minimum value. If None, clipping is not performed on lower interval edge.
threshold: float or ‘None’ (default None)
Threshold value (in absolute units) for saturation artifacts. If None, the threshold will be determined from the 0.1 signal percentile.
seed: int
Random seed for reproducibility
rescaled_traces: BlankSaturationRecording
The filtered traces recording extractor object
spiketoolkit.preprocessing.clip(recording, a_min=None, a_max=None)

Limit the values of the data between a_min and a_max. Values exceeding the range will be set to the minimum or maximum, respectively.

recording: RecordingExtractor
The recording extractor to be transformed
a_min: float or None (default None)
Minimum value. If None, clipping is not performed on lower interval edge.
a_max: float or None (default None)
Maximum value. If None, clipping is not performed on upper interval edge.
rescaled_traces: ClipTracesRecording
The clipped traces recording extractor object
spiketoolkit.preprocessing.normalize_by_quantile(recording, scale=1.0, median=0.0, q1=0.01, q2=0.99, seed=0)

Rescale the traces from the given recording extractor with a scalar and offset. First, the median and quantiles of the distribution are estimated. Then the distribution is rescaled and offset so that the scale is given by the distance between the quantiles (1st and 99th by default) is set to scale, and the median is set to the given median.

recording: RecordingExtractor
The recording extractor to be transformed
scalar: float
Scale for the output distribution
median: float
Median for the output distribution
q1: float (default 0.01)
Lower quantile used for measuring the scale
q1: float (default 0.99)
Upper quantile used for measuring the
seed: int
Random seed for reproducibility
rescaled_traces: NormalizeByQuantileRecording
The rescaled traces recording extractor object
spiketoolkit.preprocessing.notch_filter(recording, freq=3000, q=30, chunk_size=30000, cache_to_file=False, cache_chunks=False)

Performs a notch filter on the recording extractor traces using scipy iirnotch function.

recording: RecordingExtractor
The recording extractor to be notch-filtered.
freq: int or float
The target frequency of the notch filter.
q: int
The quality factor of the notch filter.
chunk_size: int
The chunk size to be used for the filtering.
cache_to_file: bool (default False).
If True, filtered traces are computed and cached all at once on disk in temp file
cache_chunks: bool (default False).
If True then each chunk is cached in memory (in a dict)
filter_recording: NotchFilterRecording
The notch-filtered recording extractor object
spiketoolkit.preprocessing.rectify(recording)

Rectifies the recording extractor traces. It is useful, in combination with ‘resample’, to compute multi-unit activity (MUA).

recording: RecordingExtractor
The recording extractor object to be rectified
rectified_recording: RectifyRecording
The rectified recording extractor object
spiketoolkit.preprocessing.remove_artifacts(recording, triggers, ms_before=0.5, ms_after=3)

Removes stimulation artifacts from recording extractor traces. Artifact periods are zeroed-out.

recording: RecordingExtractor
The recording extractor to remove artifacts from
triggers: list
List of int with the stimulation trigger frames
ms_before: float
Time interval in ms to remove before the trigger events
ms_after: float
Time interval in ms to remove after the trigger events
removed_recording: RemoveArtifactsRecording
The recording extractor after artifact removal
spiketoolkit.preprocessing.remove_bad_channels(recording, bad_channel_ids=None, bad_threshold=2, seconds=10, verbose=False)

Remove bad channels from the recording extractor.

recording: RecordingExtractor
The recording extractor object
bad_channel_ids: list
List of bad channel ids (int). If None, automatic removal will be done based on standard deviation.
bad_threshold: float
If automatic is used, the threshold for the standard deviation over which channels are removed
seconds: float
If automatic is used, the number of seconds used to compute standard deviations
verbose: bool
If True, output is verbose
remove_bad_channels_recording: RemoveBadChannelsRecording
The recording extractor without bad channels
spiketoolkit.preprocessing.resample(recording, resample_rate)

Resamples the recording extractor traces. If the resampling rate is multiple of the sampling rate, the faster scipy decimate function is used.

recording: RecordingExtractor
The recording extractor to be resampled
resample_rate: int or float
The resampling frequency
resampled_recording: ResampleRecording
The resample recording extractor
spiketoolkit.preprocessing.transform(recording, scalar=1, offset=0)

Transforms the traces from the given recording extractor with a scalar and offset. New traces = traces*scalar + offset.

recording: RecordingExtractor
The recording extractor to be transformed
scalar: float
Scalar for the traces of the recording extractor
offset: float
Offset for the traces of the recording extractor
transform_traces: TransformTracesRecording
The transformed traces recording extractor object
spiketoolkit.preprocessing.whiten(recording, chunk_size=30000, cache_chunks=False, seed=0)

Whitens the recording extractor traces.

recording: RecordingExtractor
The recording extractor to be whitened.
chunk_size: int
The chunk size to be used for the filtering.
cache_chunks: bool
If True, filtered traces are computed and cached all at once (default False).
seed: int
Random seed for reproducibility
whitened_recording: WhitenRecording
The whitened recording extractor
spiketoolkit.preprocessing.common_reference(recording, reference='median', groups=None, ref_channels=None, dtype=None, verbose=False)

Re-references the recording extractor traces.

recording: RecordingExtractor
The recording extractor to be re-referenced
reference: str
‘median’, ‘average’, or ‘single’. If ‘median’, common median reference (CMR) is implemented (the median of the selected channels is removed for each timestamp). If ‘average’, common average reference (CAR) is implemented (the mean of the selected channels is removed for each timestamp). If ‘single’, the selected channel(s) is remove from all channels.
groups: list
List of lists containins the channels for splitting the reference. The CMR, CAR, or referencing with respect to single channels are applied group-wise. It is useful when dealing with different channel groups, e.g. multiple tetrodes.
ref_channels: list or int
If no ‘groups’ are specified, all channels are referenced to ‘ref_channels’. If ‘groups’ is provided, then a list of channels to be applied to each group is expected. If ‘single’ reference, a list of one channel or an int is expected.
dtype: str
dtype of the returned traces. If None, dtype is maintained
verbose: bool
If True, output is verbose
referenced_recording: CommonReferenceRecording
The re-referenced recording extractor object

Postprocessing

spiketoolkit.postprocessing.get_unit_waveforms(recording, sorting, unit_ids=None, channel_ids=None, return_idxs=False, **kwargs)

Computes the spike waveforms from a recording and sorting extractor.

recording: RecordingExtractor
The recording extractor
sorting: SortingExtractor
The sorting extractor
unit_ids: list
List of unit ids to extract waveforms
channel_ids: list
List of channels ids to compute waveforms from
return_idxs: bool
If True, spike indexes and channel indexes are returned
**kwargs: Keyword arguments

A dictionary with default values can be retrieved with: st.postprocessing.get_waveforms_params():

grouping_property: str
Property to group channels. E.g. if the recording extractor has the ‘group’ property and ‘grouping_property’ is ‘group’, then waveforms are computed group-wise.
ms_before: float
Time period in ms to cut waveforms before the spike events
ms_after: float
Time period in ms to cut waveforms after the spike events
dtype: dtype
The numpy dtype of the waveforms
compute_property_from_recording: bool
If True and ‘grouping_property’ is given, the property of each unit is assigned as the corresponding property of the recording extractor channel on which the average waveform is the largest
max_channels_per_waveforms: int or None
Maximum channels per waveforms to return. If None, all channels are returned
n_jobs: int
Number of parallel jobs (default 1)
max_spikes_per_unit: int
The maximum number of spikes to extract per unit.
memmap: bool
If True, waveforms are saved as memmap object (recommended for long recordings with many channels)
seed: int
Random seed for extracting random waveforms
save_property_or_features: bool
If True (default), waveforms are saved as features of the sorting extractor object
recompute_info: bool
If True, waveforms are recomputed (default False)
verbose: bool
If True output is verbose
waveforms: list
List of np.array (n_spikes, n_channels, n_timepoints) containing extracted waveforms for each unit
spike_indexes: list
List of spike indexes for which waveforms are computed. Returned if ‘return_idxs’ is True
channel_indexes: list
List of max channel indexes
spiketoolkit.postprocessing.get_unit_templates(recording, sorting, unit_ids=None, channel_ids=None, mode='median', _waveforms=None, **kwargs)

Computes the spike templates from a recording and sorting extractor. If waveforms are not found as features, they are computed.

recording: RecordingExtractor
The recording extractor
sorting: SortingExtractor
The sorting extractor
unit_ids: list
List of unit ids to extract templates
channel_ids: list
List of channels ids to compute templates from
mode: str
Use ‘mean’ or ‘median’ to compute templates
_waveforms: list
Pre-computed waveforms to be used for computing templates
**kwargs: Keyword arguments

A dictionary with default values can be retrieved with: st.postprocessing.get_waveforms_params():

grouping_property: str
Property to group channels. E.g. if the recording extractor has the ‘group’ property and ‘grouping_property’ is ‘group’, then waveforms are computed group-wise.
ms_before: float
Time period in ms to cut waveforms before the spike events
ms_after: float
Time period in ms to cut waveforms after the spike events
dtype: dtype
The numpy dtype of the waveforms
compute_property_from_recording: bool
If True and ‘grouping_property’ is given, the property of each unit is assigned as the corresponding property of the recording extractor channel on which the average waveform is the largest
max_channels_per_waveforms: int or None
Maximum channels per waveforms to return. If None, all channels are returned
n_jobs: int
Number of parallel jobs (default 1)
max_spikes_per_unit: int
The maximum number of spikes to extract per unit
memmap: bool
If True, waveforms are saved as memmap object (recommended for long recordings with many channels)
seed: int
Random seed for extracting random waveforms
save_property_or_features: bool
If True (default), waveforms are saved as features of the sorting extractor object
recompute_info: bool
If True, waveforms are recomputed (default False)
verbose: bool
If True output is verbose
templates: list
List of np.array (n_channels, n_timepoints) containing extracted templates for each unit
spiketoolkit.postprocessing.get_unit_amplitudes(recording, sorting, unit_ids=None, channel_ids=None, return_idxs=False, **kwargs)

Computes the spike amplitudes from a recording and sorting extractor. Amplitudes can be computed in absolute value (uV) or relative to the template amplitude.

recording: RecordingExtractor
The recording extractor
sorting: SortingExtractor
The sorting extractor
unit_ids: list
List of unit ids to extract maximum channels
channel_ids: list
List of channels ids to compute amplitudes from
return_idxs: bool
If True, spike indexes and channel indexes are returned
**kwargs: Keyword arguments

A dictionary with default values can be retrieved with: st.postprocessing.get_waveforms_params():

method: str
If ‘absolute’ (default), amplitudes are absolute amplitudes in uV are returned. If ‘relative’, amplitudes are returned as ratios between waveform amplitudes and template amplitudes.
peak: str
If maximum channel has to be found among negative peaks (‘neg’), positive (‘pos’) or both (‘both’ - default)
frames_before: int
Frames before peak to compute amplitude
frames_after: float
Frames after peak to compute amplitude
max_spikes_per_unit: int
The maximum number of spikes to extract per unit
memmap: bool
If True, waveforms are saved as memmap object (recommended for long recordings with many channels)
seed: int
Random seed for extracting random waveforms
save_property_or_features: bool
If True (default), waveforms are saved as features of the sorting extractor object
recompute_info: bool
If True, waveforms are recomputed (default False)
verbose: bool
If True output is verbose
amplitudes: list
List of int containing extracted amplitudes for each unit
indexes: list
List of spike indexes for which amplitudes are computed. Returned if ‘return_idxs’ is True
spiketoolkit.postprocessing.get_unit_max_channels(recording, sorting, unit_ids=None, channel_ids=None, max_channels=1, peak='both', mode='median', **kwargs)

Computes the spike maximum channels from a recording and sorting extractor. If templates are not found as property, they are computed.

recording: RecordingExtractor
The recording extractor
sorting: SortingExtractor
The sorting extractor
unit_ids: list
List of unit ids to extract maximum channels
channel_ids: list
List of channels ids to compute max_channels from
max_channels: int
Number of max channels per units to return (default=1)
mode: str
Use ‘mean’ or ‘median’ to compute templates
**kwargs: Keyword arguments

A dictionary with default values can be retrieved with: st.postprocessing.get_waveforms_params():

grouping_property: str
Property to group channels. E.g. if the recording extractor has the ‘group’ property and ‘grouping_property’ is ‘group’, then waveforms are computed group-wise.
ms_before: float
Time period in ms to cut waveforms before the spike events
ms_after: float
Time period in ms to cut waveforms after the spike events
dtype: dtype
The numpy dtype of the waveforms
compute_property_from_recording: bool
If True and ‘grouping_property’ is given, the property of each unit is assigned as the corresponding property of the recording extractor channel on which the average waveform is the largest
max_channels_per_waveforms: int or None
Maximum channels per waveforms to return. If None, all channels are returned
n_jobs: int
Number of parallel jobs (default 1)
max_spikes_per_unit: int
The maximum number of spikes to extract per unit
memmap: bool
If True, waveforms are saved as memmap object (recommended for long recordings with many channels)
seed: int
Random seed for extracting random waveforms
save_property_or_features: bool
If True (default), waveforms are saved as features of the sorting extractor object
recompute_info: bool
If True, waveforms are recomputed (default False)
verbose: bool
If True output is verbose
max_channels: list
List of int containing extracted maximum channels for each unit
spiketoolkit.postprocessing.set_unit_properties_by_max_channel_properties(recording, sorting, property, unit_ids=None, peak='both', mode='median', verbose=False, **kwargs)

Extracts ‘property’ from recording channel with largest peak for each unit and saves it as unit property.

recording: RecordingExtractor
The recording extractor
sorting: SortingExtractor
The sorting extractor
property: str
Property to compute
unit_ids: list
List of unit ids to extract maximum channels
peak: str
If maximum channel has to be found among negative peaks (‘neg’), positive (‘pos’) or both (‘both’ - default)
mode: str
Use ‘mean’ or ‘median’ to compute templates
verbose: bool
If True output is verbose
**kwargs: Keyword arguments

A dictionary with default values can be retrieved with: st.postprocessing.get_waveforms_params():

grouping_property: str
Property to group channels. E.g. if the recording extractor has the ‘group’ property and ‘grouping_property’ is ‘group’, then waveforms are computed group-wise.
ms_before: float
Time period in ms to cut waveforms before the spike events
ms_after: float
Time period in ms to cut waveforms after the spike events
dtype: dtype
The numpy dtype of the waveforms
max_spikes_per_unit: int
The maximum number of spikes to extract per unit
compute_property_from_recording: bool
If True and ‘grouping_property’ is given, the property of each unit is assigned as the corresponding property of the recording extractor channel on which the average waveform is the largest
seed: int
Random seed for extracting random waveforms
n_jobs: int
Number of parallel jobs (default 1)
memmap: bool
If True, waveforms are saved as memmap object (recommended for long recordings with many channels)
max_channels_per_waveforms: int or None
Maximum channels per waveforms to return. If None, all channels are returned
spiketoolkit.postprocessing.compute_unit_pca_scores(recording, sorting, unit_ids=None, channel_ids=None, return_idxs=False, _waveforms=None, _spike_index_list=None, _channel_index_list=None, **kwargs)

Computes the PCA scores from the unit waveforms. If waveforms are not found as features, they are computed.

recording: RecordingExtractor
The recording extractor
sorting: SortingExtractor
The sorting extractor
unit_ids: list
List of unit ids to compute pca scores
channel_ids: list
List of channels ids to compute pca from
return_idxs: list
List of indexes of used spikes for each unit
_waveforms: list
Pre-computed waveforms (optional)
_spike_index_list: list
Pre-computed spike indexes for waveforms (optional)
_channel_index_list: list
Pre-computed channel indexes for waveforms (optional)
**kwargs: Keyword arguments

A dictionary with default values can be retrieved with: st.postprocessing.get_waveforms_params():

n_comp: int
Number of PCA components (default 3)
by_electrode: bool
If True, PCA scores are computed electrode-wise (channel by channel)
max_spikes_for_pca: int
The maximum number of spikes to use to compute PCA
whiten: bool
If True, PCA is run with whiten equal True
grouping_property: str
Property to group channels. E.g. if the recording extractor has the ‘group’ property and ‘grouping_property’ is ‘group’, then waveforms are computed group-wise.
ms_before: float
Time period in ms to cut waveforms before the spike events
ms_after: float
Time period in ms to cut waveforms after the spike events
dtype: dtype
The numpy dtype of the waveforms
compute_property_from_recording: bool
If True and ‘grouping_property’ is given, the property of each unit is assigned as the corresponding property of the recording extractor channel on which the average waveform is the largest
max_channels_per_waveforms: int or None
Maximum channels per waveforms to return. If None, all channels are returned
n_jobs: int
Number of parallel jobs (default 1)
max_spikes_per_unit: int
The maximum number of spikes to extract per unit
memmap: bool
If True, waveforms are saved as memmap object (recommended for long recordings with many channels)
seed: int
Random seed for extracting random waveforms
save_property_or_features: bool
If True (default), waveforms are saved as features of the sorting extractor object
recompute_info: bool
If True, waveforms are recomputed (default False)
verbose: bool
If True output is verbose
pcs_scores: list
List of np.array containing extracted pca scores. If ‘by_electrode’ is False, the array has shape (n_spikes, n_comp) If ‘by_electrode’ is True, the array has shape (n_spikes, n_channels, n_comp)
indexes: list
List of spike indexes for which pca scores are computed. Returned if ‘return_idxs’ is True
spiketoolkit.postprocessing.export_to_phy(recording, sorting, output_folder, compute_pc_features=True, max_channels_per_template=16, **kwargs)

Exports paired recording and sorting extractors to phy template-gui format.

recording: RecordingExtractor
The recording extractor
sorting: SortingExtractor
The sorting extractor
output_folder: str
The output folder where the phy template-gui files are saved
compute_pc_features: bool
If True (default), pc features are computed
max_channels_per_template: int or None
Maximum channels per unit to return. If None, all channels are returned
**kwargs: Keyword arguments

A dictionary with default values can be retrieved with: st.postprocessing.get_waveforms_params():

n_comp: int
Number of PCA components (default 3)
max_spikes_for_pca: int
The maximum number of spikes to use to compute PCA
whiten: bool
If True, PCA is run with whiten equal True
grouping_property: str
Property to group channels. E.g. if the recording extractor has the ‘group’ property and ‘grouping_property’ is ‘group’, then waveforms are computed group-wise.
ms_before: float
Time period in ms to cut waveforms before the spike events
ms_after: float
Time period in ms to cut waveforms after the spike events
dtype: dtype
The numpy dtype of the waveforms
max_spikes_per_unit: int
The maximum number of spikes to extract per unit
compute_property_from_recording: bool
If True and ‘grouping_property’ is given, the property of each unit is assigned as the corresponding property of the recording extractor channel on which the average waveform is the largest
n_jobs: int
Number of parallel jobs (default 1)
method: str
If ‘absolute’ (default), amplitudes are absolute amplitudes in uV are returned. If ‘relative’, amplitudes are returned as ratios between waveform amplitudes and template amplitudes.
peak: str
If maximum channel has to be found among negative peaks (‘neg’), positive (‘pos’) or both (‘both’ - default)
frames_before: int
Frames before peak to compute amplitude
frames_after: float
Frames after peak to compute amplitude
recompute_info: bool
If True, will always re-extract waveforms and templates.
save_property_or_features: bool
If True, will store all calculated features and properties
verbose: bool
If True output is verbose
seed: int
Random seed for extracting random waveforms
memmap: bool
If True, waveforms are saved as memmap object (recommended for long recordings with many channels)
spiketoolkit.postprocessing.compute_unit_template_features(recording, sorting, unit_ids=None, channel_ids=None, feature_names=None, max_channels_per_features=1, recovery_slope_window=0.7, upsampling_factor=1, invert_waveforms=False, as_dataframe=False, **kwargs)

Use SpikeInterface/spikefeatures to compute features for the unit template.

These consist of a set of 1D features:
  • peak to valley (peak_to_valley), time between peak and valley
  • halfwidth (halfwidth), width of peak at half its amplitude
  • peak trough ratio (peak_trough_ratio), amplitude of peak over amplitude of trough
  • repolarization slope (repolarization_slope), slope between trough and return to base
  • recovery slope (recovery_slope), slope after peak towards baseline
And 2D features:
  • unit_spread
  • propagation velocity

To be implemented

The metrics are computed on ‘negative’ waveforms, if templates are saved as positive, pass keyword ‘invert_waveforms’.

recording: RecordingExtractor
The recording extractor
sorting: SortingExtractor
The sorting extractor
unit_ids: list
List of unit ids to compute features
channel_ids: list
List of channels ids to compute templates on which features are computed
feature_names: list
List of feature names to be computed. If None, all features are computed
max_channels_per_features: int
Maximum number of channels to compute features on (default 1). If channel_ids is used, this parameter is ignored
upsampling_factor: int
Factor with which to upsample the template resolution (default 1)
invert_waveforms: bool
Invert templates before computing features (default False)
recovery_slope_window: float
Window after peak in ms wherein to compute recovery slope (default 0.7)
as_dataframe: bool
IfTrue, output is returned as a pandas dataframe, otherwise as a dictionary
**kwargs: Keyword arguments

A dictionary with default values can be retrieved with: st.postprocessing.get_waveforms_params():

grouping_property: str
Property to group channels. E.g. if the recording extractor has the ‘group’ property and ‘grouping_property’ is ‘group’, then waveforms are computed group-wise.
ms_before: float
Time period in ms to cut waveforms before the spike events
ms_after: float
Time period in ms to cut waveforms after the spike events
dtype: dtype
The numpy dtype of the waveforms
compute_property_from_recording: bool
If True and ‘grouping_property’ is given, the property of each unit is assigned as the corresponding property of the recording extractor channel on which the average waveform is the largest
max_channels_per_waveforms: int or None
Maximum channels per waveforms to return. If None, all channels are returned
n_jobs: int
Number of parallel jobs (default 1)
max_spikes_per_unit: int
The maximum number of spikes to extract per unit
memmap: bool
If True, waveforms are saved as memmap object (recommended for long recordings with many channels)
seed: int
Random seed for extracting random waveforms
save_property_or_features: bool
If True (default), waveforms are saved as features of the sorting extractor object
recompute_info: bool
If True, waveforms are recomputed (default False)
verbose: bool
If True output is verbose
features: dict or pandas.DataFrame
The computed features as a dictionary or a pandas.DataFrame (if as_dataframe is True)

Validation

spiketoolkit.validation.compute_isolation_distances(sorting, recording, num_channels_to_compare=13, max_spikes_per_cluster=500, unit_ids=None, **kwargs)

Computes and returns the isolation distances in the sorted dataset.

sorting: SortingExtractor
The sorting result to be evaluated.
recording: RecordingExtractor
The given recording extractor from which to extract amplitudes
num_channels_to_compare: int
The number of channels to be used for the PC extraction and comparison
max_spikes_per_cluster: int
Max spikes to be used from each unit
unit_ids: list
List of unit ids to compute metric for. If not specified, all units are used
**kwargs: keyword arguments
Keyword arguments among the following:
method: str
If ‘absolute’ (default), amplitudes are absolute amplitudes in uV are returned. If ‘relative’, amplitudes are returned as ratios between waveform amplitudes and template amplitudes
peak: str
If maximum channel has to be found among negative peaks (‘neg’), positive (‘pos’) or both (‘both’ - default)
frames_before: int
Frames before peak to compute amplitude
frames_after: int
Frames after peak to compute amplitude
apply_filter: bool
If True, recording is bandpass-filtered
freq_min: float
High-pass frequency for optional filter (default 300 Hz)
freq_max: float
Low-pass frequency for optional filter (default 6000 Hz)
grouping_property: str
Property to group channels. E.g. if the recording extractor has the ‘group’ property and ‘grouping_property’ is ‘group’, then waveforms are computed group-wise.
ms_before: float
Time period in ms to cut waveforms before the spike events
ms_after: float
Time period in ms to cut waveforms after the spike events
dtype: dtype
The numpy dtype of the waveforms
compute_property_from_recording: bool
If True and ‘grouping_property’ is given, the property of each unit is assigned as the corresponding property of the recording extractor channel on which the average waveform is the largest
max_channels_per_waveforms: int or None
Maximum channels per waveforms to return. If None, all channels are returned
n_jobs: int
Number of parallel jobs (default 1)
memmap: bool
If True, waveforms are saved as memmap object (recommended for long recordings with many channels)
save_property_or_features: bool
If true, it will save features in the sorting extractor
recompute_info: bool
If True, waveforms are recomputed
max_spikes_per_unit: int
The maximum number of spikes to extract per unit
seed: int
Random seed for reproducibility
verbose: bool
If True, will be verbose in metric computation
isolation_distances: np.ndarray
The isolation distances of the sorted units.
spiketoolkit.validation.compute_isi_violations(sorting, duration_in_frames, isi_threshold=0.0015, min_isi=None, sampling_frequency=None, unit_ids=None, **kwargs)

Computes and returns the isi violations for the sorted dataset.

sorting: SortingExtractor
The sorting result to be evaluated.
duration_in_frames: int
Length of recording (in frames).
isi_threshold: float
The isi threshold for calculating isi violations
min_isi: float
The minimum expected isi value
sampling_frequency: float
The sampling frequency of the result. If None, will check to see if sampling frequency is in sorting extractor
unit_ids: list
List of unit ids to compute metric for. If not specified, all units are used
**kwargs: keyword arguments
Keyword arguments among the following:
save_property_or_features: bool
If True, the metric is saved as sorting property
verbose: bool
If True, will be verbose in metric computation
isi_violations: np.ndarray
The isi violations of the sorted units.
spiketoolkit.validation.compute_snrs(sorting, recording, snr_mode='mad', snr_noise_duration=10.0, max_spikes_per_unit_for_snr=1000, template_mode='median', max_channel_peak='both', unit_ids=None, **kwargs)

Computes and returns the snrs in the sorted dataset.

sorting: SortingExtractor
The sorting result to be evaluated.
recording: RecordingExtractor
The given recording extractor from which to extract amplitudes
snr_mode: str
Mode to compute noise SNR (‘mad’ | ‘std’ - default ‘mad’)
snr_noise_duration: float
Number of seconds to compute noise level from (default 10.0)
max_spikes_per_unit_for_snr: int
Maximum number of spikes to compute templates from (default 1000)
template_mode: str
Use ‘mean’ or ‘median’ to compute templates
max_channel_peak: str
If maximum channel has to be found among negative peaks (‘neg’), positive (‘pos’) or both (‘both’ - default)
unit_ids: list
List of unit ids to compute metric for. If not specified, all units are used
**kwargs: keyword arguments
Keyword arguments among the following:
method: str
If ‘absolute’ (default), amplitudes are absolute amplitudes in uV are returned. If ‘relative’, amplitudes are returned as ratios between waveform amplitudes and template amplitudes
peak: str
If maximum channel has to be found among negative peaks (‘neg’), positive (‘pos’) or both (‘both’ - default)
frames_before: int
Frames before peak to compute amplitude
frames_after: int
Frames after peak to compute amplitude
apply_filter: bool
If True, recording is bandpass-filtered
freq_min: float
High-pass frequency for optional filter (default 300 Hz)
freq_max: float
Low-pass frequency for optional filter (default 6000 Hz)
grouping_property: str
Property to group channels. E.g. if the recording extractor has the ‘group’ property and ‘grouping_property’ is ‘group’, then waveforms are computed group-wise.
ms_before: float
Time period in ms to cut waveforms before the spike events
ms_after: float
Time period in ms to cut waveforms after the spike events
dtype: dtype
The numpy dtype of the waveforms
compute_property_from_recording: bool
If True and ‘grouping_property’ is given, the property of each unit is assigned as the corresponding property of the recording extractor channel on which the average waveform is the largest
max_channels_per_waveforms: int or None
Maximum channels per waveforms to return. If None, all channels are returned
n_jobs: int
Number of parallel jobs (default 1)
memmap: bool
If True, waveforms are saved as memmap object (recommended for long recordings with many channels)
save_property_or_features: bool
If true, it will save features in the sorting extractor
recompute_info: bool
If True, waveforms are recomputed
max_spikes_per_unit: int
The maximum number of spikes to extract per unit
seed: int
Random seed for reproducibility
verbose: bool
If True, will be verbose in metric computation
snrs: np.ndarray
The snrs of the sorted units.
spiketoolkit.validation.compute_amplitude_cutoffs(sorting, recording, unit_ids=None, **kwargs)

Computes and returns the amplitude cutoffs for the sorted dataset.

sorting: SortingExtractor
The sorting result to be evaluated.
recording: RecordingExtractor
The given recording extractor from which to extract amplitudes
unit_ids: list
List of unit ids to compute metric for. If not specified, all units are used
**kwargs: keyword arguments
Keyword arguments among the following:
apply_filter: bool
If True, recording is bandpass-filtered.
freq_min: float
High-pass frequency for optional filter (default 300 Hz)
freq_max: float
Low-pass frequency for optional filter (default 6000 Hz)
save_property_or_features: bool
If true, it will save amplitudes in the sorting extractor
recompute_info: bool
If True, waveforms are recomputed
max_spikes_per_unit: int
The maximum number of spikes to extract per unit
method: str
If ‘absolute’ (default), amplitudes are absolute amplitudes in uV are returned. If ‘relative’, amplitudes are returned as ratios between waveform amplitudes and template amplitudes.
peak: str
If maximum channel has to be found among negative peaks (‘neg’), positive (‘pos’) or both (‘both’ - default)
frames_before: int
Frames before peak to compute amplitude
frames_after: float
Frames after peak to compute amplitude
save_property_or_features: bool
If True, the metric is saved as sorting property
seed: int
Random seed for reproducibility
verbose: bool
If True, will be verbose in metric computation
amplitude_cutoffs: np.ndarray
The amplitude cutoffs of the sorted units.
spiketoolkit.validation.compute_d_primes(sorting, recording, num_channels_to_compare=13, max_spikes_per_cluster=500, unit_ids=None, **kwargs)

Computes and returns the d primes in the sorted dataset.

sorting: SortingExtractor
The sorting result to be evaluated
recording: RecordingExtractor
The given recording extractor from which to extract amplitudes
num_channels_to_compare: int
The number of channels to be used for the PC extraction and comparison
max_spikes_per_cluster: int
Max spikes to be used from each unit
unit_ids: list
List of unit ids to compute metric for. If not specified, all units are used
**kwargs: keyword arguments
Keyword arguments among the following:
method: str
If ‘absolute’ (default), amplitudes are absolute amplitudes in uV are returned. If ‘relative’, amplitudes are returned as ratios between waveform amplitudes and template amplitudes
peak: str
If maximum channel has to be found among negative peaks (‘neg’), positive (‘pos’) or both (‘both’ - default)
frames_before: int
Frames before peak to compute amplitude
frames_after: int
Frames after peak to compute amplitude
apply_filter: bool
If True, recording is bandpass-filtered
freq_min: float
High-pass frequency for optional filter (default 300 Hz)
freq_max: float
Low-pass frequency for optional filter (default 6000 Hz)
grouping_property: str
Property to group channels. E.g. if the recording extractor has the ‘group’ property and ‘grouping_property’ is ‘group’, then waveforms are computed group-wise.
ms_before: float
Time period in ms to cut waveforms before the spike events
ms_after: float
Time period in ms to cut waveforms after the spike events
dtype: dtype
The numpy dtype of the waveforms
compute_property_from_recording: bool
If True and ‘grouping_property’ is given, the property of each unit is assigned as the corresponding property of the recording extractor channel on which the average waveform is the largest
max_channels_per_waveforms: int or None
Maximum channels per waveforms to return. If None, all channels are returned
n_jobs: int
Number of parallel jobs (default 1)
memmap: bool
If True, waveforms are saved as memmap object (recommended for long recordings with many channels)
save_property_or_features: bool
If true, it will save features in the sorting extractor
recompute_info: bool
If True, waveforms are recomputed
max_spikes_per_unit: int
The maximum number of spikes to extract per unit
seed: int
Random seed for reproducibility
verbose: bool
If True, will be verbose in metric computation
d_primes: np.ndarray
The d primes of the sorted units.
spiketoolkit.validation.compute_drift_metrics(sorting, recording, drift_metrics_interval_s=51, drift_metrics_min_spikes_per_interval=10, unit_ids=None, **kwargs)

Computes and returns the drift metrics in the sorted dataset.

sorting: SortingExtractor
The sorting result to be evaluated.
recording: RecordingExtractor
The given recording extractor from which to extract amplitudes
drift_metrics_interval_s: float
Time period for evaluating drift.
drift_metrics_min_spikes_per_interval: int
Minimum number of spikes for evaluating drift metrics per interval.
unit_ids: list
List of unit ids to compute metric for. If not specified, all units are used
**kwargs: keyword arguments
Keyword arguments among the following:
method: str
If ‘absolute’ (default), amplitudes are absolute amplitudes in uV are returned. If ‘relative’, amplitudes are returned as ratios between waveform amplitudes and template amplitudes
peak: str
If maximum channel has to be found among negative peaks (‘neg’), positive (‘pos’) or both (‘both’ - default)
frames_before: int
Frames before peak to compute amplitude
frames_after: int
Frames after peak to compute amplitude
apply_filter: bool
If True, recording is bandpass-filtered
freq_min: float
High-pass frequency for optional filter (default 300 Hz)
freq_max: float
Low-pass frequency for optional filter (default 6000 Hz)
grouping_property: str
Property to group channels. E.g. if the recording extractor has the ‘group’ property and ‘grouping_property’ is ‘group’, then waveforms are computed group-wise.
ms_before: float
Time period in ms to cut waveforms before the spike events
ms_after: float
Time period in ms to cut waveforms after the spike events
dtype: dtype
The numpy dtype of the waveforms
compute_property_from_recording: bool
If True and ‘grouping_property’ is given, the property of each unit is assigned as the corresponding property of the recording extractor channel on which the average waveform is the largest
max_channels_per_waveforms: int or None
Maximum channels per waveforms to return. If None, all channels are returned
n_jobs: int
Number of parallel jobs (default 1)
memmap: bool
If True, waveforms are saved as memmap object (recommended for long recordings with many channels)
save_property_or_features: bool
If true, it will save features in the sorting extractor
recompute_info: bool
If True, waveforms are recomputed
max_spikes_per_unit: int
The maximum number of spikes to extract per unit
seed: int
Random seed for reproducibility
verbose: bool
If True, will be verbose in metric computation
dm_metrics: np.ndarray
The drift metrics of the sorted units.
spiketoolkit.validation.compute_firing_rates(sorting, duration_in_frames, sampling_frequency=None, unit_ids=None, **kwargs)

Computes and returns the firing rates for the sorted dataset.

sorting: SortingExtractor
The sorting result to be evaluated.
duration_in_frames: int
Length of recording (in frames).
sampling_frequency: float
The sampling frequency of the result. If None, will check to see if sampling frequency is in sorting extractor
unit_ids: list
List of unit ids to compute metric for. If not specified, all units are used
**kwargs: keyword arguments
Keyword arguments among the following:
save_property_or_features: bool
If True, the metric is saved as sorting property
verbose: bool
If True, will be verbose in metric computation
firing_rates: np.ndarray
The firing rates of the sorted units.
spiketoolkit.validation.compute_l_ratios(sorting, recording, num_channels_to_compare=13, max_spikes_per_cluster=500, unit_ids=None, **kwargs)

Computes and returns the l ratios in the sorted dataset.

sorting: SortingExtractor
The sorting result to be evaluated
recording: RecordingExtractor
The given recording extractor from which to extract amplitudes
num_channels_to_compare: int
The number of channels to be used for the PC extraction and comparison
max_spikes_per_cluster: int
Max spikes to be used from each unit
unit_ids: list
List of unit ids to compute metric for. If not specified, all units are used
**kwargs: keyword arguments
Keyword arguments among the following:
method: str
If ‘absolute’ (default), amplitudes are absolute amplitudes in uV are returned. If ‘relative’, amplitudes are returned as ratios between waveform amplitudes and template amplitudes
peak: str
If maximum channel has to be found among negative peaks (‘neg’), positive (‘pos’) or both (‘both’ - default)
frames_before: int
Frames before peak to compute amplitude
frames_after: int
Frames after peak to compute amplitude
apply_filter: bool
If True, recording is bandpass-filtered
freq_min: float
High-pass frequency for optional filter (default 300 Hz)
freq_max: float
Low-pass frequency for optional filter (default 6000 Hz)
grouping_property: str
Property to group channels. E.g. if the recording extractor has the ‘group’ property and ‘grouping_property’ is ‘group’, then waveforms are computed group-wise.
ms_before: float
Time period in ms to cut waveforms before the spike events
ms_after: float
Time period in ms to cut waveforms after the spike events
dtype: dtype
The numpy dtype of the waveforms
compute_property_from_recording: bool
If True and ‘grouping_property’ is given, the property of each unit is assigned as the corresponding property of the recording extractor channel on which the average waveform is the largest
max_channels_per_waveforms: int or None
Maximum channels per waveforms to return. If None, all channels are returned
n_jobs: int
Number of parallel jobs (default 1)
memmap: bool
If True, waveforms are saved as memmap object (recommended for long recordings with many channels)
save_property_or_features: bool
If true, it will save features in the sorting extractor
recompute_info: bool
If True, waveforms are recomputed
max_spikes_per_unit: int
The maximum number of spikes to extract per unit
seed: int
Random seed for reproducibility
verbose: bool
If True, will be verbose in metric computation
l_ratios: np.ndarray
The l ratios of the sorted units.
spiketoolkit.validation.compute_nn_metrics(sorting, recording, num_channels_to_compare=13, max_spikes_per_cluster=500, max_spikes_for_nn=10000, n_neighbors=4, unit_ids=None, **kwargs)

Computes and returns the nearest neighbor metrics in the sorted dataset.

sorting: SortingExtractor
The sorting result to be evaluated.
recording: RecordingExtractor
The given recording extractor from which to extract amplitudes
num_channels_to_compare: int
The number of channels to be used for the PC extraction and comparison
max_spikes_per_cluster: int
Max spikes to be used from each unit
max_spikes_for_nn: int
Max spikes to be used for nearest-neighbors calculation
n_neighbors: int
Number of neighbors to compare
unit_ids: list
List of unit ids to compute metric for. If not specified, all units are used
**kwargs: keyword arguments
Keyword arguments among the following:
method: str
If ‘absolute’ (default), amplitudes are absolute amplitudes in uV are returned. If ‘relative’, amplitudes are returned as ratios between waveform amplitudes and template amplitudes
peak: str
If maximum channel has to be found among negative peaks (‘neg’), positive (‘pos’) or both (‘both’ - default)
frames_before: int
Frames before peak to compute amplitude
frames_after: int
Frames after peak to compute amplitude
apply_filter: bool
If True, recording is bandpass-filtered
freq_min: float
High-pass frequency for optional filter (default 300 Hz)
freq_max: float
Low-pass frequency for optional filter (default 6000 Hz)
grouping_property: str
Property to group channels. E.g. if the recording extractor has the ‘group’ property and ‘grouping_property’ is ‘group’, then waveforms are computed group-wise.
ms_before: float
Time period in ms to cut waveforms before the spike events
ms_after: float
Time period in ms to cut waveforms after the spike events
dtype: dtype
The numpy dtype of the waveforms
compute_property_from_recording: bool
If True and ‘grouping_property’ is given, the property of each unit is assigned as the corresponding property of the recording extractor channel on which the average waveform is the largest
max_channels_per_waveforms: int or None
Maximum channels per waveforms to return. If None, all channels are returned
n_jobs: int
Number of parallel jobs (default 1)
memmap: bool
If True, waveforms are saved as memmap object (recommended for long recordings with many channels)
save_property_or_features: bool
If true, it will save features in the sorting extractor
recompute_info: bool
If True, waveforms are recomputed
max_spikes_per_unit: int
The maximum number of spikes to extract per unit
seed: int
Random seed for reproducibility
verbose: bool
If True, will be verbose in metric computation
nn_metrics: np.ndarray
The nearest neighbor metrics of the sorted units.
spiketoolkit.validation.compute_num_spikes(sorting, sampling_frequency=None, unit_ids=None, **kwargs)

Computes and returns the num spikes for the sorted dataset.

sorting: SortingExtractor
The sorting result to be evaluated
sampling_frequency: float
The sampling frequency of the result. If None, will check to see if sampling frequency is in sorting extractor
unit_ids: list
List of unit ids to compute metric for. If not specified, all units are used
**kwargs: keyword arguments
Keyword arguments among the following:
save_property_or_features: bool
If True, the metric is saved as sorting property
verbose: bool
If True, will be verbose in metric computation
num_spikes: np.ndarray
The number of spikes of the sorted units.
spiketoolkit.validation.compute_presence_ratios(sorting, duration_in_frames, sampling_frequency=None, unit_ids=None, **kwargs)

Computes and returns the presence ratios for the sorted dataset.

sorting: SortingExtractor
The sorting result to be evaluated.
duration_in_frames: int
Length of recording (in frames).
sampling_frequency: float
The sampling frequency of the result. If None, will check to see if sampling frequency is in sorting extractor
unit_ids: list
List of unit ids to compute metric for. If not specified, all units are used
**kwargs: keyword arguments
Keyword arguments among the following:
save_property_or_features: bool
If True, the metric is saved as sorting property
verbose: bool
If True, will be verbose in metric computation
presence_ratios: np.ndarray
The presence ratios of the sorted units.
spiketoolkit.validation.compute_silhouette_scores(sorting, recording, max_spikes_for_silhouette=10000, unit_ids=None, **kwargs)

Computes and returns the silhouette scores in the sorted dataset.

sorting: SortingExtractor
The sorting result to be evaluated
recording: RecordingExtractor
The given recording extractor from which to extract amplitudes
max_spikes_for_silhouette: int
Max spikes to be used for silhouette metric
unit_ids: list
List of unit ids to compute metric for. If not specified, all units are used
**kwargs: keyword arguments
Keyword arguments among the following:
method: str
If ‘absolute’ (default), amplitudes are absolute amplitudes in uV are returned. If ‘relative’, amplitudes are returned as ratios between waveform amplitudes and template amplitudes
peak: str
If maximum channel has to be found among negative peaks (‘neg’), positive (‘pos’) or both (‘both’ - default)
frames_before: int
Frames before peak to compute amplitude
frames_after: int
Frames after peak to compute amplitude
apply_filter: bool
If True, recording is bandpass-filtered
freq_min: float
High-pass frequency for optional filter (default 300 Hz)
freq_max: float
Low-pass frequency for optional filter (default 6000 Hz)
grouping_property: str
Property to group channels. E.g. if the recording extractor has the ‘group’ property and ‘grouping_property’ is ‘group’, then waveforms are computed group-wise.
ms_before: float
Time period in ms to cut waveforms before the spike events
ms_after: float
Time period in ms to cut waveforms after the spike events
dtype: dtype
The numpy dtype of the waveforms
compute_property_from_recording: bool
If True and ‘grouping_property’ is given, the property of each unit is assigned as the corresponding property of the recording extractor channel on which the average waveform is the largest
max_channels_per_waveforms: int or None
Maximum channels per waveforms to return. If None, all channels are returned
n_jobs: int
Number of parallel jobs (default 1)
memmap: bool
If True, waveforms are saved as memmap object (recommended for long recordings with many channels)
save_property_or_features: bool
If true, it will save features in the sorting extractor
recompute_info: bool
If True, waveforms are recomputed
max_spikes_per_unit: int
The maximum number of spikes to extract per unit
seed: int
Random seed for reproducibility
verbose: bool
If True, will be verbose in metric computation
silhouette_scores: np.ndarray
The sihouette scores of the sorted units.
spiketoolkit.validation.compute_quality_metrics(sorting, recording=None, duration_in_frames=None, sampling_frequency=None, metric_names=None, unit_ids=None, as_dataframe=False, isi_threshold=0.0015, min_isi=None, snr_mode='mad', snr_noise_duration=10.0, max_spikes_per_unit_for_snr=1000, template_mode='median', max_channel_peak='both', drift_metrics_interval_s=51, drift_metrics_min_spikes_per_interval=10, max_spikes_for_silhouette=10000, num_channels_to_compare=13, max_spikes_per_cluster=500, max_spikes_for_nn=10000, n_neighbors=4, **kwargs)

Computes and returns all specified metrics for the sorted dataset.

sorting: SortingExtractor
The sorting result to be evaluated.
recording: RecordingExtractor
The given recording extractor from which to extract amplitudes
duration_in_frames: int
Length of recording (in frames).
sampling_frequency: float
The sampling frequency of the result. If None, will check to see if sampling frequency is in sorting extractor
metric_names: list
List of metric names to be computed
unit_ids: list
List of unit ids to compute metric for. If not specified, all units are used
as_dataframe: bool
If True, will return dataframe of metrics. If False, will return dictionary.
isi_threshold: float
The isi threshold for calculating isi violations
min_isi: float
The minimum expected isi value
snr_mode: str
Mode to compute noise SNR (‘mad’ | ‘std’ - default ‘mad’)
snr_noise_duration: float
Number of seconds to compute noise level from (default 10.0)
max_spikes_per_unit_for_snr: int
Maximum number of spikes to compute templates from (default 1000)
template_mode: str
Use ‘mean’ or ‘median’ to compute templates
max_channel_peak: str
If maximum channel has to be found among negative peaks (‘neg’), positive (‘pos’) or both (‘both’ - default)
drift_metrics_interval_s: float
Time period for evaluating drift.
drift_metrics_min_spikes_per_interval: int
Minimum number of spikes for evaluating drift metrics per interval
max_spikes_for_silhouette: int
Max spikes to be used for silhouette metric
num_channels_to_compare: int
The number of channels to be used for the PC extraction and comparison
max_spikes_per_cluster: int
Max spikes to be used from each unit
max_spikes_for_nn: int
Max spikes to be used for nearest-neighbors calculation
n_neighbors: int
Number of neighbors to compare
**kwargs: keyword arguments
Keyword arguments among the following:
method: str
If ‘absolute’ (default), amplitudes are absolute amplitudes in uV are returned. If ‘relative’, amplitudes are returned as ratios between waveform amplitudes and template amplitudes
peak: str
If maximum channel has to be found among negative peaks (‘neg’), positive (‘pos’) or both (‘both’ - default)
frames_before: int
Frames before peak to compute amplitude
frames_after: int
Frames after peak to compute amplitude
apply_filter: bool
If True, recording is bandpass-filtered
freq_min: float
High-pass frequency for optional filter (default 300 Hz)
freq_max: float
Low-pass frequency for optional filter (default 6000 Hz)
grouping_property: str
Property to group channels. E.g. if the recording extractor has the ‘group’ property and ‘grouping_property’ is ‘group’, then waveforms are computed group-wise.
ms_before: float
Time period in ms to cut waveforms before the spike events
ms_after: float
Time period in ms to cut waveforms after the spike events
dtype: dtype
The numpy dtype of the waveforms
compute_property_from_recording: bool
If True and ‘grouping_property’ is given, the property of each unit is assigned as the corresponding property of the recording extractor channel on which the average waveform is the largest
max_channels_per_waveforms: int or None
Maximum channels per waveforms to return. If None, all channels are returned
n_jobs: int
Number of parallel jobs (default 1)
memmap: bool
If True, waveforms are saved as memmap object (recommended for long recordings with many channels)
save_property_or_features: bool
If true, it will save features in the sorting extractor
recompute_info: bool
If True, waveforms are recomputed
max_spikes_per_unit: int
The maximum number of spikes to extract per unit
seed: int
Random seed for reproducibility
verbose: bool
If True, will be verbose in metric computation
metrics: dictionary OR pandas.dataframe
Dictionary or pandas.dataframe of metrics.

Curation

spiketoolkit.curation.threshold_amplitude_cutoffs(sorting, recording, threshold, threshold_sign, **kwargs)

Computes and thresholds the amplitude cutoffs in the sorted dataset with the given sign and value.

sorting: SortingExtractor
The sorting result to be evaluated
recording: RecordingExtractor
The given recording extractor
threshold: int or float
The threshold for the given metric
threshold_sign: str
If ‘less’, will threshold any metric less than the given threshold If ‘less_or_equal’, will threshold any metric less than or equal to the given threshold If ‘greater’, will threshold any metric greater than the given threshold If ‘greater_or_equal’, will threshold any metric greater than or equal to the given threshold
**kwargs: keyword arguments
Keyword arguments among the following:
method: str
If ‘absolute’ (default), amplitudes are absolute amplitudes in uV are returned If ‘relative’, amplitudes are returned as ratios between waveform amplitudes and template amplitudes
peak: str
If maximum channel has to be found among negative peaks (‘neg’), positive (‘pos’) or both (‘both’ - default)
frames_before: int
Frames before peak to compute amplitude
frames_after: int
Frames after peak to compute amplitude
apply_filter: bool
If True, recording is bandpass-filtered
freq_min: float
High-pass frequency for optional filter (default 300 Hz)
freq_max: float
Low-pass frequency for optional filter (default 6000 Hz)
save_property_or_features: bool
If true, it will save features in the sorting extractor
recompute_info: bool
If True, waveforms are recomputed
max_spikes_per_unit: int
The maximum number of spikes to extract per unit

threshold sorting extractor

spiketoolkit.curation.threshold_d_primes(sorting, recording, threshold, threshold_sign, num_channels_to_compare=13, max_spikes_per_cluster=500, **kwargs)

Computes and thresholds the d primes in the sorted dataset with the given sign and value.

sorting: SortingExtractor
The sorting result to be evaluated
recording: RecordingExtractor
The given recording extractor
threshold: int or float
The threshold for the given metric
threshold_sign: str
If ‘less’, will threshold any metric less than the given threshold If ‘less_or_equal’, will threshold any metric less than or equal to the given threshold If ‘greater’, will threshold any metric greater than the given threshold If ‘greater_or_equal’, will threshold any metric greater than or equal to the given threshold
num_channels_to_compare: int
The number of channels to be used for the PC extraction and comparison
max_spikes_per_cluster: int
Max spikes to be used from each unit
**kwargs: keyword arguments
Keyword arguments among the following:
method: str
If ‘absolute’ (default), amplitudes are absolute amplitudes in uV are returned. If ‘relative’, amplitudes are returned as ratios between waveform amplitudes and template amplitudes
peak: str
If maximum channel has to be found among negative peaks (‘neg’), positive (‘pos’) or both (‘both’ - default)
frames_before: int
Frames before peak to compute amplitude
frames_after: int
Frames after peak to compute amplitude
apply_filter: bool
If True, recording is bandpass-filtered
freq_min: float
High-pass frequency for optional filter (default 300 Hz)
freq_max: float
Low-pass frequency for optional filter (default 6000 Hz)
grouping_property: str
Property to group channels. E.g. if the recording extractor has the ‘group’ property and ‘grouping_property’ is ‘group’, then waveforms are computed group-wise.
ms_before: float
Time period in ms to cut waveforms before the spike events
ms_after: float
Time period in ms to cut waveforms after the spike events
dtype: dtype
The numpy dtype of the waveforms
compute_property_from_recording: bool
If True and ‘grouping_property’ is given, the property of each unit is assigned as the corresponding property of the recording extractor channel on which the average waveform is the largest
max_channels_per_waveforms: int or None
Maximum channels per waveforms to return. If None, all channels are returned
n_jobs: int
Number of parallel jobs (default 1)
memmap: bool
If True, waveforms are saved as memmap object (recommended for long recordings with many channels)
save_property_or_features: bool
If true, it will save features in the sorting extractor
recompute_info: bool
If True, waveforms are recomputed
max_spikes_per_unit: int
The maximum number of spikes to extract per unit
seed: int
Random seed for reproducibility
verbose: bool
If True, will be verbose in metric computation

threshold sorting extractor

spiketoolkit.curation.threshold_drift_metrics(sorting, recording, threshold, threshold_sign, metric_name='max_drift', drift_metrics_interval_s=51, drift_metrics_min_spikes_per_interval=10, **kwargs)

Computes and thresholds the specified drift metric for the sorted dataset with the given sign and value.

sorting: SortingExtractor
The sorting result to be evaluated.
recording: RecordingExtractor
The given recording extractor
threshold: int or float
The threshold for the given metric.
threshold_sign: str
If ‘less’, will threshold any metric less than the given threshold. If ‘less_or_equal’, will threshold any metric less than or equal to the given threshold. If ‘greater’, will threshold any metric greater than the given threshold. If ‘greater_or_equal’, will threshold any metric greater than or equal to the given threshold.
metric_name: str
The name of the nearest neighbor metric to be thresholded (either “max_drift” or “cumulative_drift”).
drift_metrics_interval_s: float
Time period for evaluating drift.
drift_metrics_min_spikes_per_interval: int
Minimum number of spikes for evaluating drift metrics per interval.
**kwargs: keyword arguments
Keyword arguments among the following:
method: str
If ‘absolute’ (default), amplitudes are absolute amplitudes in uV are returned. If ‘relative’, amplitudes are returned as ratios between waveform amplitudes and template amplitudes
peak: str
If maximum channel has to be found among negative peaks (‘neg’), positive (‘pos’) or both (‘both’ - default)
frames_before: int
Frames before peak to compute amplitude
frames_after: int
Frames after peak to compute amplitude
apply_filter: bool
If True, recording is bandpass-filtered
freq_min: float
High-pass frequency for optional filter (default 300 Hz)
freq_max: float
Low-pass frequency for optional filter (default 6000 Hz)
grouping_property: str
Property to group channels. E.g. if the recording extractor has the ‘group’ property and ‘grouping_property’ is ‘group’, then waveforms are computed group-wise.
ms_before: float
Time period in ms to cut waveforms before the spike events
ms_after: float
Time period in ms to cut waveforms after the spike events
dtype: dtype
The numpy dtype of the waveforms
compute_property_from_recording: bool
If True and ‘grouping_property’ is given, the property of each unit is assigned as the corresponding property of the recording extractor channel on which the average waveform is the largest
max_channels_per_waveforms: int or None
Maximum channels per waveforms to return. If None, all channels are returned
n_jobs: int
Number of parallel jobs (default 1)
memmap: bool
If True, waveforms are saved as memmap object (recommended for long recordings with many channels)
save_property_or_features: bool
If true, it will save features in the sorting extractor
recompute_info: bool
If True, waveforms are recomputed
max_spikes_per_unit: int
The maximum number of spikes to extract per unit
seed: int
Random seed for reproducibility
verbose: bool
If True, will be verbose in metric computation

threshold sorting extractor

spiketoolkit.curation.threshold_firing_rates(sorting, threshold, threshold_sign, duration_in_frames, sampling_frequency=None, **kwargs)

Computes and thresholds the firing rates in the sorted dataset with the given sign and value.

sorting: SortingExtractor
The sorting result to be evaluated
threshold: int or float
The threshold for the given metric
threshold_sign: str
If ‘less’, will threshold any metric less than the given threshold If ‘less_or_equal’, will threshold any metric less than or equal to the given threshold If ‘greater’, will threshold any metric greater than the given threshold If ‘greater_or_equal’, will threshold any metric greater than or equal to the given threshold
duration_in_frames: int
Length of recording (in frames).
sampling_frequency:
The sampling frequency of the result. If None, will check to see if sampling frequency is in sorting extractor
**kwargs: keyword arguments
Keyword arguments among the following:
save_property_or_features: bool
If True, the metric is saved as sorting property
verbose: bool
If True, will be verbose in metric computation

threshold sorting extractor

spiketoolkit.curation.threshold_isi_violations(sorting, threshold, threshold_sign, duration_in_frames, isi_threshold=0.0015, min_isi=None, sampling_frequency=None, **kwargs)

Computes and thresholds the isi violations in the sorted dataset with the given sign and value.

sorting: SortingExtractor
The sorting result to be evaluated.
threshold: int or float
The threshold for the given metric.
threshold_sign: str
If ‘less’, will threshold any metric less than the given threshold If ‘less_or_equal’, will threshold any metric less than or equal to the given threshold If ‘greater’, will threshold any metric greater than the given threshold If ‘greater_or_equal’, will threshold any metric greater than or equal to the given threshold
duration_in_frames: int
Length of recording (in frames).
isi_threshold: float
The isi threshold for calculating isi violations.
min_isi: float
The minimum expected isi value.
sampling_frequency:
The sampling frequency of the result. If None, will check to see if sampling frequency is in sorting extractor.
**kwargs: keyword arguments
Keyword arguments among the following:
save_property_or_features: bool
If True, the metric is saved as sorting property
verbose: bool
If True, will be verbose in metric computation

threshold sorting extractor

spiketoolkit.curation.threshold_isolation_distances(sorting, recording, threshold, threshold_sign, num_channels_to_compare=13, max_spikes_per_cluster=500, **kwargs)

Computes and thresholds the isolation distances in the sorted dataset with the given sign and value.

sorting: SortingExtractor
The sorting result to be evaluated.
recording: RecordingExtractor
The given recording extractor
threshold: int or float
The threshold for the given metric.
threshold_sign: str
If ‘less’, will threshold any metric less than the given threshold. If ‘less_or_equal’, will threshold any metric less than or equal to the given threshold. If ‘greater’, will threshold any metric greater than the given threshold. If ‘greater_or_equal’, will threshold any metric greater than or equal to the given threshold.
num_channels_to_compare: int
The number of channels to be used for the PC extraction and comparison
max_spikes_per_cluster: int
Max spikes to be used from each unit
**kwargs: keyword arguments
Keyword arguments among the following:
method: str
If ‘absolute’ (default), amplitudes are absolute amplitudes in uV are returned. If ‘relative’, amplitudes are returned as ratios between waveform amplitudes and template amplitudes
peak: str
If maximum channel has to be found among negative peaks (‘neg’), positive (‘pos’) or both (‘both’ - default)
frames_before: int
Frames before peak to compute amplitude
frames_after: int
Frames after peak to compute amplitude
apply_filter: bool
If True, recording is bandpass-filtered
freq_min: float
High-pass frequency for optional filter (default 300 Hz)
freq_max: float
Low-pass frequency for optional filter (default 6000 Hz)
grouping_property: str
Property to group channels. E.g. if the recording extractor has the ‘group’ property and ‘grouping_property’ is ‘group’, then waveforms are computed group-wise.
ms_before: float
Time period in ms to cut waveforms before the spike events
ms_after: float
Time period in ms to cut waveforms after the spike events
dtype: dtype
The numpy dtype of the waveforms
compute_property_from_recording: bool
If True and ‘grouping_property’ is given, the property of each unit is assigned as the corresponding property of the recording extractor channel on which the average waveform is the largest
max_channels_per_waveforms: int or None
Maximum channels per waveforms to return. If None, all channels are returned
n_jobs: int
Number of parallel jobs (default 1)
memmap: bool
If True, waveforms are saved as memmap object (recommended for long recordings with many channels)
save_property_or_features: bool
If true, it will save features in the sorting extractor
recompute_info: bool
If True, waveforms are recomputed
max_spikes_per_unit: int
The maximum number of spikes to extract per unit
seed: int
Random seed for reproducibility
verbose: bool
If True, will be verbose in metric computation

threshold sorting extractor

spiketoolkit.curation.threshold_l_ratios(sorting, recording, threshold, threshold_sign, num_channels_to_compare=13, max_spikes_per_cluster=500, **kwargs)

Computes and thresholds the l ratios in the sorted dataset with the given sign and value.

sorting: SortingExtractor
The sorting result to be evaluated.
recording: RecordingExtractor
The given recording extractor
threshold: int or float
The threshold for the given metric.
threshold_sign: str
If ‘less’, will threshold any metric less than the given threshold. If ‘less_or_equal’, will threshold any metric less than or equal to the given threshold. If ‘greater’, will threshold any metric greater than the given threshold. If ‘greater_or_equal’, will threshold any metric greater than or equal to the given threshold.
num_channels_to_compare: int
The number of channels to be used for the PC extraction and comparison
max_spikes_per_cluster: int
Max spikes to be used from each unit
**kwargs: keyword arguments
Keyword arguments among the following:
method: str
If ‘absolute’ (default), amplitudes are absolute amplitudes in uV are returned. If ‘relative’, amplitudes are returned as ratios between waveform amplitudes and template amplitudes
peak: str
If maximum channel has to be found among negative peaks (‘neg’), positive (‘pos’) or both (‘both’ - default)
frames_before: int
Frames before peak to compute amplitude
frames_after: int
Frames after peak to compute amplitude
apply_filter: bool
If True, recording is bandpass-filtered
freq_min: float
High-pass frequency for optional filter (default 300 Hz)
freq_max: float
Low-pass frequency for optional filter (default 6000 Hz)
grouping_property: str
Property to group channels. E.g. if the recording extractor has the ‘group’ property and ‘grouping_property’ is ‘group’, then waveforms are computed group-wise.
ms_before: float
Time period in ms to cut waveforms before the spike events
ms_after: float
Time period in ms to cut waveforms after the spike events
dtype: dtype
The numpy dtype of the waveforms
compute_property_from_recording: bool
If True and ‘grouping_property’ is given, the property of each unit is assigned as the corresponding property of the recording extractor channel on which the average waveform is the largest
max_channels_per_waveforms: int or None
Maximum channels per waveforms to return. If None, all channels are returned
n_jobs: int
Number of parallel jobs (default 1)
memmap: bool
If True, waveforms are saved as memmap object (recommended for long recordings with many channels)
save_property_or_features: bool
If true, it will save features in the sorting extractor
recompute_info: bool
If True, waveforms are recomputed
max_spikes_per_unit: int
The maximum number of spikes to extract per unit
seed: int
Random seed for reproducibility
verbose: bool
If True, will be verbose in metric computation

threshold sorting extractor

spiketoolkit.curation.threshold_nn_metrics(sorting, recording, threshold, threshold_sign, metric_name='nn_hit_rate', num_channels_to_compare=13, max_spikes_per_cluster=500, max_spikes_for_nn=10000, n_neighbors=4, **kwargs)

Computes and thresholds the specified nearest neighbor metric for the sorted dataset with the given sign and value.

sorting: SortingExtractor
The sorting result to be evaluated.
recording: RecordingExtractor
The given recording extractor
threshold: int or float
The threshold for the given metric.
threshold_sign: str
If ‘less’, will threshold any metric less than the given threshold. If ‘less_or_equal’, will threshold any metric less than or equal to the given threshold. If ‘greater’, will threshold any metric greater than the given threshold. If ‘greater_or_equal’, will threshold any metric greater than or equal to the given threshold.
metric_name: str
The name of the nearest neighbor metric to be thresholded (either “nn_hit_rate” or “nn_miss_rate”).
num_channels_to_compare: int
The number of channels to be used for the PC extraction and comparison
max_spikes_per_cluster: int
Max spikes to be used from each unit
max_spikes_for_nn: int
Max spikes to be used for nearest-neighbors calculation.
n_neighbors: int
Number of neighbors to compare.
**kwargs: keyword arguments
Keyword arguments among the following:
method: str
If ‘absolute’ (default), amplitudes are absolute amplitudes in uV are returned. If ‘relative’, amplitudes are returned as ratios between waveform amplitudes and template amplitudes
peak: str
If maximum channel has to be found among negative peaks (‘neg’), positive (‘pos’) or both (‘both’ - default)
frames_before: int
Frames before peak to compute amplitude
frames_after: int
Frames after peak to compute amplitude
apply_filter: bool
If True, recording is bandpass-filtered
freq_min: float
High-pass frequency for optional filter (default 300 Hz)
freq_max: float
Low-pass frequency for optional filter (default 6000 Hz)
grouping_property: str
Property to group channels. E.g. if the recording extractor has the ‘group’ property and ‘grouping_property’ is ‘group’, then waveforms are computed group-wise.
ms_before: float
Time period in ms to cut waveforms before the spike events
ms_after: float
Time period in ms to cut waveforms after the spike events
dtype: dtype
The numpy dtype of the waveforms
compute_property_from_recording: bool
If True and ‘grouping_property’ is given, the property of each unit is assigned as the corresponding property of the recording extractor channel on which the average waveform is the largest
max_channels_per_waveforms: int or None
Maximum channels per waveforms to return. If None, all channels are returned
n_jobs: int
Number of parallel jobs (default 1)
memmap: bool
If True, waveforms are saved as memmap object (recommended for long recordings with many channels)
save_property_or_features: bool
If true, it will save features in the sorting extractor
recompute_info: bool
If True, waveforms are recomputed
max_spikes_per_unit: int
The maximum number of spikes to extract per unit
seed: int
Random seed for reproducibility
verbose: bool
If True, will be verbose in metric computation

threshold sorting extractor

spiketoolkit.curation.threshold_num_spikes(sorting, threshold, threshold_sign, sampling_frequency=None, **kwargs)

Computes and thresholds the num spikes in the sorted dataset with the given sign and value.

sorting: SortingExtractor
The sorting result to be evaluated
threshold: int or float
The threshold for the given metric
threshold_sign: str
If ‘less’, will threshold any metric less than the given threshold If ‘less_or_equal’, will threshold any metric less than or equal to the given threshold If ‘greater’, will threshold any metric greater than the given threshold If ‘greater_or_equal’, will threshold any metric greater than or equal to the given threshold
sampling_frequency:
The sampling frequency of the result. If None, will check to see if sampling frequency is in sorting extractor
**kwargs: keyword arguments
Keyword arguments among the following:
save_property_or_features: bool
If True, the metric is saved as sorting property
verbose: bool
If True, will be verbose in metric computation

threshold sorting extractor

spiketoolkit.curation.threshold_presence_ratios(sorting, threshold, threshold_sign, duration_in_frames, sampling_frequency=None, **kwargs)

Computes and thresholds the presence ratios in the sorted dataset with the given sign and value.

sorting: SortingExtractor
The sorting result to be evaluated
threshold: int or float
The threshold for the given metric
threshold_sign: str
If ‘less’, will threshold any metric less than the given threshold If ‘less_or_equal’, will threshold any metric less than or equal to the given threshold If ‘greater’, will threshold any metric greater than the given threshold If ‘greater_or_equal’, will threshold any metric greater than or equal to the given threshold
duration_in_frames: int
Length of recording (in frames).
sampling_frequency:
The sampling frequency of the result. If None, will check to see if sampling frequency is in sorting extractor
**kwargs: keyword arguments
Keyword arguments among the following:
save_property_or_features: bool
If True, the metric is saved as sorting property
verbose: bool
If True, will be verbose in metric computation

threshold sorting extractor

spiketoolkit.curation.threshold_silhouette_scores(sorting, recording, threshold, threshold_sign, max_spikes_for_silhouette=10000, **kwargs)

Computes and thresholds the silhouette scores in the sorted dataset with the given sign and value.

sorting: SortingExtractor
The sorting result to be evaluated
recording: RecordingExtractor
The given recording extractor
threshold: int or float
The threshold for the given metric
threshold_sign: str
If ‘less’, will threshold any metric less than the given threshold If ‘less_or_equal’, will threshold any metric less than or equal to the given threshold If ‘greater’, will threshold any metric greater than the given threshold If ‘greater_or_equal’, will threshold any metric greater than or equal to the given threshold
max_spikes_for_silhouette: int
Max spikes to be used for silhouette metric
**kwargs: keyword arguments
Keyword arguments among the following:
method: str
If ‘absolute’ (default), amplitudes are absolute amplitudes in uV are returned. If ‘relative’, amplitudes are returned as ratios between waveform amplitudes and template amplitudes
peak: str
If maximum channel has to be found among negative peaks (‘neg’), positive (‘pos’) or both (‘both’ - default)
frames_before: int
Frames before peak to compute amplitude
frames_after: int
Frames after peak to compute amplitude
apply_filter: bool
If True, recording is bandpass-filtered
freq_min: float
High-pass frequency for optional filter (default 300 Hz)
freq_max: float
Low-pass frequency for optional filter (default 6000 Hz)
grouping_property: str
Property to group channels. E.g. if the recording extractor has the ‘group’ property and ‘grouping_property’ is ‘group’, then waveforms are computed group-wise.
ms_before: float
Time period in ms to cut waveforms before the spike events
ms_after: float
Time period in ms to cut waveforms after the spike events
dtype: dtype
The numpy dtype of the waveforms
compute_property_from_recording: bool
If True and ‘grouping_property’ is given, the property of each unit is assigned as the corresponding property of the recording extractor channel on which the average waveform is the largest
max_channels_per_waveforms: int or None
Maximum channels per waveforms to return. If None, all channels are returned
n_jobs: int
Number of parallel jobs (default 1)
memmap: bool
If True, waveforms are saved as memmap object (recommended for long recordings with many channels)
save_property_or_features: bool
If true, it will save features in the sorting extractor
recompute_info: bool
If True, waveforms are recomputed
max_spikes_per_unit: int
The maximum number of spikes to extract per unit
seed: int
Random seed for reproducibility
verbose: bool
If True, will be verbose in metric computation

threshold sorting extractor

spiketoolkit.curation.threshold_snrs(sorting, recording, threshold, threshold_sign, snr_mode='mad', snr_noise_duration=10.0, max_spikes_per_unit_for_snr=1000, template_mode='median', max_channel_peak='both', **kwargs)

Computes and thresholds the snrs in the sorted dataset with the given sign and value.

sorting: SortingExtractor
The sorting result to be evaluated.
recording: RecordingExtractor
The given recording extractor
threshold: int or float
The threshold for the given metric.
threshold_sign: str
If ‘less’, will threshold any metric less than the given threshold. If ‘less_or_equal’, will threshold any metric less than or equal to the given threshold. If ‘greater’, will threshold any metric greater than the given threshold. If ‘greater_or_equal’, will threshold any metric greater than or equal to the given threshold.
snr_mode: str
Mode to compute noise SNR (‘mad’ | ‘std’ - default ‘mad’)
snr_noise_duration: float
Number of seconds to compute noise level from (default 10.0)
max_spikes_per_unit_for_snr: int
Maximum number of spikes to compute templates from (default 1000)
template_mode: str
Use ‘mean’ or ‘median’ to compute templates
max_channel_peak: str
If maximum channel has to be found among negative peaks (‘neg’), positive (‘pos’) or both (‘both’ - default)
**kwargs: keyword arguments
Keyword arguments among the following:
method: str
If ‘absolute’ (default), amplitudes are absolute amplitudes in uV are returned. If ‘relative’, amplitudes are returned as ratios between waveform amplitudes and template amplitudes
peak: str
If maximum channel has to be found among negative peaks (‘neg’), positive (‘pos’) or both (‘both’ - default)
frames_before: int
Frames before peak to compute amplitude
frames_after: int
Frames after peak to compute amplitude
apply_filter: bool
If True, recording is bandpass-filtered
freq_min: float
High-pass frequency for optional filter (default 300 Hz)
freq_max: float
Low-pass frequency for optional filter (default 6000 Hz)
grouping_property: str
Property to group channels. E.g. if the recording extractor has the ‘group’ property and ‘grouping_property’ is ‘group’, then waveforms are computed group-wise.
ms_before: float
Time period in ms to cut waveforms before the spike events
ms_after: float
Time period in ms to cut waveforms after the spike events
dtype: dtype
The numpy dtype of the waveforms
compute_property_from_recording: bool
If True and ‘grouping_property’ is given, the property of each unit is assigned as the corresponding property of the recording extractor channel on which the average waveform is the largest
max_channels_per_waveforms: int or None
Maximum channels per waveforms to return. If None, all channels are returned
n_jobs: int
Number of parallel jobs (default 1)
memmap: bool
If True, waveforms are saved as memmap object (recommended for long recordings with many channels)
save_property_or_features: bool
If true, it will save features in the sorting extractor
recompute_info: bool
If True, waveforms are recomputed
max_spikes_per_unit: int
The maximum number of spikes to extract per unit
seed: int
Random seed for reproducibility
verbose: bool
If True, will be verbose in metric computation

threshold sorting extractor

class spiketoolkit.curation.CurationSortingExtractor(parent_sorting, curation_steps=None)
exclude_units(unit_ids)

This function deletes roots from the curation tree according to the given unit_ids

unit_ids: list or int
The unit ids to be excluded
append_curation_step: bool
Appends the curation step to the object keyword arguments
get_sampling_frequency()

It returns the sampling frequency.

sampling_frequency: float
The sampling frequency
get_unit_ids()

This function returns a list of ids (ints) for each unit in the sorsted result.

unit_ids: array_like
A list of the unit ids in the sorted result (ints).
get_unit_spike_train(unit_id, start_frame=None, end_frame=None)

This function extracts spike frames from the specified unit. It will return spike frames from within three ranges:

[start_frame, t_start+1, …, end_frame-1] [start_frame, start_frame+1, …, final_unit_spike_frame - 1] [0, 1, …, end_frame-1] [0, 1, …, final_unit_spike_frame - 1]

if both start_frame and end_frame are given, if only start_frame is given, if only end_frame is given, or if neither start_frame or end_frame are given, respectively. Spike frames are returned in the form of an array_like of spike frames. In this implementation, start_frame is inclusive and end_frame is exclusive conforming to numpy standards.

unit_id: int
The id that specifies a unit in the recording
start_frame: int
The frame above which a spike frame is returned (inclusive)
end_frame: int
The frame below which a spike frame is returned (exclusive)
spike_train: numpy.ndarray
An 1D array containing all the frames for each spike in the specified unit given the range of start and end frames
merge_units(unit_ids)

This function merges two roots from the curation tree according to the given unit_ids. It creates a new unit_id and root that has the merged roots as children.

unit_ids: list
The unit ids to be merged
new_root_id: int
The unit id of the new merged unit.
print_curation_tree(unit_id)

This function prints the current curation tree for the unit_id (roots are current unit ids).

unit_id: in
The unit id whose curation history will be printed.
split_unit(unit_id, indices)

This function splits a root from the curation tree according to the given unit_id and indices. It creates two new unit_ids and roots that have the split root as a child. This function splits the spike train of the root by the given indices.

unit_id: int
The unit id to be split
indices: list
The indices of the unit spike train at which the spike train will be split.
new_root_ids: tuple
A tuple of new unit ids after the split (integers).

Module spikeinterface.sorters

spikesorters.available_sorters()

Lists available sorters.

spikesorters.get_default_params(sorter_name_or_class)

Returns default parameters for the specified sorter.

sorter_name_or_class: str or SorterClass
The sorter to retrieve default parameters from
default_params: dict
Dictionary with default params for the specified sorter
spikesorters.run_sorter(sorter_name_or_class, recording, output_folder=None, delete_output_folder=False, grouping_property=None, parallel=False, verbose=False, raise_error=True, **params)

Generic function to run a sorter via function approach.

Two usages with name or class:

by name:
>>> sorting = run_sorter('tridesclous', recording)
by class:
>>> sorting = run_sorter(TridesclousSorter, recording)
sorter_name_or_class: str or SorterClass
The sorter to retrieve default parameters from
recording: RecordingExtractor
The recording extractor to be spike sorted
output_folder: str or Path
Path to output folder
delete_output_folder: bool
If True, output folder is deleted (default False)
grouping_property: str
Splits spike sorting by ‘grouping_property’ (e.g. ‘groups’)
parallel: bool
If True and spike sorting is by ‘grouping_property’, spike sorting jobs are launched in parallel
verbose: bool
If True, output is verbose
raise_error: bool
If True, an error is raised if spike sorting fails (default). If False, the process continues and the error is logged in the log file.
**params: keyword args
Spike sorter specific arguments (they can be retrieved with ‘get_default_params(sorter_name_or_class)’
sortingextractor: SortingExtractor
The spike sorted data
spikesorters.run_sorters(sorter_list, recording_dict_or_list, working_folder, sorter_params={}, grouping_property=None, mode='raise', engine=None, engine_kargs={}, verbose=False, with_output=True, raise_error=False)

This run several sorter on several recording. Simple implementation are nested loops or with multiprocessing.

sorter_list: list of str (sorter names) recording_dict_or_list: a dict (or a list) of recording working_folder : str

engine = None ( = ‘loop’) or ‘multiprocessing’ processes = only if ‘multiprocessing’ if None then processes=os.cpu_count() verbose=True/False to control sorter verbosity

Note: engine=’multiprocessing’ use the python multiprocessing module. This do not allow to have subprocess in subprocess. So sorter that already use internally multiprocessing, this will fail.

sorter_list: list of str
List of sorter name.
recording_dict_or_list: dict or list
A dict of recording. The key will be the name of the recording. In a list is given then the name will be recording_0, recording_1, …
working_folder: str
The working directory. This must not exist before calling this function.
grouping_property: str
The property of grouping given to sorters.
sorter_params: dict of dict with sorter_name as key
This allow to overwrite default params for sorter.
mode: ‘raise_if_exists’ or ‘overwrite’ or ‘keep’
The mode when the subfolder of recording/sorter already exists.
  • ‘raise’ : raise error if subfolder exists
  • ‘overwrite’ : force recompute
  • ‘keep’ : do not compute again if f=subfolder exists and log is OK
engine: str
‘loop’ or ‘multiprocessing’
engine_kargs: dict
This contains kargs specific to the launcher engine:
  • ‘loop’ : no kargs
  • ‘multiprocessing’ : {‘processes’ : } number of processes
  • dask : {‘client’:} the dask client for submiting task
verbose: bool
default True
with_output: bool
return the output.
raise_error: False by default
Raise error or not when a sorter do run(…) or silently continue.
results : dict
The output is nested dict[(rec_name, sorter_name)] of SortingExtractor.

Module spikeinterface.comparison

spikecomparison.compare_two_sorters(sorting1, sorting2, sorting1_name=None, sorting2_name=None, delta_time=0.4, sampling_frequency=None, match_score=0.5, chance_score=0.1, n_jobs=-1, verbose=False)

Compares two spike sorter outputs.

  • Spike trains are matched based on their agreement scores
  • Individual spikes are labelled as true positives (TP), false negatives (FN), false positives 1 (FP from spike train 1), false positives 2 (FP from spike train 2), misclassifications (CL)

It also allows to get confusion matrix and agreement fraction, false positive fraction and false negative fraction.

sorting1: SortingExtractor
The first sorting for the comparison
sorting2: SortingExtractor
The second sorting for the comparison
sorting1_name: str
The name of sorter 1
sorting2_name: : str
The name of sorter 2
delta_time: float
Number of ms to consider coincident spikes (default 0.4 ms)
sampling_frequency: float
Optional sampling frequency in Hz when not included in sorting
match_score: float
Minimum agreement score to match units (default 0.5)
chance_score: float
Minimum agreement score to for a possible match (default 0.1)
n_jobs: int
Number of cores to use in parallel. Uses all available if -1
verbose: bool
If True, output is verbose
sorting_comparison: SortingComparison
The SortingComparison object
spikecomparison.compare_multiple_sorters(sorting_list, name_list=None, delta_time=0.4, match_score=0.5, chance_score=0.1, n_jobs=-1, spiketrain_mode='union', sampling_frequency=None, verbose=False)

Compares multiple spike sorter outputs.

  • Pair-wise comparisons are made
  • An agreement graph is built based on the agreement score

It allows to return a consensus-based sorting extractor with the get_agreement_sorting() method.

sorting_list: list
List of sorting extractor objects to be compared
name_list: list
List of spike sorter names. If not given, sorters are named as ‘sorter0’, ‘sorter1’, ‘sorter2’, etc.
delta_time: float
Number of ms to consider coincident spikes (default 0.4 ms)
match_score: float
Minimum agreement score to match units (default 0.5)
chance_score: float
Minimum agreement score to for a possible match (default 0.1)
n_jobs: int
Number of cores to use in parallel. Uses all availible if -1
spiketrain_mode: str
Mode to extract agreement spike trains:
  • ‘union’: spike trains are the union between the spike trains of the best matching two sorters
  • ‘intersection’: spike trains are the intersection between the spike trains of the
    best matching two sorters
sampling_frequency: float
Sampling frequency (used if information is not in the sorting extractors)
verbose: bool
if True, output is verbose
multi_sorting_comparison: MultiSortingComparison
MultiSortingComparison object with the multiple sorter comparison
spikecomparison.compare_sorter_to_ground_truth(gt_sorting, tested_sorting, gt_name=None, tested_name=None, delta_time=0.4, sampling_frequency=None, match_score=0.5, chance_score=0.1, well_detected_score=0.8, redundant_score=0.2, overmerged_score=0.2, exhaustive_gt=True, match_mode='hungarian', n_jobs=-1, compute_labels=False, compute_misclassifications=False, verbose=False)

Compares a sorter to a ground truth.

  • Spike trains are matched based on their agreement scores
  • Individual spikes are labelled as true positives (TP), false negatives (FN), false positives 1 (FP), misclassifications (CL)

It also allows to compute_performance and confusion matrix.

gt_sorting: SortingExtractor
The first sorting for the comparison
tested_sorting: SortingExtractor
The second sorting for the comparison
gt_name: str
The name of sorter 1
tested_name: : str
The name of sorter 2
delta_time: float
Number of ms to consider coincident spikes (default 0.4 ms)
sampling_frequency: float
Optional sampling frequency in Hz when not included in sorting
match_score: float
Minimum agreement score to match units (default 0.5)
chance_score: float
Minimum agreement score to for a possible match (default 0.1)
redundant_score: float
Agreement score above which units are redundant (default 0.2)
overmerged_score: float
Agreement score above which units can be overmerged (default 0.2)
well_detected_score: float
Agreement score above which units are well detected (default 0.8)
exhaustive_gt: bool (default True)
Tell if the ground true is “exhaustive” or not. In other world if the GT have all possible units. It allows more performance measurement. For instance, MEArec simulated dataset have exhaustive_gt=True
match_mode: ‘hungarian’, or ‘best’
What is match used for counting : ‘hugarian’ or ‘best match’.
n_jobs: int
Number of cores to use in parallel. Uses all available if -1
compute_labels: bool
If True, labels are computed at instantiation (default False)
compute_misclassifications: bool
If True, misclassifications are computed at instantiation (default False)
verbose: bool
If True, output is verbose
sorting_comparison: SortingComparison
The SortingComparison object
class spikecomparison.GroundTruthComparison(gt_sorting, tested_sorting, gt_name=None, tested_name=None, delta_time=0.4, sampling_frequency=None, match_score=0.5, well_detected_score=0.8, redundant_score=0.2, overmerged_score=0.2, chance_score=0.1, exhaustive_gt=False, n_jobs=-1, match_mode='hungarian', compute_labels=False, compute_misclassifications=False, verbose=False)

Class to compare a sorter to ground truth (GT)

This class can:
  • compute a “macth between gt_sorting and tested_sorting
  • compte th score label (TP, FN, CL, FP) for each spike
  • count by unit of GT the total of each (TP, FN, CL, FP) into a Dataframe GroundTruthComparison.count
  • compute the confusion matrix .get_confusion_matrix()
  • compute some performance metric with several strategy based on the count score by unit
  • count well detected units
  • count false positve detected units
  • count redundant units
  • count overmerged units
  • summary all this
count_bad_units()

See get_bad_units

count_false_positive_units(redundant_score=None)

See get_false_positive_units().

count_overmerged_units(overmerged_score=None)

See get_overmerged_units().

count_redundant_units(redundant_score=None)

See get_redundant_units().

count_well_detected_units(well_detected_score)

Count how many well detected units. Kargs are the same as get_well_detected_units.

get_bad_units()

Return units list of “bad units”.

“bad units” are defined as units in tested that are not in the best match list of GT units.

So it is the union of “false positive units” + “redundant units”.

Need exhaustive_gt=True

get_confusion_matrix()

Computes the confusion matrix.

confusion_matrix: pandas.DataFrame
The confusion matrix
get_false_positive_units(redundant_score=None)

Return units list of “false positive units” from tested_sorting.

“false positive units” ara defined as units in tested that are not matched at all in GT units.

Need exhaustive_gt=True

redundant_score: float (default 0.2)
The agreement score below which tested units are counted as “false positive”” (and not “redundant”).
get_overmerged_units(overmerged_score=None)

Return “overmerged units”

“overmerged units” are defined as units in tested that match more than one GT unit with an agreement score larger than overmerged_score.

overmerged_score: float (default 0.4)
Tested units with 2 or more agrement scores above ‘overmerged_score’ are counted as “overmerged”.
get_performance(method='by_unit', output='pandas')
Get performance rate with several method:
  • ‘raw_count’ : just render the raw count table
  • ‘by_unit’ : render perf as rate unit by unit of the GT
  • ‘pooled_with_average’ : compute rate unit by unit and average
method: str
‘by_unit’, or ‘pooled_with_average’
output: str
‘pandas’ or ‘dict’
perf: pandas dataframe/series (or dict)
dataframe/series (based on ‘output’) with performance entries
get_redundant_units(redundant_score=None)

Return “redundant units”

“redundant units” are defined as units in tested that match a GT units with a big agreement score but it is not the best match. In other world units in GT that detected twice or more.

redundant_score=None: float (default 0.2)
The agreement score above which tested units are counted as “redundant” (and not “false positive” ).
get_well_detected_units(well_detected_score=None)

Return units list of “well detected units” from tested_sorting.

“well detected units” ara defined as units in tested that are well matched to GT units.

well_detected_score: float (default 0.8)
The agreement score above which tested units are counted as “well detected”.
print_performance(method='pooled_with_average')

Print performance with the selected method

print_summary(well_detected_score=None, redundant_score=None, overmerged_score=None)
Print a global performance summary that depend on the context:
  • exhaustive= True/False
  • how many gt units (one or several)

This summary mix several performance metrics.

class spikecomparison.SymmetricSortingComparison(sorting1, sorting2, sorting1_name=None, sorting2_name=None, delta_time=0.4, sampling_frequency=None, match_score=0.5, chance_score=0.1, n_jobs=-1, verbose=False)

Class for symmetric comparison of two sorters when no assumption is done.

get_agreement_fraction(unit1=None, unit2=None)
get_best_unit_match1(unit1)
get_best_unit_match2(unit2)
get_mapped_sorting1()

Returns a MappedSortingExtractor for sorting 1.

The returned MappedSortingExtractor.get_unit_ids returns the unit_ids of sorting 1.

The returned MappedSortingExtractor.get_mapped_unit_ids returns the mapped unit_ids of sorting 2 to the units of sorting 1 (if units are not mapped they are labeled as -1).

The returned MappedSortingExtractor.get_unit_spikeTrains returns the the spike trains of sorting 2 mapped to the unit_ids of sorting 1.

get_mapped_sorting2()

Returns a MappedSortingExtractor for sorting 2.

The returned MappedSortingExtractor.get_unit_ids returns the unit_ids of sorting 2.

The returned MappedSortingExtractor.get_mapped_unit_ids returns the mapped unit_ids of sorting 1 to the units of sorting 2 (if units are not mapped they are labeled as -1).

The returned MappedSortingExtractor.get_unit_spikeTrains returns the the spike trains of sorting 1 mapped to the unit_ids of sorting 2.

get_matching_event_count(unit1, unit2)
get_matching_unit_list1(unit1)
get_matching_unit_list2(unit2)
class spikecomparison.GroundTruthStudy(study_folder=None)
aggregate_count_units(well_detected_score=None, redundant_score=None, overmerged_score=None)
aggregate_dataframes(copy_into_folder=True, **karg_thresh)
aggregate_performance_by_units()
aggregate_run_times()
concat_all_snr()
copy_sortings()
classmethod create(study_folder, gt_dict)
get_ground_truth(rec_name=None)
get_recording(rec_name=None)
get_sorting(sort_name, rec_name=None)
get_units_snr(rec_name=None, **snr_kargs)

Load or compute units SNR for a given recording.

run_comparisons(exhaustive_gt=False, **kwargs)
run_sorters(sorter_list, sorter_params={}, mode='keep', engine='loop', engine_kargs={}, verbose=False, raise_error=False)
scan_folder()

Module spikeinterface.widgets

spikewidgets.plot_timeseries(recording, channel_ids=None, trange=None, color_groups=False, figure=None, ax=None)

Plots recording timeseries.

recording: RecordingExtractor
The recordng extractor object
channel_ids: list
The channel ids to display.
trange: list
List with start time and end time
color_groups: bool
If True groups are plotted with different colors
figure: matplotlib figure
The figure to be used. If not given a figure is created
ax: matplotlib axis
The axis to be used. If not given an axis is created
W: TimeseriesWidget
The output widget
spikewidgets.plot_electrode_geometry(recording, markersize=20, marker='o', figure=None, ax=None)

Plots electrode geometry.

recording: RecordingExtractor
The recordng extractor object
markersize: int
The size of the marker for the electrodes
marker: str
The matplotlib marker to use (default ‘o’)
figure: matplotlib figure
The figure to be used. If not given a figure is created
ax: matplotlib axis
The axis to be used. If not given an axis is created
W: UnitWaveformsWidget
The output widget
spikewidgets.plot_spectrum(recording, channels=None, trange=None, freqrange=None, color_groups=False, color='steelblue', nfft=256, figure=None, ax=None)

Plots electrode geometry.

recording: RecordingExtractor
The recordng extractor object
channels: list
The channels to show
trange: list
List with start time and end time
freqrange: list
List with start frequency and end frequency
color_groups: bool
If True groups are plotted with different colors
color: matplotlib color
The color to be used
figure: matplotlib figure
The figure to be used. If not given a figure is created
ax: matplotlib axis
The axis to be used. If not given an axis is created
W: TimeseriesWidget
The output widget
spikewidgets.plot_spectrogram(recording, channel, trange=None, freqrange=None, cmap='viridis', nfft=256, figure=None, ax=None)

Plots electrode geometry.

recording: RecordingExtractor
The recordng extractor object
channel: int
The channel to plot spectrogram of
trange: list
List with start time and end time
freqrange: list
List with start frequency and end frequency
cmap: matplotlib colorma
The colormap to be used
figure: matplotlib figure
The figure to be used. If not given a figure is created
ax: matplotlib axis
The axis to be used. If not given an axis is created
W: TimeseriesWidget
The output widget
spikewidgets.plot_activity_map(recording, channel_ids=None, trange=None, cmap='viridis', background='on', label_color='r', ax=None, figure=None)

Plots sorting comparison confusion matrix.

recording: RecordingExtractor
The recordng extractor object
channel_ids: list
The channel ids to display.
trange: list
List with start time and end time
cmap: matplotlib colormap
The colormap to be used (default ‘viridis’)
figure: matplotlib figure
The figure to be used. If not given a figure is created
ax: matplotlib axis
The axis to be used. If not given an axis is created
W: ActivityMapWidget
The output widget
spikewidgets.plot_rasters(sorting, sampling_frequency=None, unit_ids=None, trange=None, color='k', figure=None, ax=None)

Plots spike train rasters.

sorting: SortingExtractor
The sorting extractor object
sampling_frequency: float
The sampling frequency (if not in the sorting extractor)
unit_ids: list
List of unit ids
trange: list
List with start time and end time
color: matplotlib color
The color to be used
figure: matplotlib figure
The figure to be used. If not given a figure is created
ax: matplotlib axis
The axis to be used. If not given an axis is created
W: RasterWidget
The output widget
spikewidgets.plot_autocorrelograms(sorting, sampling_frequency=None, unit_ids=None, bin_size=2, window=50, figure=None, ax=None)

Plots spike train auto-correlograms.

sorting: SortingExtractor
The sorting extractor object
sampling_frequency: float
The sampling frequency (if not in the sorting extractor)
unit_ids: list
List of unit ids
bin_size: float
Bin size in s
window: float
Window size in s
figure: matplotlib figure
The figure to be used. If not given a figure is created
ax: matplotlib axis
The axis to be used. If not given an axis is created
W: AutoCorrelogramsWidget
The output widget
spikewidgets.plot_crosscorrelograms(sorting, sampling_frequency=None, unit_ids=None, bin_size=1, window=10, figure=None, ax=None)

Plots spike train cross-correlograms.

sorting: SortingExtractor
The sorting extractor object
sampling_frequency: float
The sampling frequency (if not in the sorting extractor)
unit_ids: list
List of unit ids
bin_size: float
Bin size in s
window: float
Window size in s
figure: matplotlib figure
The figure to be used. If not given a figure is created
ax: matplotlib axis
The axis to be used. If not given an axis is created
W: CrossCorrelogramsWidget
The output widget
spikewidgets.plot_isi_distribution(sorting, sampling_frequency=None, unit_ids=None, bins=10, window=1, figure=None, ax=None)

Plots spike train ISI distribution.

sorting: SortingExtractor
The sorting extractor object
sampling_frequency: float
The sampling frequency (if not in the sorting extractor)
unit_ids: list
List of unit ids
bins: int
Number of bins
window: float
Window size in s
figure: matplotlib figure
The figure to be used. If not given a figure is created
ax: matplotlib axis
The axis to be used. If not given an axis is created
W: ISIDistributionWidget
The output widget
spikewidgets.plot_unit_waveforms(recording, sorting, channel_ids=None, unit_ids=None, ms_before=1.0, ms_after=2.0, max_spikes_per_unit=100, max_channels=16, channel_locs=True, plot_templates=True, figure=None, ax=None)

Plots unit waveforms.

recording: RecordingExtractor
The recordng extractor object
sorting: SortingExtractor
The sorting extractor object
channel_ids: list
The channel ids to display.
unit_ids: list
List of unit ids.
ms_before: float
Time before peak (ms)
ms_after: float
Time after peak (ms)
max_spikes_per_unit: int
Maximum number of spikes to display per unit.
max_channels: int
Maximum number of largest channels to plot waveform
channel_locs: bool
If True, channel locations are used to display the waveforms. If False, waveforms are displayed in vertical order. (default)
plot_templates: bool
If True, templates are plotted over the waveforms
figure: matplotlib figure
The figure to be used. If not given a figure is created
ax: matplotlib axis
The axis to be used. If not given an axis is created
W: UnitWaveformsWidget
The output widget
spikewidgets.plot_unit_templates(recording, sorting, channel_ids=None, unit_ids=None, ms_before=1.0, ms_after=2.0, max_spikes_per_unit=100, max_channels=16, channel_locs=True, figure=None, ax=None)

Plots unit waveforms.

recording: RecordingExtractor
The recordng extractor object
sorting: SortingExtractor
The sorting extractor object
channel_ids: list
The channel ids to display.
unit_ids: list
List of unit ids.
ms_before: float
Time before peak (ms)
ms_after: float
Time after peak (ms)
max_spikes_per_unit: int
Maximum number of spikes to display per unit.
max_channels: int
Maximum number of largest channels to plot waveform
channel_locs: bool
If True, channel locations are used to display the waveforms. If False, waveforms are displayed in vertical order. (default)
figure: matplotlib figure
The figure to be used. If not given a figure is created
ax: matplotlib axis
The axis to be used. If not given an axis is created
W: UnitWaveformsWidget
The output widget
spikewidgets.plot_unit_template_maps(recording, sorting, channel_ids=None, unit_ids=None, peak='neg', log=False, ncols=10, ms_before=1.0, ms_after=2.0, max_spikes_per_unit=100, background='on', cmap='viridis', label_color='r', ax=None, figure=None)

Plots sorting comparison confusion matrix.

recording: RecordingExtractor
The recordng extractor object
sorting: SortingExtractor
The sorting extractor object
channel_ids: list
The channel ids to display.
unit_ids: list
List of unit ids.
peak: str
‘neg’, ‘pos’ or ‘both’
log: bool
If True, log scale is used
ncols: int
Number of columns if multiple units are displayed
ms_before: float
Time before peak (ms)
ms_after: float
Time after peak (ms)
max_spikes_per_unit: int
Maximum number of spikes to display per unit.
background: str
‘on’ or ‘off’
cmap: matplotlib colormap
The colormap to be used (default ‘viridis’)
label_color: matplotlib color
Color to display channel name upon click
figure: matplotlib figure
The figure to be used. If not given a figure is created
ax: matplotlib axis
The axis to be used. If not given an axis is created
W: ActivityMapWidget
The output widget
spikewidgets.plot_amplitudes_distribution(recording, sorting, unit_ids=None, max_spikes_per_unit=100, figure=None, ax=None)

Plots waveform amplitudes distribution.

recording: RecordingExtractor
The recording extractor object
sorting: SortingExtractor
The sorting extractor object
unit_ids: list
List of unit ids
max_spikes_per_unit: int
Maximum number of spikes to display per unit.
figure: matplotlib figure
The figure to be used. If not given a figure is created
ax: matplotlib axis
The axis to be used. If not given an axis is created
W: AmplitudeDistributionWidget
The output widget
spikewidgets.plot_amplitudes_timeseries(recording, sorting, unit_ids=None, max_spikes_per_unit=100, figure=None, ax=None)

Plots waveform amplitudes timeseries.

recording: RecordingExtractor
The recording extractor object
sorting: SortingExtractor
The sorting extractor object
unit_ids: list
List of unit ids
max_spikes_per_unit: int
Maximum number of spikes to display per unit.
figure: matplotlib figure
The figure to be used. If not given a figure is created
ax: matplotlib axis
The axis to be used. If not given an axis is created
W: AmplitudeTimeseriesWidget
The output widget
spikewidgets.plot_confusion_matrix(gt_comparison, count_text=True, unit_ticks=True, ax=None, figure=None)

Plots sorting comparison confusion matrix.

gt_comparison: GroundTruthComparison
The ground truth sorting comparison object
count_text: bool
If True counts are displayed as text
unit_ticks: bool
If True unit tick labels are displayed
figure: matplotlib figure
The figure to be used. If not given a figure is created
ax: matplotlib axis
The axis to be used. If not given an axis is created
W: ConfusionMatrixWidget
The output widget
spikewidgets.plot_agreement_matrix(sorting_comparison, ordered=True, count_text=True, unit_ticks=True, ax=None, figure=None)

Plots sorting comparison confusion matrix.

sorting_comparison: GroundTruthComparison or SymmetricSortingComparison
The sorting comparison object. Symetric or not.
ordered: bool
Order units with best agreement scores. This enable to see agreement on a diagonal.
count_text: bool
If True counts are displayed as text
unit_ticks: bool
If True unit tick labels are displayed
figure: matplotlib figure
The figure to be used. If not given a figure is created
ax: matplotlib axis
The axis to be used. If not given an axis is created
W: ConfusionMatrixWidget
The output widget
spikewidgets.plot_sorting_performance(gt_sorting_comparison, property_name=None, metric='accuracy', markersize=10, marker='.', figure=None, ax=None)

Plots sorting performance for each ground-truth unit.

gt_sorting_comparison: GroundTruthComparison
The ground truth sorting comparison object
property_name: str
The property of the sorting extractor to use as x-axis (e.g. snr). If None, no property is used.
metric: str
The performance metric. ‘accuracy’ (default), ‘precision’, ‘recall’, ‘miss rate’, etc.
markersize: int
The size of the marker
marker: str
The matplotlib marker to use (default ‘.’)
figure: matplotlib figure
The figure to be used. If not given a figure is created
ax: matplotlib axis
The axis to be used. If not given an axis is created
W: SortingPerformanceWidget
The output widget
spikewidgets.plot_multicomp_graph(multi_sorting_comparison, draw_labels=False, node_cmap='viridis', edge_cmap='hot_r', alpha_edges=0.7, colorbar=False, figure=None, ax=None)

Plots multi sorting comparison graph.

multi_sorting_comparison: MultiSortingComparison
The multi sorting comparison object
draw_labels: bool
If True unit labels are shown
node_cmap: matplotlib colormap
The colormap to be used for the nodes (default ‘viridis’)
edge_cmap: matplotlib colormap
The colormap to be used for the edges (default ‘hot’)
alpha_edges: float
Alpha value for edges
colorbar: bool
If True a colorbar for the edges is plotted
figure: matplotlib figure
The figure to be used. If not given a figure is created
ax: matplotlib axis
The axis to be used. If not given an axis is created
W: MultiCompGraphWidget
The output widget
spikewidgets.plot_multicomp_agreement(multi_sorting_comparison, plot_type='pie', cmap='YlOrRd', figure=None, ax=None)

Plots multi sorting comparison agreement as pie or bar plot.

multi_sorting_comparison: MultiSortingComparison
The multi sorting comparison object
plot_type: str
‘pie’ or ‘bar’
cmap: matplotlib colormap
The colormap to be used for the nodes (default ‘Reds’)
figure: matplotlib figure
The figure to be used. If not given a figure is created
ax: matplotlib axis
The axis to be used. If not given an axis is created
W: MultiCompGraphWidget
The output widget
spikewidgets.plot_multicomp_agreement_by_sorter(multi_sorting_comparison, plot_type='pie', cmap='YlOrRd', figure=None, ax=None)

Plots multi sorting comparison agreement as pie or bar plot.

multi_sorting_comparison: MultiSortingComparison
The multi sorting comparison object
plot_type: str
‘pie’ or ‘bar’
cmap: matplotlib colormap
The colormap to be used for the nodes (default ‘Reds’)
figure: matplotlib figure
The figure to be used. If not given a figure is created
ax: matplotlib axis
The axis to be used. If not given an axis is created
W: MultiCompGraphWidget
The output widget