Modeling dentate granule cells heterosynaptic plasticity using STDP-BCM rule (Jedlicka et al. 2015)

 Download zip file   Auto-launch 
Help downloading and running models
... Here we study how key components of learning mechanisms in the brain, namely spike timing-dependent plasticity and metaplasticity, interact with spontaneous activity in the input pathways of the neuron. Using biologically realistic simulations we show that ongoing background activity is a key determinant of the degree of long-term potentiation and long-term depression of synaptic transmission between nerve cells in the hippocampus of freely moving animals. This work helps better understand the computational rules which drive synaptic plasticity in vivo. ...
1 . Jedlicka P, Benuskova L, Abraham WC (2015) A Voltage-Based STDP Rule Combined with Fast BCM-Like Metaplasticity Accounts for LTP and Concurrent "Heterosynaptic" LTD in the Dentate Gyrus In Vivo. PLoS Comput Biol 11:e1004588 [PubMed]
Model Information (Click on a link to find other models with that property)
Model Type: Neuron or other electrically excitable cell; Synapse;
Brain Region(s)/Organism:
Cell Type(s): Dentate gyrus granule GLU cell;
Gap Junctions:
Receptor(s): AMPA;
Transmitter(s): Glutamate;
Simulation Environment: NEURON;
Model Concept(s): STDP; Homeostasis;
Implementer(s): Jedlicka, Peter [jedlicka at];
Search NeuronDB for information about:  Dentate gyrus granule GLU cell; AMPA; Glutamate;

This is a mechanism for computing sliding BCM threshold based on recent spike count (Benuskova et al. PNAS 2001, Benuskova and Abraham JCNS 2007):

alpha_scount = alpha * scount 

The averaged postsynaptic activity scount expresses the weighted
average of the postsynaptic spike count, with the most recent
spikes entering the sum with bigger weight than previous

output = 1, if there is a postsynaptic spike
at a given time, output = 0, otherwise.

alpha is the scaling constant.

scounttau is the averaging time constant for calculation of alpha_scount.

The mechanism should be inserted into soma to calculate the value of alpha_scount and thereby of d and p for all synaptic point processes which use d, p as POINTER variables.
At the hoc level d and p have to be set up as POINTER variables to allow the synaptic point process to know the d and p value. Here is an example
for setting up POINTER variables for a synaptic object syn: 

setpointer syn.d, d_BCMthreshold
setpointer syn.p, p_BCMthreshold


	GLOBAL d0, p0, scount0, scounttau, alpha, alpha_scount
	GLOBAL d, p, tspike

	(mV) = (millivolt)

	d0		: initial value for the depression factor (additive, non-saturating)
	p0		: initial value for the potentiation factor (additive, non-saturating)

	scounttau  		: averaging time constant for postsynaptic spike count, e.g. 12000 ms
	alpha			: scaling constant
	scount0 		: initial scount = 0 
	boltzman = 0	: initial boltzman = 0 (from Luba)


	v (mV)
	alpha_scount	: scount scaled by alpha - sliding (scount-dependent) modification threshold
	d			: depression factor (multiplicative to prevent < 0)
	p			: potentiation factor (multiplicative)
	boltzfactor 	: from Luba
	pf				: from Luba
	output			: from Luba
	tspike (ms)
	scount			: counter for postsynaptic spikes
	tspike = -100000
:flag is an implicit argument to NET_RECEIVE. It is an integer, zero by default but a nonzero value can be specified via the second argument to
:net_send(). net_send() is used to launch self-events. A self-event comes back to the mechanism that launched it, no NetCon required. 

	net_send(0, 1)
	flagOLD = 1
	scount = scount0
	d = d0		
	p = p0
	alpha_scount = alpha*scount
	boltzfactor = exp( - 1.0 / scounttau)
	if(boltzman == 0) {pf = 1.0 / (1 - boltzfactor)} else {pf = 1.0}
	output = 0

	:if (output > 0) {printf("entry time=%g output=%g\n", t, output)}
	scount = scount  + output/pf
	SOLVE state METHOD cnexp								:credit to Steffen Platschek
  	pf = pf * boltzfactor + 1.0
  	alpha_scount = alpha * scount							:scount scaled by alpha
	if (alpha_scount > 0) {p = p0/alpha_scount} else {p = p}
	d = d0*alpha_scount
    output = 0

	scount' = -scount / pf

:The items in the argument list in the NET_RECEIVE statement of a synaptic mechanism are actually the elements of a
:weight vector. The first element, which is called nc.weight[0],
:corresponds to the first item in the NET_RECEIVE argument list--w--which remains constant during a simulation.
:The second element is called nc.weight[1], and it corresponds to wE.
:The value of this second element DOES change as a consequence of STDP.

NET_RECEIVE(w) {		:w is actually not needed for computations
	INITIAL {w=0}

:When a presynaptic spike occurs, the mechanism receives an event with flag == 0. 
:The printf statements are purely for diagnostic purposes and can be commented out.

	if (flag == 0) {
		output = 0 			:no postsynaptic spike
	} else if (flag == 2) { 	: postsynaptic spike
		tspike = t				: just in case one needs time of the spike
		output = 1				:postsynaptic spike 
		:printf("output=%g at time t=tspike=%g\n", scount, tspike)
	} else { : flag == 1 from INITIAL block

		:printf("entry flag=%g t=%g\n", flag, t)

:WATCH (var > thresh) flagvalue is used in a NET_RECEIVE block to specify a condition in the postsynaptic cell
:that will generate a self-event with latency 0 and a specified flag value. Generally, WATCH is used to make NEURON
:monitor a variable for threshold crossing, and generates a self event with the specified flag value when the threshold
:is crossed. If the postsynaptic cell is a biophysical model cell, var is usually local membrane potential (or cai or some
:other concentration); if the postsynaptic cell is an artificial spiking cell, var is one of that cell's state variables.
:But WATCH could in principle be anything, such as the total number of spikes that a cell has fired, or perhaps even t (time)

		WATCH (v > 0) 2 :This mechanism watches postsynaptic membrane potential at the location of the mechanism
						:When a postsynaptic spike occurs, the mechanism receives an event with flag == 2

Loading data, please wait...