Esempio n. 1
0
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)
Esempio n. 2
0
def add_parrots(encoding_pars, n_parrots, decode=True, **extra_pars):
    """
    Attaches a layer of parrot neurons to the encoder (for cases when the generator is a spike-emmitting device)
    :param encoding_pars: original encoding parameters
    :param n_parrots: number of parrot neurons to attach (should be the same as the number of unique generators)
    :param decode: attach decoders and readouts to parrot neurons.. (only spikes can be read!)
    """
    if extra_pars.items():
        conn_specs = extra_pars['conn_specs']
        presetW = extra_pars['preset_W']
    else:
        conn_specs = {'rule': 'one_to_one'}
        presetW = None
    rec_devices = rec_device_defaults()
    encoding_pars.encoder.N += 1
    encoding_pars.encoder.labels.extend(['parrots'])
    encoding_pars.encoder.models.extend(['parrot_neuron'])
    encoding_pars.encoder.model_pars.extend([None])
    encoding_pars.encoder.n_neurons.extend([n_parrots])
    encoding_pars.encoder.neuron_pars.extend([{'model': 'parrot_neuron'}])
    encoding_pars.encoder.topology.extend([False])
    encoding_pars.encoder.topology_dict.extend([None])
    encoding_pars.encoder.record_spikes.extend([True])
    encoding_pars.encoder.spike_device_pars.extend([
        copy_dict(rec_devices, {
            'model': 'spike_detector',
            'label': 'input_Spikes'
        })
    ])
    encoding_pars.encoder.record_analogs.extend([False])
    encoding_pars.encoder.analog_device_pars.extend([None])
    syn_name = encoding_pars.connectivity.synapse_name[
        0]  # all synapses from a device must have the same name!!
    encoding_pars.connectivity.synapse_name.extend([syn_name])
    encoding_pars.connectivity.connections.extend([
        ('parrots', encoding_pars.generator.labels[0])
    ])
    encoding_pars.connectivity.topology_dependent.extend([False])
    encoding_pars.connectivity.conn_specs.extend([conn_specs])
    encoding_pars.connectivity.syn_specs.extend([{}])
    encoding_pars.connectivity.models.extend(['static_synapse'])
    encoding_pars.connectivity.model_pars.extend([{}])
    encoding_pars.connectivity.weight_dist.extend([1.])
    encoding_pars.connectivity.delay_dist.extend([0.1])
    encoding_pars.connectivity.preset_W.extend([presetW])
    if decode:
        encoding_pars.input_decoder = {'encoder_label': 'parrots'}
Esempio n. 3
0
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)])
Esempio n. 4
0
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)
Esempio n. 5
0
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)
Esempio n. 6
0
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)