def add_input_decoders(encoding_pars, input_decoder_pars, kernel_pars):
"""
Updates encoding parameters, adding decoders to the encoding layer
:param encoding_pars: original encoding parameters to update
:param encoder_label: label of encoder to readout
:param input_decoder_pars: parameters of decoder to attach
:param kernel_pars: main system parameters
:return: updates encoding ParameterSet
"""
if not isinstance(input_decoder_pars, ParameterSet):
input_decoder_pars = ParameterSet(input_decoder_pars)
if isinstance(encoding_pars, ParameterSet):
encoding_pars = encoding_pars.as_dict()
if encoding_pars['input_decoder'] is not None:
enc_label = encoding_pars['input_decoder'].pop('encoder_label')
else:
enc_label = 'parrots'
encoding_pars['input_decoder'] = {}
decoder_dict = copy_dict(
input_decoder_pars.as_dict(), {
'decoded_population':
[enc_label for _ in range(len(input_decoder_pars.state_variable))]
})
resolution = decoder_dict.pop('output_resolution')
input_decoder = set_decoding_defaults(output_resolution=resolution,
kernel_pars=kernel_pars,
**decoder_dict)
encoding_pars.update({'input_decoder': input_decoder.as_dict()})
return ParameterSet(encoding_pars)
def rec_device_defaults(start=0.,
stop=sys.float_info.max,
resolution=0.1,
record_to='memory',
device_type='spike_detector',
label=''):
"""
Standard device parameters
:param default_set:
:return:
"""
rec_devices = {
'start': start,
'stop': stop,
'origin': 0.,
'interval': resolution,
'record_to': [record_to],
'label': label,
'model': device_type,
'close_after_simulate': False,
'flush_after_simulate': False,
'flush_records': False,
'close_on_reset': True,
'withtime': True,
'withgid': True,
'withweight': False,
'time_in_steps': False,
'scientific': False,
'precision': 3,
'binary': False,
}
return ParameterSet(rec_devices)
def set_kernel_defaults(run_type='local', data_label='', **system_pars):
"""
Return pre-defined kernel parameters dictionary
:param default_set:
:return:
"""
keys = [
'nodes', 'ppn', 'mem', 'walltime', 'queue', 'sim_time',
'transient_time'
]
if not np.mean(np.sort(system_pars.keys()) == np.sort(keys)).astype(bool):
raise TypeError(
"system parameters dictionary must contain the following keys {0}".
format(str(keys)))
N_vp = system_pars['nodes'] * system_pars['ppn']
np_seed = np.random.randint(1000000000) + 1
np.random.seed(np_seed)
msd = np.random.randint(100000000000)
kernel_pars = {
'resolution': 0.1,
'sim_time': system_pars['sim_time'],
'transient_t': system_pars['transient_time'],
'data_prefix': data_label,
'data_path': paths[run_type]['data_path'],
'mpl_path': paths[run_type]['matplotlib_rc'],
'overwrite_files': True,
'print_time': (run_type == 'local'),
'rng_seeds': range(msd + N_vp + 1, msd + 2 * N_vp + 1),
'grng_seed': msd + N_vp,
'total_num_virtual_procs': N_vp,
'local_num_threads': system_pars['ppn'],
'np_seed': np_seed,
'system': {
'local': (run_type == 'local'),
'system_label': run_type,
'queueing_system': paths[run_type]['queueing_system'],
'jdf_template': paths[run_type]['jdf_template'],
'remote_directory': paths[run_type]['remote_directory'],
'jdf_fields': {
'{{ script_folder }}': '',
'{{ nodes }}': str(system_pars['nodes']),
'{{ ppn }}': str(system_pars['ppn']),
'{{ mem }}': str(system_pars['mem']),
'{{ walltime }}': system_pars['walltime'],
'{{ queue }}': system_pars['queue'],
'{{ computation_script }}': ''
}
}
}
return ParameterSet(kernel_pars)
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,
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):
"""
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
display = True
save = True
debug = False
# ######################################################################################################################
# Extract parameters from file and build global ParameterSet
# ======================================================================================================================
params_file = '../parameters/noise_driven_dynamics.py'
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'])
results = dict()
def build_parameters(max_current):
# ##################################################################################################################
# DC input parameters
# ==================================================================================================================
sim_res = 0.1
total_time = 10000. + sim_res # total simulation time [ms]
analysis_interval = 1000. # duration of each current step [ms]
min_current = 0. # initial current amplitude [pA]
# max_current = 600. # final current amplitude [pA]
# specify input times and input amplitudes
times = list(np.arange(0.1, total_time, analysis_interval))
amplitudes = list(np.linspace(min_current, max_current, len(times)))
# ##################################################################################################################
# System / Kernel Parameters
# ##################################################################################################################
# system-specific parameters (resource allocation, simulation times)
system_pars = dict(nodes=1,
ppn=8,
mem=32,
walltime='00:20:00:00',
queue='singlenode',
transient_time=0.,
sim_time=total_time)
# seeds for rngs
N_vp = system_pars['nodes'] * system_pars['ppn']
np_seed = np.random.randint(1000000000) + 1
np.random.seed(np_seed)
msd = np.random.randint(100000000000)
# main kernel parameter set
kernel_pars = ParameterSet({
'resolution':
sim_res,
'sim_time':
total_time,
'transient_t':
0.,
'data_prefix':
data_label,
'data_path':
paths[system_name]['data_path'],
'mpl_path':
paths[system_name]['matplotlib_rc'],
'overwrite_files':
True,
'print_time': (system_name == 'local'),
'rng_seeds':
range(msd + N_vp + 1, msd + 2 * N_vp + 1),
'grng_seed':
msd + N_vp,
'total_num_virtual_procs':
N_vp,
'local_num_threads':
16,
'np_seed':
np_seed,
'system': {
'local': (system_name == 'local'),
'system_label': system_name,
'queueing_system': paths[system_name]['queueing_system'],
'jdf_template': paths[system_name]['jdf_template'],
'remote_directory': paths[system_name]['remote_directory'],
'jdf_fields': {
'{{ script_folder }}': '',
'{{ nodes }}': str(system_pars['nodes']),
'{{ ppn }}': str(system_pars['ppn']),
'{{ mem }}': str(system_pars['mem']),
'{{ walltime }}': system_pars['walltime'],
'{{ queue }}': system_pars['queue'],
'{{ computation_script }}': ''
}
}
})
# ##################################################################################################################
# Recording devices
# ##################################################################################################################
multimeter = {
'start': 0.,
'stop': sys.float_info.max,
'origin': 0.,
'interval': 0.1,
'record_to': ['memory'],
'label': '',
'model': 'multimeter',
'close_after_simulate': False,
'flush_after_simulate': False,
'flush_records': False,
'close_on_reset': True,
'withtime': True,
'withgid': True,
'withweight': False,
'time_in_steps': False,
'scientific': False,
'precision': 3,
'binary': False,
}
# ##################################################################################################################
# Neuron, Synapse and Network Parameters
# ##################################################################################################################
neuron_pars = {
'AdEx': {
'model': 'aeif_cond_exp',
'C_m': 250.0,
'Delta_T': 2.0,
'E_L': -70.,
'E_ex': 0.0,
'E_in': -75.0,
'I_e': 0.,
'V_m': -70.,
'V_th': -50.,
'V_reset': -60.0,
'V_peak': 0.0,
'a': 4.0,
'b': 80.5,
'g_L': 16.7,
'g_ex': 1.0,
'g_in': 1.0,
't_ref': 2.0,
'tau_minus': 20.,
'tau_minus_triplet': 200.,
'tau_w': 144.0,
'tau_syn_ex': 2.,
'tau_syn_in': 6.0,
}
}
multimeter.update({'record_from': ['V_m'], 'record_n': 1})
pop_names = ['{0}'.format(str(n)) for n in neuron_pars.keys()]
n_neurons = [1 for _ in neuron_pars.keys()]
if len(neuron_pars.keys()) > 1:
neuron_params = [neuron_pars[n] for n in neuron_pars.keys()]
else:
neuron_params = [neuron_pars[neuron_pars.keys()[0]]]
net_pars = ParameterSet({
'n_populations':
len(neuron_pars.keys()),
'pop_names':
pop_names,
'n_neurons':
n_neurons,
'neuron_pars':
neuron_params,
'randomize_neuron_pars': [{
'V_m': (np.random.uniform, {
'low': -70.,
'high': -50.
})
}],
'topology': [False for _ in neuron_pars.keys()],
'topology_dict': [None for _ in neuron_pars.keys()],
'record_spikes': [True for _ in neuron_pars.keys()],
'spike_device_pars': [
copy_dict(multimeter, {'model': 'spike_detector'})
for _ in neuron_pars.keys()
],
'record_analogs': [True for _ in neuron_pars.keys()],
'analog_device_pars': [
copy_dict(multimeter, {
'record_from': ['V_m'],
'record_n': 1
}) for _ in neuron_pars.keys()
],
})
neuron_pars = ParameterSet(neuron_pars)
# ##################################################################################################################
# Input/Encoding Parameters
# ##################################################################################################################
connections = [('{0}'.format(str(n)), 'DC_Input')
for n in net_pars.pop_names]
n_connections = len(connections)
encoding_pars = ParameterSet({
'generator': {
'N':
1,
'labels': ['DC_Input'],
'models': ['step_current_generator'],
'model_pars': [{
'start': 0.,
'stop': kernel_pars['sim_time'],
'origin': 0.,
'amplitude_times': times,
'amplitude_values': amplitudes
}],
'topology': [False],
'topology_pars': [None]
},
'connectivity': {
'connections': connections,
'topology_dependent': [False for _ in range(n_connections)],
'conn_specs': [{
'rule': 'all_to_all'
} for _ in range(n_connections)],
'syn_specs': [{} for _ in range(n_connections)],
'models': ['static_synapse' for _ in range(n_connections)],
'model_pars': [{} for _ in range(n_connections)],
'weight_dist': [1. for _ in range(n_connections)],
'delay_dist': [0.1 for _ in range(n_connections)],
'preset_W': [None for _ in range(n_connections)]
},
})
# ##################################################################################################################
# RETURN dictionary of Parameters dictionaries
# ==================================================================================================================
return dict([('kernel_pars', kernel_pars), ('neuron_pars', neuron_pars),
('net_pars', net_pars), ('encoding_pars', encoding_pars)])
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)
def set_decoding_defaults(output_resolution=1.,
to_memory=True,
**decoder_pars):
"""
:return:
"""
keys = [
'decoded_population', 'state_variable', 'filter_time', 'readouts',
'sampling_times', 'reset_states', 'average_states', 'standardize'
]
if not all([n in decoder_pars.keys() for n in keys]) or len(decoder_pars['decoded_population']) != \
len(decoder_pars['state_variable']):
raise TypeError("Incorrect Decoder Parameters")
dec_pars = ParameterSet(decoder_pars)
n_decoders = len(dec_pars.decoded_population)
if to_memory:
rec_device = rec_device_defaults(start=0.,
resolution=output_resolution)
else:
rec_device = rec_device_defaults(start=0.,
resolution=output_resolution,
record_to='file')
state_specs = []
for state_var in dec_pars.state_variable:
if state_var == 'spikes':
state_specs.append({
'tau_m': dec_pars.filter_time,
'interval': output_resolution
})
else:
state_specs.append(
copy_dict(
rec_device, {
'model': 'multimeter',
'record_n': None,
'record_from': [state_var]
}))
if 'N' in decoder_pars.keys():
N = decoder_pars['N']
else:
N = len(dec_pars.readouts)
if len(dec_pars.readout_algorithms) == N:
readouts = [{
'N': N,
'labels': dec_pars.readouts,
'algorithm': dec_pars.readout_algorithms
} for _ in range(n_decoders)]
else:
readouts = [{
'N': N,
'labels': dec_pars.readouts,
'algorithm': [dec_pars.readout_algorithms[0]]
} for _ in range(n_decoders)]
decoding_pars = {
'state_extractor': {
'N': n_decoders,
'filter_tau': dec_pars.filter_time,
'source_population': dec_pars.decoded_population,
'state_variable': dec_pars.state_variable,
'state_specs': state_specs,
'reset_states': dec_pars.reset_states,
'average_states': dec_pars.average_states,
'standardize': dec_pars.standardize
},
'readout': readouts,
'sampling_times': dec_pars.sampling_times,
'output_resolution': output_resolution
}
return ParameterSet(decoding_pars)
def set_encoding_defaults(default_set=1,
input_dimensions=1,
n_encoding_neurons=0,
encoder_neuron_pars=None,
gen_label=None,
**synapse_pars):
"""
:param default_set:
:return:
"""
if default_set == 0:
print(
"\nLoading Default Encoding Set 0 - Empty Settings (add background noise)"
)
encoding_pars = {
'encoder': {
'N': 0,
'labels': [],
'models': [],
'model_pars': [],
'n_neurons': [],
'neuron_pars': [],
'topology': [],
'topology_dict': [],
'record_spikes': [],
'spike_device_pars': [],
'record_analogs': [],
'analog_device_pars': []
},
'generator': {
'N': 0,
'labels': [],
'models': [],
'model_pars': [],
'topology': [],
'topology_pars': []
},
'connectivity': {
'synapse_name': [],
'connections': [],
'topology_dependent': [],
'conn_specs': [],
'syn_specs': [],
'models': [],
'model_pars': [],
'weight_dist': [],
'delay_dist': [],
'preset_W': []
},
'input_decoder': None
}
elif default_set == 1:
# ###################################################################
# Encoding Type 1 - DC injection to target populations
# ###################################################################
if gen_label is None:
gen_label = 'DC_input'
keys = [
'target_population_names', 'conn_specs', 'syn_specs', 'models',
'model_pars', 'weight_dist', 'delay_dist', 'preset_W'
]
if not np.mean([n in synapse_pars.keys() for n in keys]).astype(bool):
raise TypeError("Incorrect Synapse Parameters")
syn_pars = ParameterSet(synapse_pars)
# n_connections = len(syn_pars.target_population_names)
connections = [(n, gen_label)
for n in syn_pars.target_population_names]
synapse_names = [
gen_label + 'syn' for _ in syn_pars.target_population_names
]
print("\nLoading Default Encoding Set 1 - DC input to {0}".format(
str(syn_pars.target_population_names)))
encoding_pars = {
'encoder': {
'N': 0,
'labels': [],
'models': [],
'model_pars': [],
'n_neurons': [],
'neuron_pars': [],
'topology': [],
'topology_dict': [],
'record_spikes': [],
'spike_device_pars': [],
'record_analogs': [],
'analog_device_pars': []
},
'generator': {
'N':
input_dimensions,
'labels': [gen_label],
'models': ['step_current_generator'],
'model_pars': [{
'start': 0.,
'stop': sys.float_info.max,
'origin': 0.
}],
'topology': [False for _ in range(input_dimensions)],
'topology_pars': [None for _ in range(input_dimensions)]
},
'connectivity': {
'synapse_name': synapse_names,
'connections': connections,
'topology_dependent': [False, False],
'conn_specs': syn_pars.conn_specs,
'syn_specs': syn_pars.syn_specs,
'models': syn_pars.models,
'model_pars': syn_pars.model_pars,
'weight_dist': syn_pars.weight_dist,
'delay_dist': syn_pars.delay_dist,
'preset_W': syn_pars.preset_W
},
'input_decoder': None
}
elif default_set == 2:
# ###################################################################
# Encoding Type 2 - Deterministic spike encoding layer
# ###################################################################
rec_devices = rec_device_defaults()
enc_label = 'NEF'
keys = [
'target_population_names', 'conn_specs', 'syn_specs', 'models',
'model_pars', 'weight_dist', 'delay_dist', 'preset_W'
]
if not np.mean([n in synapse_pars.keys() for n in keys]).astype(bool):
raise TypeError("Incorrect Synapse Parameters")
syn_pars = ParameterSet(synapse_pars)
# n_connections = len(syn_pars.target_population_names) + 1
labels = [
enc_label + '{0}'.format(str(n)) for n in range(input_dimensions)
]
connections = [(n, enc_label)
for n in syn_pars.target_population_names]
conn_specs = syn_pars.conn_specs
conn_specs.insert(0, {'rule': 'all_to_all'}) #None)
synapse_names = [
enc_label + '_' + n for n in syn_pars.target_population_names
]
connections.insert(0, ('NEF', 'StepGen'))
synapse_names.insert(0, 'Gen_Enc')
spike_device_pars = [
copy_dict(rec_devices, {
'model': 'spike_detector',
'label': 'input_Spikes'
}) for _ in range(input_dimensions)
]
models = syn_pars.models
models.insert(0, 'static_synapse')
model_pars = syn_pars.model_pars
model_pars.insert(0, {})
weight_dist = syn_pars.weight_dist
weight_dist.insert(0, 1.)
delay_dist = syn_pars.delay_dist
delay_dist.insert(0, 0.1)
syn_specs = syn_pars.syn_specs
syn_specs.insert(0, {})
if hasattr(syn_pars, 'gen_to_enc_W'):
preset_W = syn_pars.preset_W
preset_W.insert(0, syn_pars.gen_to_enc_W)
else:
preset_W = syn_pars.preset_W
print("\nLoading Default Encoding Set 2 - Deterministic spike encoding, {0} input populations of {1} [{2} " \
"neurons] connected to {3}".format(
str(input_dimensions), str(n_encoding_neurons), str(encoder_neuron_pars['model']), str(
syn_pars.target_population_names)))
encoding_pars = {
'encoder': {
'N':
input_dimensions,
'labels': [enc_label for _ in range(input_dimensions)],
'models': [enc_label for _ in range(input_dimensions)],
'model_pars': [None for _ in range(input_dimensions)],
'n_neurons':
[n_encoding_neurons for _ in range(input_dimensions)],
'neuron_pars':
[encoder_neuron_pars for _ in range(input_dimensions)],
'topology': [False for _ in range(input_dimensions)],
'topology_dict': [None for _ in range(input_dimensions)],
'record_spikes': [True for _ in range(input_dimensions)],
'spike_device_pars':
spike_device_pars,
'record_analogs': [False for _ in range(input_dimensions)],
'analog_device_pars': [None for _ in range(input_dimensions)]
},
'generator': {
'N':
1,
'labels': ['StepGen'],
'models': ['step_current_generator'],
'model_pars': [{
'start': 0.,
'stop': sys.float_info.max,
'origin': 0.
}],
'topology': [False],
'topology_pars': [None]
},
'connectivity': {
'connections': connections,
'synapse_name': synapse_names,
'topology_dependent':
[False for _ in range(len(synapse_names))],
'conn_specs': conn_specs,
'models': models,
'model_pars': model_pars,
'weight_dist': weight_dist,
'delay_dist': delay_dist,
'preset_W': preset_W,
'syn_specs': syn_specs
},
'input_decoder': {
'encoder_label': enc_label
}
}
elif default_set == 3:
# ###################################################################
# Encoding Type 3 - Stochastic spike encoding layer
# ###################################################################
gen_label = 'inh_poisson'
keys = [
'target_population_names', 'conn_specs', 'syn_specs', 'models',
'model_pars', 'weight_dist', 'delay_dist', 'preset_W'
]
if not np.mean([n in synapse_pars.keys() for n in keys]).astype(bool):
raise TypeError("Incorrect Synapse Parameters")
syn_pars = ParameterSet(synapse_pars)
# n_connections = len(syn_pars.target_population_names)
connections = [(n, gen_label)
for n in syn_pars.target_population_names]
synapse_names = [
gen_label + 'syn' for _ in syn_pars.target_population_names
]
print(
"\nLoading Default Encoding Set 3 - Stochastic spike encoding, independent realizations of "
"inhomogeneous Poisson processes connected to {0}".format(
str(syn_pars.target_population_names)))
encoding_pars = {
'encoder': {
'N': 0,
'labels': [],
'models': [],
'model_pars': [],
'n_neurons': [],
'neuron_pars': [],
'topology': [],
'topology_dict': [],
'record_spikes': [],
'spike_device_pars': [],
'record_analogs': [],
'analog_device_pars': []
},
'generator': {
'N':
input_dimensions,
'labels': ['inh_poisson'],
'models': ['inh_poisson_generator'],
'model_pars': [{
'start': 0.,
'stop': sys.float_info.max,
'origin': 0.
}],
'topology': [False],
'topology_pars': [None]
},
'connectivity': {
'synapse_name': synapse_names,
'connections': connections,
'topology_dependent': [False, False],
'conn_specs': syn_pars.conn_specs,
'syn_specs': syn_pars.syn_specs,
'models': syn_pars.models,
'model_pars': syn_pars.model_pars,
'weight_dist': syn_pars.weight_dist,
'delay_dist': syn_pars.delay_dist,
'preset_W': syn_pars.preset_W
}
}
elif default_set == 4:
# ###################################################################
# Encoding Type 4 - Precise Spatiotemporal spike encoding (Frozen noise)
# ###################################################################
gen_label = 'spike_pattern'
keys = [
'target_population_names', 'conn_specs', 'syn_specs', 'models',
'model_pars', 'weight_dist', 'delay_dist', 'preset_W'
]
if not np.mean([n in synapse_pars.keys() for n in keys]).astype(bool):
raise TypeError("Incorrect Synapse Parameters")
syn_pars = ParameterSet(synapse_pars)
connections = [(n, gen_label)
for n in syn_pars.target_population_names]
synapse_names = [
gen_label + 'syn' for _ in syn_pars.target_population_names
]
conn_tp = [False for _ in range(len(connections))]
if hasattr(syn_pars, 'jitter'):
jitter = syn_pars.jitter
else:
jitter = None
print(
"\nLoading Default Encoding Set 4 - Stochastic spike encoding, {0} fixed spike pattern templates "
"composed of {1} independent spike trains connected to {2}".format(
str(input_dimensions), str(n_encoding_neurons),
str(syn_pars.target_population_names)))
encoding_pars = {
'encoder': {
'N': 0,
'labels': [],
'models': [],
'model_pars': [],
'n_neurons': [],
'neuron_pars': [],
'topology': [],
'topology_dict': [],
'record_spikes': [],
'spike_device_pars': [],
'record_analogs': [],
'analog_device_pars': []
},
'generator': {
'N':
1,
'labels': ['spike_pattern'],
'models': ['spike_generator'],
'model_pars': [{
'start': 0.,
'stop': sys.float_info.max,
'origin': 0.,
'precise_times': True
}],
'jitter':
jitter,
'topology': [False],
'topology_pars': [None],
'gen_to_enc_W':
syn_pars.gen_to_enc_W
},
'connectivity': {
'synapse_name': synapse_names,
'connections': connections,
'topology_dependent': conn_tp,
'conn_specs': syn_pars.conn_specs,
'syn_specs': syn_pars.syn_specs,
'models': syn_pars.models,
'model_pars': syn_pars.model_pars,
'weight_dist': syn_pars.weight_dist,
'delay_dist': syn_pars.delay_dist,
'preset_W': syn_pars.preset_W
},
'input_decoder': None #{}
}
else:
raise IOError("default_set not defined")
return ParameterSet(encoding_pars)
def set_network_defaults(neuron_set=0, N=1250, **synapse_pars):
"""
Network default parameters
:param default_set:
:return:
"""
print("\nLoading Default Network Set - Standard BRN, no topology")
syn_pars = ParameterSet(synapse_pars)
nE = 0.8 * N
nI = 0.2 * N
rec_devices = rec_device_defaults(start=0.)
neuron_pars = set_neuron_defaults(default_set=neuron_set)
#############################################################################################################
# NETWORK Parameters
# ===========================================================================================================
net_pars = {
'n_populations':
2,
'pop_names': ['E', 'I'],
'n_neurons': [int(nE), int(nI)],
'neuron_pars': [neuron_pars['E'], neuron_pars['I']],
'randomize_neuron_pars': [{
'V_m': (np.random.uniform, {
'low': -70.,
'high': -50.
})
}, {
'V_m': (np.random.uniform, {
'low': -70.,
'high': -50.
})
}],
'topology': [False, False],
'topology_dict': [None, None],
'record_spikes': [True, True],
'spike_device_pars': [
copy_dict(
rec_devices, {
'model': 'spike_detector',
'record_to': ['memory'],
'interval': 0.1,
'label': ''
}),
copy_dict(
rec_devices, {
'model': 'spike_detector',
'record_to': ['memory'],
'interval': 0.1,
'label': ''
})
],
'record_analogs': [False, False],
'analog_device_pars': [None, None],
}
#############################################################################################################
# SYNAPSE Parameters
# ============================================================================================================
connection_pars = set_connection_defaults(syn_pars=syn_pars)
return ParameterSet(neuron_pars), ParameterSet(net_pars), ParameterSet(
connection_pars)