def run(parameter_set,
plot=False,
display=False,
save=True,
debug=False,
online=True):
"""
:param parameter_set:
:param plot:
:param display:
:param save:
:param debug:
:param online:
:return:
"""
if not isinstance(parameter_set, ParameterSet):
if isinstance(parameter_set, basestring) or isinstance(
parameter_set, dict):
parameter_set = ParameterSet(parameter_set)
else:
raise TypeError(
"parameter_set must be ParameterSet, string with full path to parameter file or "
"dictionary")
# ##################################################################################################################
# Setup extra variables and parameters
# ==================================================================================================================
if plot:
set_global_rcParams(parameter_set.kernel_pars['mpl_path'])
paths = io.set_storage_locations(parameter_set, save)
np.random.seed(parameter_set.kernel_pars['np_seed'])
# ##################################################################################################################
# Set kernel and simulation parameters
# ==================================================================================================================
print('\nRuning ParameterSet {0}'.format(parameter_set.label))
nest.ResetKernel()
nest.set_verbosity('M_WARNING')
nest.SetKernelStatus(
extract_nestvalid_dict(parameter_set.kernel_pars.as_dict(),
param_type='kernel'))
# ##################################################################################################################
# Build network
# ==================================================================================================================
net = Network(parameter_set.net_pars)
net.merge_subpopulations([net.populations[0], net.populations[1]],
name='EI') # merge for EI case
# ##################################################################################################################
# Randomize initial variable values
# ==================================================================================================================
for idx, n in enumerate(list(iterate_obj_list(net.populations))):
if hasattr(parameter_set.net_pars, "randomize_neuron_pars"):
randomize = parameter_set.net_pars.randomize_neuron_pars[idx]
for k, v in randomize.items():
n.randomize_initial_states(k,
randomization_function=v[0],
**v[1])
# ##################################################################################################################
# Build Stimulus/Target datasets
# ==================================================================================================================
io.log_timer.start('stimulus_sets')
stim_set = StimulusSet(parameter_set, unique_set=False)
stim_set.generate_datasets(parameter_set.stim_pars)
target_set = StimulusSet(parameter_set,
unique_set=False) # for identity task.
output_sequence = list(itertools.chain(*stim_set.full_set_labels))
target_set.generate_datasets(parameter_set.stim_pars,
external_sequence=output_sequence)
# correct N for small sequences
# parameter_set.input_pars.signal.N = len(np.unique(stim_set.full_set_labels))
io.log_timer.stop('stimulus_sets')
# ##################################################################################################################
# Build Input Signal Sets
# ==================================================================================================================
io.log_timer.start('input_sets')
inputs = InputSignalSet(parameter_set, stim_set, online=online)
inputs.generate_datasets(stim_set)
io.log_timer.stop('input_sets')
parameter_set.kernel_pars.sim_time = inputs.train_stimulation_time + inputs.test_stimulation_time
# Plot example signal
if plot and debug and not online:
plot_input_example(stim_set,
inputs,
set_name='test',
display=display,
save=paths['figures'] + paths['label'])
if save:
stim_set.save(paths['inputs'])
if debug:
inputs.save(paths['inputs'])
# ##################################################################################################################
# Encode Input
# ==================================================================================================================
io.log_timer.start('encoding_layer')
enc_layer = EncodingLayer(parameter_set.encoding_pars,
signal=inputs.full_set_signal,
online=online)
enc_layer.connect(parameter_set.encoding_pars, net)
enc_layer.extract_connectivity(net, sub_set=True, progress=False)
io.log_timer.stop('encoding_layer')
# ##################################################################################################################
# Connect Network
# ==================================================================================================================
io.log_timer.start('connection_setup')
net.connect_populations(parameter_set.connection_pars)
# ##################################################################################################################
# Set-up Analysis
# ==================================================================================================================
net.connect_devices()
if hasattr(parameter_set, "decoding_pars"):
set_decoder_times(
enc_layer, parameter_set.input_pars, parameter_set.encoding_pars,
parameter_set.decoding_pars) # iff using the fast sampling method!
net.connect_decoders(parameter_set.decoding_pars)
# Attach decoders to input encoding populations
if not empty(enc_layer.encoders) and hasattr(parameter_set.encoding_pars, "input_decoder") and \
parameter_set.encoding_pars.input_decoder is not None:
enc_layer.connect_decoders(parameter_set.encoding_pars.input_decoder)
io.log_timer.stop('connection_setup')
# ##################################################################################################################
# Run Simulation (full sequence)
# ==================================================================================================================
# fast state sampling
io.log_timer.start('process_sequence')
epochs, timing = process_input_sequence(parameter_set,
net, [enc_layer], [stim_set],
[inputs],
set_name='full',
record=True)
io.log_timer.stop('process_sequence')
# ##################################################################################################################
# Process data
# ==================================================================================================================
io.log_timer.start('process_data')
target_matrix = dict(EI=np.array(target_set.full_set.todense()))
results = process_states(net,
target_matrix,
stim_set,
data_sets=None,
save=save,
accepted_idx=None,
plot=plot,
display=display,
save_paths=paths)
results.update({'timing_info': timing, 'epochs': epochs})
processed_results = dict()
for ctr, n_pop in enumerate(
list(
itertools.chain(*[
net.merged_populations, net.populations, enc_layer.encoders
]))):
if n_pop.decoding_layer is not None:
processed_results.update({n_pop.name: {}})
dec_layer = n_pop.decoding_layer
for idx_var, var in enumerate(dec_layer.state_variables):
processed_results[n_pop.name].update({
var:
compile_performance_results(dec_layer.readouts[idx_var],
var)
})
# The labels are often not properly ordered
readout_labels = processed_results[n_pop.name][var]['labels']
all_indices = np.array([
int(''.join(c for c in x if c.isdigit()))
for x in readout_labels
])
ordered_indices = np.argsort(all_indices)
# Extract and plot example results
if plot:
ordered_accuracy = processed_results[
n_pop.name][var]['accuracy'][ordered_indices]
fig, ax = pl.subplots()
ax.plot(all_indices[ordered_indices],
ordered_accuracy,
'o-',
lw=2)
ax.plot(
all_indices[ordered_indices],
np.ones_like(ordered_accuracy) * 1. /
parameter_set.stim_pars.n_stim, '--r')
ax.set_xlabel(r'$lag [n]$')
ax.set_ylabel(r'Accuracy')
if display:
pl.show(False)
if save:
fig.savefig(paths['figures'] + paths['label'])
results.update({'processed_results': processed_results})
io.log_timer.stop('process_data')
# ##################################################################################################################
# Save data
# ==================================================================================================================
if save:
with open(paths['results'] + 'Results_' + parameter_set.label,
'w') as f:
pickle.dump(results, f)
parameter_set.save(paths['parameters'] + 'Parameters_' +
parameter_set.label)
def run(parameter_set, plot=False, display=False, save=True):
"""
:param parameter_set:
:param plot:
:param display:
:param save:
:return:
"""
if not isinstance(parameter_set, ParameterSet):
if isinstance(parameter_set, basestring) or isinstance(
parameter_set, dict):
parameter_set = ParameterSet(parameter_set)
else:
raise TypeError(
"parameter_set must be ParameterSet, string with full path to parameter file or "
"dictionary")
# ######################################################################################################################
# Setup extra variables and parameters
# ======================================================================================================================
if plot:
set_global_rcParams(parameter_set.kernel_pars['mpl_path'])
paths = set_storage_locations(parameter_set, save)
np.random.seed(parameter_set.kernel_pars['np_seed'])
results = dict()
# ######################################################################################################################
# Set kernel and simulation parameters
# ======================================================================================================================
print('\nRuning ParameterSet {0}'.format(parameter_set.label))
nest.ResetKernel()
nest.set_verbosity('M_WARNING')
nest.SetKernelStatus(
extract_nestvalid_dict(parameter_set.kernel_pars.as_dict(),
param_type='kernel'))
# ######################################################################################################################
# Build network
# ======================================================================================================================
net = Network(parameter_set.net_pars)
# ######################################################################################################################
# Randomize initial variable values
# ======================================================================================================================
for idx, n in enumerate(list(iterate_obj_list(net.populations))):
if hasattr(parameter_set.net_pars, "randomize_neuron_pars"):
randomize = parameter_set.net_pars.randomize_neuron_pars[idx]
for k, v in randomize.items():
n.randomize_initial_states(k,
randomization_function=v[0],
**v[1])
# ######################################################################################################################
# Build and connect input
# ======================================================================================================================
# Poisson input
enc_layer = EncodingLayer(parameter_set.encoding_pars)
enc_layer.connect(parameter_set.encoding_pars, net)
# ######################################################################################################################
# Set-up Analysis
# ======================================================================================================================
net.connect_devices()
# ######################################################################################################################
# Connect Network
# ======================================================================================================================
net.connect_populations(parameter_set.connection_pars, progress=True)
# ######################################################################################################################
# Simulate
# ======================================================================================================================
if parameter_set.kernel_pars.transient_t:
net.simulate(parameter_set.kernel_pars.transient_t)
net.flush_records()
net.simulate(parameter_set.kernel_pars.sim_time)
# ######################################################################################################################
# Extract and store data
# ======================================================================================================================
net.extract_population_activity()
net.extract_network_activity()
net.flush_records()
# ######################################################################################################################
# Analyse / plot data
# ======================================================================================================================
analysis_interval = [
parameter_set.kernel_pars.transient_t,
parameter_set.kernel_pars.sim_time +
parameter_set.kernel_pars.transient_t
]
parameter_set.analysis_pars.pop('label')
start_analysis = time.time()
results.update(
characterize_population_activity(
net,
parameter_set,
analysis_interval,
epochs=None,
color_map='jet',
plot=plot,
display=display,
save=paths['figures'] + paths['label'],
color_subpop=True,
analysis_pars=parameter_set.analysis_pars))
print("\nElapsed time (state characterization): {0}".format(
str(time.time() - start_analysis)))
# ######################################################################################################################
# Save data
# ======================================================================================================================
if save:
with open(paths['results'] + 'Results_' + parameter_set.label,
'w') as f:
pickle.dump(results, f)
parameter_set.save(paths['parameters'] + 'Parameters_' +
parameter_set.label)
def run(parameter_set, plot=False, display=False, save=True):
"""
Compute single neuron fI curves
:param parameter_set: must be consistent with the computation
:param plot: plot results - either show them or save to file
:param display: show figures/reports
:param save: save results
:return results_dictionary:
"""
if not isinstance(parameter_set, ParameterSet):
if isinstance(parameter_set, basestring) or isinstance(
parameter_set, dict):
parameter_set = ParameterSet(parameter_set)
else:
raise TypeError(
"parameter_set must be ParameterSet, string with full path to parameter file or "
"dictionary")
# ##################################################################################################################
# Setup extra variables and parameters
# ==================================================================================================================
if plot:
vis.set_global_rcParams(parameter_set.kernel_pars['mpl_path'])
paths = set_storage_locations(parameter_set, save)
np.random.seed(parameter_set.kernel_pars['np_seed'])
# ##################################################################################################################
# Set kernel and simulation parameters
# ==================================================================================================================
print('\nRuning ParameterSet {0}'.format(parameter_set.label))
nest.ResetKernel()
nest.set_verbosity('M_WARNING')
nest.SetKernelStatus(
extract_nestvalid_dict(parameter_set.kernel_pars.as_dict(),
param_type='kernel'))
# ##################################################################################################################
# Build network
# ==================================================================================================================
net = Network(parameter_set.net_pars)
# ##################################################################################################################
# Randomize initial variable values
# ==================================================================================================================
for idx, n in enumerate(list(iterate_obj_list(net.populations))):
if hasattr(parameter_set.net_pars, "randomize_neuron_pars"):
randomize = parameter_set.net_pars.randomize_neuron_pars[idx]
for k, v in randomize.items():
n.randomize_initial_states(k,
randomization_function=v[0],
**v[1])
####################################################################################################################
# Build Input Signal Sets
# ==================================================================================================================
assert hasattr(parameter_set, "input_pars")
total_stimulation_time = parameter_set.kernel_pars.sim_time + parameter_set.kernel_pars.transient_t
# Current input (need to build 2 separate noise signals for the 2 input channels)
# Generate input for channel 1
input_noise_ch1 = InputNoise(parameter_set.input_pars.noise,
rng=np.random,
stop_time=total_stimulation_time)
input_noise_ch1.generate()
input_noise_ch1.re_seed(parameter_set.kernel_pars.np_seed)
# Generate input for channel 2
input_noise_ch2 = InputNoise(parameter_set.input_pars.noise,
rng=np.random,
stop_time=total_stimulation_time)
input_noise_ch2.generate()
input_noise_ch2.re_seed(parameter_set.kernel_pars.np_seed)
if plot:
inp_plot = vis.InputPlots(stim_obj=None,
input_obj=None,
noise_obj=input_noise_ch1)
inp_plot.plot_noise_component(display=display,
save=paths['figures'] +
"/InputNoise_CH1")
inp_plot = vis.InputPlots(stim_obj=None,
input_obj=None,
noise_obj=input_noise_ch2)
inp_plot.plot_noise_component(display=display,
save=paths['figures'] +
"/InputNoise_CH2")
# ##################################################################################################################
# Build and connect input
# ==================================================================================================================
enc_layer_ch1 = EncodingLayer(parameter_set.encoding_ch1_pars,
signal=input_noise_ch1)
enc_layer_ch1.connect(parameter_set.encoding_ch1_pars, net)
enc_layer_ch2 = EncodingLayer(parameter_set.encoding_ch2_pars,
signal=input_noise_ch2)
enc_layer_ch2.connect(parameter_set.encoding_ch2_pars, net)
# ##################################################################################################################
# Connect Devices
# ==================================================================================================================
net.connect_devices()
# ##################################################################################################################
# Simulate
# ==================================================================================================================
if parameter_set.kernel_pars.transient_t:
net.simulate(parameter_set.kernel_pars.transient_t)
net.flush_records()
net.simulate(parameter_set.kernel_pars.sim_time +
nest.GetKernelStatus()['resolution'])
# ##################################################################################################################
# Extract and store data
# ==================================================================================================================
net.extract_population_activity(
t_start=parameter_set.kernel_pars.transient_t,
t_stop=parameter_set.kernel_pars.sim_time +
parameter_set.kernel_pars.transient_t)
net.extract_network_activity()
# ##################################################################################################################
# Analyse / plot data
# ==================================================================================================================
results = dict()
analysis_interval = [
parameter_set.kernel_pars.transient_t,
parameter_set.kernel_pars.transient_t +
parameter_set.kernel_pars.sim_time
]
for idd, nam in enumerate(net.population_names):
results.update({nam: {}})
results[nam] = single_neuron_responses(net.populations[idd],
parameter_set,
pop_idx=idd,
start=analysis_interval[0],
stop=analysis_interval[1],
plot=plot,
display=display,
save=paths['figures'] +
paths['label'])
if results[nam]['rate']:
print('Output Rate [{0}] = {1} spikes/s'.format(
str(nam), str(results[nam]['rate'])))
# ##################################################################################################################
# Save data
# ==================================================================================================================
if save:
with open(paths['results'] + 'Results_' + parameter_set.label,
'w') as f:
pickle.dump(results, f)
parameter_set.save(paths['parameters'] + 'Parameters_' +
parameter_set.label)
def __initialize_test_data(params_file_):
plot = False
display = True
save = True
# ##################################################################################################################
# Extract parameters from file and build global ParameterSet
# ==================================================================================================================
parameter_set = ParameterSpace(params_file_)[0]
parameter_set = parameter_set.clean(termination='pars')
if not isinstance(parameter_set, ParameterSet):
if isinstance(parameter_set, basestring) or isinstance(
parameter_set, dict):
parameter_set = ParameterSet(parameter_set)
else:
raise TypeError(
"parameter_set must be ParameterSet, string with full path to parameter file or dictionary"
)
# ######################################################################################################################
# Setup extra variables and parameters
# ======================================================================================================================
if plot:
import modules.visualization as vis
vis.set_global_rcParams(parameter_set.kernel_pars['mpl_path'])
paths = set_storage_locations(parameter_set, save)
np.random.seed(parameter_set.kernel_pars['np_seed'])
results = dict()
# ######################################################################################################################
# Set kernel and simulation parameters
# ======================================================================================================================
print '\nRuning ParameterSet {0}'.format(parameter_set.label)
nest.ResetKernel()
nest.set_verbosity('M_WARNING')
nest.SetKernelStatus(
extract_nestvalid_dict(parameter_set.kernel_pars.as_dict(),
param_type='kernel'))
# ######################################################################################################################
# Build network
# ======================================================================================================================
net = Network(parameter_set.net_pars)
# ######################################################################################################################
# Randomize initial variable values
# ======================================================================================================================
for idx, n in enumerate(list(iterate_obj_list(net.populations))):
if hasattr(parameter_set.net_pars, "randomize_neuron_pars"):
randomize = parameter_set.net_pars.randomize_neuron_pars[idx]
for k, v in randomize.items():
n.randomize_initial_states(k,
randomization_function=v[0],
**v[1])
# ######################################################################################################################
# Build and connect input
# ======================================================================================================================
enc_layer = EncodingLayer(parameter_set.encoding_pars)
enc_layer.connect(parameter_set.encoding_pars, net)
# ######################################################################################################################
# Set-up Analysis
# ======================================================================================================================
net.connect_devices()
# ######################################################################################################################
# Simulate
# ======================================================================================================================
if parameter_set.kernel_pars.transient_t:
net.simulate(parameter_set.kernel_pars.transient_t)
net.flush_records()
net.simulate(parameter_set.kernel_pars.sim_time +
nest.GetKernelStatus()['resolution'])
# ######################################################################################################################
# Extract and store data
# ======================================================================================================================
net.extract_population_activity(
t_start=parameter_set.kernel_pars.transient_t +
nest.GetKernelStatus()['resolution'],
t_stop=parameter_set.kernel_pars.sim_time +
parameter_set.kernel_pars.transient_t)
net.extract_network_activity()
net.flush_records()
# ######################################################################################################################
# Analyse / plot data
# ======================================================================================================================
analysis_interval = [
parameter_set.kernel_pars.transient_t +
nest.GetKernelStatus()['resolution'],
parameter_set.kernel_pars.sim_time +
parameter_set.kernel_pars.transient_t
]
for idd, nam in enumerate(net.population_names):
results.update({nam: {}})
results[nam] = single_neuron_dcresponse(net.populations[idd],
parameter_set,
start=analysis_interval[0],
stop=analysis_interval[1],
plot=plot,
display=display,
save=paths['figures'] +
paths['label'])
idx = np.min(np.where(results[nam]['output_rate']))
print "Rate range for neuron {0} = [{1}, {2}] Hz".format(
str(nam),
str(
np.min(results[nam]['output_rate'][
results[nam]['output_rate'] > 0.])),
str(
np.max(results[nam]['output_rate'][
results[nam]['output_rate'] > 0.])))
results[nam].update({
'min_rate':
np.min(
results[nam]['output_rate'][results[nam]['output_rate'] > 0.]),
'max_rate':
np.max(
results[nam]['output_rate'][results[nam]['output_rate'] > 0.])
})
print "Rheobase Current for neuron {0} in [{1}, {2}]".format(
str(nam), str(results[nam]['input_amplitudes'][idx - 1]),
str(results[nam]['input_amplitudes'][idx]))
x = np.array(results[nam]['input_amplitudes'])
y = np.array(results[nam]['output_rate'])
iddxs = np.where(y)
slope, intercept, r_value, p_value, std_err = stats.linregress(
x[iddxs], y[iddxs])
print "fI Slope for neuron {0} = {1} Hz/nA [linreg method]".format(
nam, str(slope * 1000.))
results[nam].update({
'fI_slope':
slope * 1000.,
'I_rh': [
results[nam]['input_amplitudes'][idx - 1],
results[nam]['input_amplitudes'][idx]
]
})
data = dict()
data['connections_from'] = {
pop.name: nest.GetConnections(source=pop.gids)
for (idx, pop) in enumerate(net.populations)
}
data['connections_to'] = {
pop.name: nest.GetConnections(target=pop.gids)
for (idx, pop) in enumerate(net.populations)
}
data['results'] = results
return data
def __initialize_test_data(params_file_):
plot = False
display = True
save = True
# ##################################################################################################################
# Extract parameters from file and build global ParameterSet
# ==================================================================================================================
parameter_set = ParameterSpace(params_file_)[0]
parameter_set = parameter_set.clean(termination='pars')
if not isinstance(parameter_set, ParameterSet):
if isinstance(parameter_set, basestring) or isinstance(
parameter_set, dict):
parameter_set = ParameterSet(parameter_set)
else:
raise TypeError(
"parameter_set must be ParameterSet, string with full path to parameter file or dictionary"
)
# ##################################################################################################################
# Setup extra variables and parameters
# ==================================================================================================================
if plot:
set_global_rcParams(parameter_set.kernel_pars['mpl_path'])
paths = set_storage_locations(parameter_set, save)
np.random.seed(parameter_set.kernel_pars['np_seed'])
# ##################################################################################################################
# Set kernel and simulation parameters
# ==================================================================================================================
print '\nRuning ParameterSet {0}'.format(parameter_set.label)
nest.ResetKernel()
nest.set_verbosity('M_WARNING')
nest.SetKernelStatus(
extract_nestvalid_dict(parameter_set.kernel_pars.as_dict(),
param_type='kernel'))
# ##################################################################################################################
# Build network
# ==================================================================================================================
net = Network(parameter_set.net_pars)
# ##################################################################################################################
# Randomize initial variable values
# ==================================================================================================================
for idx, n in enumerate(list(iterate_obj_list(net.populations))):
if hasattr(parameter_set.net_pars, "randomize_neuron_pars"):
randomize = parameter_set.net_pars.randomize_neuron_pars[idx]
for k, v in randomize.items():
n.randomize_initial_states(k,
randomization_function=v[0],
**v[1])
####################################################################################################################
# Build Input Signal Sets
# ==================================================================================================================
assert hasattr(parameter_set, "input_pars")
total_stimulation_time = parameter_set.kernel_pars.sim_time + parameter_set.kernel_pars.transient_t
# Current input (need to build 2 separate noise signals for the 2 input channels)
# Generate input for channel 1
input_noise_ch1 = InputNoise(parameter_set.input_pars.noise,
rng=np.random,
stop_time=total_stimulation_time)
input_noise_ch1.generate()
input_noise_ch1.re_seed(parameter_set.kernel_pars.np_seed)
# Generate input for channel 2
input_noise_ch2 = InputNoise(parameter_set.input_pars.noise,
rng=np.random,
stop_time=total_stimulation_time)
input_noise_ch2.generate()
input_noise_ch2.re_seed(parameter_set.kernel_pars.np_seed)
if plot:
inp_plot = InputPlots(stim_obj=None,
input_obj=None,
noise_obj=input_noise_ch1)
inp_plot.plot_noise_component(display=display,
save=paths['figures'] +
"/InputNoise_CH1")
inp_plot = InputPlots(stim_obj=None,
input_obj=None,
noise_obj=input_noise_ch2)
inp_plot.plot_noise_component(display=display,
save=paths['figures'] +
"/InputNoise_CH2")
# ##################################################################################################################
# Build and connect input
# ==================================================================================================================
enc_layer_ch1 = EncodingLayer(parameter_set.encoding_ch1_pars,
signal=input_noise_ch1)
enc_layer_ch1.connect(parameter_set.encoding_ch1_pars, net)
enc_layer_ch2 = EncodingLayer(parameter_set.encoding_ch2_pars,
signal=input_noise_ch2)
enc_layer_ch2.connect(parameter_set.encoding_ch2_pars, net)
# ##################################################################################################################
# Connect Devices
# ==================================================================================================================
net.connect_devices()
# ##################################################################################################################
# Simulate
# ==================================================================================================================
if parameter_set.kernel_pars.transient_t:
net.simulate(parameter_set.kernel_pars.transient_t)
net.flush_records()
net.simulate(parameter_set.kernel_pars.sim_time +
nest.GetKernelStatus()['resolution'])
# ##################################################################################################################
# Extract and store data
# ==================================================================================================================
net.extract_population_activity(
t_start=parameter_set.kernel_pars.transient_t,
t_stop=parameter_set.kernel_pars.sim_time +
parameter_set.kernel_pars.transient_t)
net.extract_network_activity()
# ##################################################################################################################
# Analyse / plot data
# ==================================================================================================================
analysis_interval = [
parameter_set.kernel_pars.transient_t,
parameter_set.kernel_pars.transient_t +
parameter_set.kernel_pars.sim_time
]
results = dict()
for idd, nam in enumerate(net.population_names):
results.update({nam: {}})
results[nam] = single_neuron_responses(net.populations[idd],
parameter_set,
pop_idx=idd,
start=analysis_interval[0],
stop=analysis_interval[1],
plot=plot,
display=display,
save=paths['figures'] +
paths['label'])
if results[nam]['rate']:
print('Output Rate [{0}] = {1} spikes/s'.format(
str(nam), str(results[nam]['rate'])))
# ######################################################################################################################
# Save data
# ======================================================================================================================
data = dict()
data['connections_from'] = {
pop.name: nest.GetConnections(source=pop.gids)
for (idx, pop) in enumerate(net.populations)
}
data['connections_to'] = {
pop.name: nest.GetConnections(target=pop.gids)
for (idx, pop) in enumerate(net.populations)
}
data['results'] = results
data['input'] = {
'channel1': input_noise_ch1.noise_signal.analog_signals[.0].signal,
'channel2': input_noise_ch2.noise_signal.analog_signals[.0].signal
}
data['network'] = {
'populations': {
net.populations[0].name: net.populations[0]
}
}
return data
print('\nRuning ParameterSet {0}'.format(parameter_set.label))
nest.ResetKernel()
nest.set_verbosity('M_WARNING')
nest.SetKernelStatus(
extract_nestvalid_dict(parameter_set.kernel_pars.as_dict(),
param_type='kernel'))
# ######################################################################################################################
# Build network
# ======================================================================================================================
net = Network(parameter_set.net_pars)
# ######################################################################################################################
# Randomize initial variable values
# ======================================================================================================================
for idx, n in enumerate(list(iterate_obj_list(net.populations))):
if hasattr(parameter_set.net_pars, "randomize_neuron_pars"):
randomize = parameter_set.net_pars.randomize_neuron_pars[idx]
for k, v in randomize.items():
n.randomize_initial_states(k, randomization_function=v[0], **v[1])
# ######################################################################################################################
# Build and connect input
# ======================================================================================================================
# Poisson input
enc_layer = EncodingLayer(parameter_set.encoding_pars)
enc_layer.connect(parameter_set.encoding_pars, net)
# ######################################################################################################################
# Set-up Analysis
# ======================================================================================================================
def run(parameter_set, plot=False, display=False, save=True):
"""
Compute single neuron fI curves
:param parameter_set: must be consistent with the computation
:param plot: plot results - either show them or save to file
:param display: show figures/reports
:param save: save results
:return results_dictionary:
"""
if not isinstance(parameter_set, ParameterSet):
if isinstance(parameter_set, basestring) or isinstance(
parameter_set, dict):
parameter_set = ParameterSet(parameter_set)
else:
raise TypeError(
"parameter_set must be ParameterSet, string with full path to parameter file or "
"dictionary")
# ######################################################################################################################
# Setup extra variables and parameters
# ======================================================================================================================
if plot:
vis.set_global_rcParams(parameter_set.kernel_pars['mpl_path'])
paths = set_storage_locations(parameter_set, save)
np.random.seed(parameter_set.kernel_pars['np_seed'])
results = dict()
# ######################################################################################################################
# Set kernel and simulation parameters
# ======================================================================================================================
print('\nRuning ParameterSet {0}'.format(parameter_set.label))
nest.ResetKernel()
nest.set_verbosity('M_WARNING')
nest.SetKernelStatus(
extract_nestvalid_dict(parameter_set.kernel_pars.as_dict(),
param_type='kernel'))
# ######################################################################################################################
# Build network
# ======================================================================================================================
net = Network(parameter_set.net_pars)
# ######################################################################################################################
# Randomize initial variable values
# ======================================================================================================================
for idx, n in enumerate(list(iterate_obj_list(net.populations))):
if hasattr(parameter_set.net_pars, "randomize_neuron_pars"):
randomize = parameter_set.net_pars.randomize_neuron_pars[idx]
for k, v in randomize.items():
n.randomize_initial_states(k,
randomization_function=v[0],
**v[1])
# ######################################################################################################################
# Build and connect input
# ======================================================================================================================
enc_layer = EncodingLayer(parameter_set.encoding_pars)
enc_layer.connect(parameter_set.encoding_pars, net)
# ######################################################################################################################
# Set-up Analysis
# ======================================================================================================================
net.connect_devices()
# ######################################################################################################################
# Simulate
# ======================================================================================================================
if parameter_set.kernel_pars.transient_t:
net.simulate(parameter_set.kernel_pars.transient_t)
net.flush_records()
net.simulate(parameter_set.kernel_pars.sim_time +
nest.GetKernelStatus()['resolution'])
# ######################################################################################################################
# Extract and store data
# ======================================================================================================================
net.extract_population_activity(
t_start=parameter_set.kernel_pars.transient_t +
nest.GetKernelStatus()['resolution'],
t_stop=parameter_set.kernel_pars.sim_time +
parameter_set.kernel_pars.transient_t)
net.extract_network_activity()
net.flush_records()
# ######################################################################################################################
# Analyse / plot data
# ======================================================================================================================
analysis_interval = [
parameter_set.kernel_pars.transient_t +
nest.GetKernelStatus()['resolution'],
parameter_set.kernel_pars.sim_time +
parameter_set.kernel_pars.transient_t
]
for idd, nam in enumerate(net.population_names):
results.update({nam: {}})
results[nam] = single_neuron_dcresponse(net.populations[idd],
parameter_set,
start=analysis_interval[0],
stop=analysis_interval[1],
plot=plot,
display=display,
save=paths['figures'] +
paths['label'])
idx = np.min(np.where(results[nam]['output_rate']))
print("Rate range for neuron {0} = [{1}, {2}] Hz".format(
str(nam),
str(
np.min(results[nam]['output_rate'][
results[nam]['output_rate'] > 0.])),
str(
np.max(results[nam]['output_rate'][
results[nam]['output_rate'] > 0.]))))
results[nam].update({
'min_rate':
np.min(
results[nam]['output_rate'][results[nam]['output_rate'] > 0.]),
'max_rate':
np.max(
results[nam]['output_rate'][results[nam]['output_rate'] > 0.])
})
print("Rheobase Current for neuron {0} in [{1}, {2}]".format(
str(nam), str(results[nam]['input_amplitudes'][idx - 1]),
str(results[nam]['input_amplitudes'][idx])))
x = np.array(results[nam]['input_amplitudes'])
y = np.array(results[nam]['output_rate'])
iddxs = np.where(y)
slope, intercept, r_value, p_value, std_err = stats.linregress(
x[iddxs], y[iddxs])
print("fI Slope for neuron {0} = {1} Hz/nA [linreg method]".format(
nam, str(slope * 1000.)))
results[nam].update({
'fI_slope':
slope * 1000.,
'I_rh': [
results[nam]['input_amplitudes'][idx - 1],
results[nam]['input_amplitudes'][idx]
]
})
# ######################################################################################################################
# Save data
# ======================================================================================================================
if save:
with open(paths['results'] + 'Results_' + parameter_set.label,
'w') as f:
pickle.dump(results, f)
parameter_set.save(paths['parameters'] + 'Parameters_' +
parameter_set.label)