Nest Simulator Guide

October 24, 2018

INTG- IASBS THEORETICAL NEUROSCIENCE GROUP

0.0.1 Single neuron

In this handout we cover the first steps in using PyNEST to simulate neuronal networks.

• create a single neuron, multimeter and spikedetector

• connect the multimeter and spikedetector to the neuron

• plot voltage and spike events over time

In [1]: import nest

import pylab as pl #to plot figures

# create a neuron of type iaf_psc_alpha

neuron =nest.Create('iaf_psc_alpha')

# print default values of parameters

# stimulate the neuron with a constant current

# create a multimeter, a device we can use to record the membrane voltage of a neuron over time.

# create a spikedetector, another device that records the spiking

# events produced by a neuron.

# withgid indicates whether the spike detector is to

# record the source id from which it received the event

# (i.e. the id of our neuron).

# Connecting node to multimeter and spikedetector with default connections

dmm =nest.GetStatus(multimeter)[0]

Vms =dmm["events"]["V_m"]

ts =dmm["events"]["times"]

# print nest.GetStatus(spikedetector)[0].keys()

# print nest.GetStatus(spikedetector)[0]['events']

dSD =nest.GetStatus(spikedetector,keys='events')[0]

evs =dSD['senders']

ts =dSD["times"]

0.0.2 Add extra neuron

• plot the voltage versus time

In [2]: %matplotlib inline

import nest

import pylab as pl

from sys import exit

# the first neuron

neuron =nest.Create('iaf_psc_alpha')

# Create an extra neuron

neuron2 =nest.Create("iaf_psc_alpha")

# add constant current to neuron but less the sufficient to make spike

# connect this newly created neuron to the multimeter

# we use the same multimeter and spikedetector to record from both neurons

# Connect(pre, post, conn_spec, syn_spec)

# http://www.nest-simulator.org/connection-management/

# [::2] get the even indices

# [1::2] get the odd indices

# numpy slicing: [start:end:step]

Vms1 =dmm["events"]["V_m"][::2]

ts1 =dmm["events"]["times"][::2]

Vms2 =dmm["events"]["V_m"][1::2]

ts2 =dmm['events']['times'][1::2]

# ------------------------------------------------------- #

# uncomment these lines to see the wrong results

# Vms1 = dmm["events"]["V_m"]

# ts1 = dmm["events"]["times"]

# pl.plot(ts1,Vms1)

# pl.show()

0.0.3 Connecting nodes with specific connections

• single neuron receives 2 Poisson spike trains

neuron =nest.Create('iaf_psc_alpha')

# one excitatory and the other inhibitory

# constant input current should be set to 0:

syn_dict_ex ={"weight":1.2}

# inhibitory postsynaptic current of -2pA amplitude

syn_dict_in ={"weight":-2.0}

# plot the results

dmm =nest.GetStatus(multimeter)[0]

Vms1 =dmm["events"]["V_m"]

ts1 =dmm["events"]["times"]

fig, ax =pl.subplots(2, figsize=(8,8))

evs =dSD['senders']

ts =dSD["times"]

# set labels

0.0.4 two connected neurons

• plot post synaptic voltage from neuron 1 on neuron 2

import nest

import pylab as pl

neuron1 =nest.Create("iaf_psc_alpha")

# input to neuron 1

neuron2 =nest.Create("iaf_psc_alpha")

# default delay is 1ms, alternative command is:

# record the membrane potential from neuron2

Vms =dmm["events"]["V_m"]

ts =dmm["events"]["times"]

#the most basic way of creating a batch of identically

# parameterised neurons is to exploit the optional

# arguments of Create():

neuronpop =nest.Create("iaf_psc_alpha",100, params=ndict)

# neuronpop is a list of all the ids of the created neurons.

# naming the neurons in population start from 1 (uncomment the next line)

# print neuronpop

# We can also set the parameters of a neuron model before

# creation, which allows us to define a simulation more

# print nest.GetStatus(conns)[0].keys()

# print nest.GetStatus(conns)[0]

Manual (NTUM)

necting layers > 4. Auxillary

In [4]: import nest.topology as topp

# my_layer_dict = {...}

# my_layer = topp.CreateLayer(my_layer_dict)

• Defining layers > 1. on grid > 2. off grid

In [8]: # on grid

"elements" :"iaf_psc_alpha"}# the element at each (x,y) coordinate in the grid

my_layer =topp.CreateLayer(layer_dict_ex)

In [11]: # off grid

import nest

import numpy as np

# grid with jitter

jit = 0.03

"elements" :"iaf_psc_alpha"}

my_layer =topp.CreateLayer(layer_dict_ex)

0.2.1 I skipped some materials from topology structure

0.2.2 visualising and querying the network structure

In [13]: %matplotlib inline

import nest.topology as tp

# plot layer with all its nodes

In [14]: %matplotlib inline

import nest.topology as tp

import matplotlib.pyplot as plt

# create a layer

# connectivity specifications with a mask

conndict ={'connection_type':'divergent',

In [16]: %matplotlib inline

# create a layer

# connectivity specifications

mask_dict ={'rectangular': {'lower_left': [-2.0,-1.0],

kernel_dict ={'gaussian': {'p_center':1.0,

conndict ={'connection_type':'divergent',

# connect layer l with itself according to the given

fig, ax =plt.subplots()

# plot layer nodes

ctr_elem =tp.FindCenterElement(l)

# plot mask and kernel of the center element