Synaptic scaling balances learning in a spiking model of neocortex (Rowan & Neymotin 2013)

 Download zip file   Auto-launch 
Help downloading and running models
Accession:147141
Learning in the brain requires complementary mechanisms: potentiation and activity-dependent homeostatic scaling. We introduce synaptic scaling to a biologically-realistic spiking model of neocortex which can learn changes in oscillatory rhythms using STDP, and show that scaling is necessary to balance both positive and negative changes in input from potentiation and atrophy. We discuss some of the issues that arise when considering synaptic scaling in such a model, and show that scaling regulates activity whilst allowing learning to remain unaltered.
Reference:
1 . Rowan MS,Neymotin SA (2013) Synaptic Scaling Balances Learning in a Spiking Model of Neocortex Adaptive and Natural Computing Algorithms, Tomassini M, Antonioni A, Daolio F, Buesser P, ed. pp.20
Model Information (Click on a link to find other models with that property)
Model Type: Realistic Network;
Brain Region(s)/Organism: Neocortex;
Cell Type(s): Neocortex L5/6 pyramidal GLU cell; Neocortex L2/3 pyramidal GLU cell; Neocortex V1 interneuron basket PV GABA cell; Neocortex fast spiking (FS) interneuron; Neocortex spiny stellate cell; Neocortex spiking regular (RS) neuron; Neocortex spiking low threshold (LTS) neuron; Abstract integrate-and-fire adaptive exponential (AdEx) neuron;
Channel(s):
Gap Junctions:
Receptor(s): GabaA; AMPA; NMDA;
Gene(s):
Transmitter(s): Gaba; Glutamate;
Simulation Environment: NEURON; Python;
Model Concept(s): Synaptic Plasticity; Long-term Synaptic Plasticity; Learning; STDP; Homeostasis;
Implementer(s): Lytton, William [bill.lytton at downstate.edu]; Neymotin, Sam [Samuel.Neymotin at nki.rfmh.org]; Rowan, Mark [m.s.rowan at cs.bham.ac.uk];
Search NeuronDB for information about:  Neocortex L5/6 pyramidal GLU cell; Neocortex L2/3 pyramidal GLU cell; Neocortex V1 interneuron basket PV GABA cell; GabaA; AMPA; NMDA; Gaba; Glutamate;
/
stdpscalingpaper
batchscripts
mod
README
alz.hoc
autotune.hoc *
basestdp.hoc *
batch.hoc *
batch2.hoc *
batchcommon
checkirreg.hoc *
clusterrun.sh
col.dot *
col.hoc *
comppowspec.hoc *
condisconcellfig.hoc *
condisconpowfig.hoc *
declist.hoc *
decmat.hoc *
decnqs.hoc *
decvec.hoc *
default.hoc *
drline.hoc *
e2hubsdisconpow.hoc *
e2incconpow.hoc *
filtutils.hoc *
geom.hoc *
graphplug.hoc *
grvec.hoc *
init.hoc *
labels.hoc *
load.hoc *
local.hoc *
makepopspikenq.hoc *
matfftpowplug.hoc *
matpmtmplug.hoc *
matpmtmsubpopplug.hoc *
matspecplug.hoc *
network.hoc *
nload.hoc *
nqpplug.hoc *
nqs.hoc *
nqsnet.hoc *
nrnoc.hoc *
params.hoc
plot.py
plotbatch.sh
plotbatchcluster.sh
powchgtest.hoc *
python.hoc *
pywrap.hoc *
redE2.hoc *
run.hoc
runsim.sh
setup.hoc *
shufmua.hoc *
sim.hoc
simctrl.hoc *
spkts.hoc *
stats.hoc *
stdpscaling.hoc
syncode.hoc *
vsampenplug.hoc *
writedata.hoc
xgetargs.hoc *
                            
// $Id: pywrap.hoc,v 1.12 2011/03/21 21:34:16 samn Exp $ 

//* variables
declare("INITPYWRAP",0) // whether initialized properly

//* initialize pywrap
if(2!=name_declared("p")) {
  print "pywrap.hoc: loading python.hoc"
  load_file("python.hoc")
}
func initpywrap () { localobj pjnk
  INITPYWRAP=0
  if(2!=name_declared("p")){printf("initpywrap ERR0A: PythonObject p not found in python.hoc!\n") return 0}
  print p  
  pjnk=new PythonObject()
  if(!isojt(p,pjnk)){printf("initpywrap ERR0B: PythonObject p not found in python.hoc!\n")}
  INITPYWRAP=1
  return 1
}
initpywrap()

//** pypmtm(vec,samplingrate)
// this function calls python version of pmtm, runs multitaper power spectra, returns an nqs
obfunc pypmtm () { local sampr,spc localobj vin,str,nqp,ptmp
  if(!INITPYWRAP) {printf("pypmtm ERR0A: python.hoc not initialized properly\n") return nil}
  if(!nrnpython("from mtspec import *")) {printf("pypmtm ERR0B: could not import mtspec python library!\n") return nil}  
  if(numarg()==0) {printf("pypmtm(vec,samplingrate)\n") return nil}
  vin=$o1 sampr=$2 str=new String()
  p.vjnk = vin.to_python()
  p.vjnk = p.numpy.array(p.vjnk)
  spc = 1.0 / sampr // "spacing"
  sprint(str.s,"[Pxx,w]=mtspec(vjnk,%g,4)",spc)
  nrnpython(str.s)
  nqp=new NQS("f","pow")
  nqp.v.from_python(p.w)
  nqp.v[1].from_python(p.Pxx)
  return nqp
}

//** pybspow(vec,samplingrate[,maxf,pord])
// this function calls python version of bsmart, to get power pectrum, returns an nqs
// pord is order of polynomial -- higher == less smoothing. default is 12
obfunc pybspow () { local sampr,pord,maxf localobj vin,str,nqp,ptmp
  if(!INITPYWRAP) {printf("pybspow ERR0A: python.hoc not initialized properly\n") return nil}
  if(!nrnpython("from bsmart import bspow")) {printf("pybspow ERR0B: could not import bsmart python library!\n") return nil}  
  if(numarg()==0) {printf("pybspow(vec,samplingrate)\n") return nil}
  vin=$o1 sampr=$2 str=new String()
  if(numarg()>2) maxf=$3 else maxf=sampr/2
  if(numarg()>3) pord=$4 else pord=12
  p.vjnk = vin.to_python()
  p.vjnk = p.numpy.array(p.vjnk)
  sprint(str.s,"Pxx=bspow(vjnk,%g,%g,p=%d)",sampr,maxf,pord)
  nrnpython(str.s)
  nqp=new NQS("f","pow")
  nqp.v.indgen(0,maxf,1)
  nqp.v[1].from_python(p.Pxx)
  return nqp
}

//** pyspecgram(vec,samplingrate[,orows])
// this function calls python version of specgram, returns an nqs
obfunc pyspecgram () { local sampr,spc,i,j,sz,f,tt,orows,a localobj vin,str,nqp,ptmp,vtmp
  if(!INITPYWRAP) {printf("pyspecgram ERR0A: python.hoc not initialized properly\n") return nil}
  if(!nrnpython("from matplotlib.mlab import specgram")) {printf("pyspecgram ERR0B: could not import specgram from matplotlib.mlab!\n") return nil}  
  if(numarg()==0) {printf("pyspecgram(vec,samplingrate)\n") return nil}
  a=allocvecs(vtmp)
  vin=$o1 sampr=$2 str=new String()
  if(numarg()>2)orows=$3 else orows=1
  p.vjnk = vin.to_python()
  p.vjnk = p.numpy.array(p.vjnk)
  sprint(str.s,"[Pxx,freqs,tt]=specgram(vjnk,Fs=%g)",sampr)
  nrnpython(str.s)
  if(orows) {
    {nqp=new NQS("f","pow") nqp.odec("pow")}
    {sz=p.Pxx.shape[0] nqp.clear(sz)}
    for i=0,sz-1 {
      {vtmp.resize(0) vtmp.from_python(p.Pxx[i]) f=p.freqs[i]}
      nqp.append(f,vtmp)
    }
  } else {
    nqp=new NQS("f","pow","t")
    sz = p.Pxx.shape[0]
    nqp.clear(sz * p.Pxx.shape[1])
    for i=0,sz-1 {
      {vtmp.resize(0) vtmp.from_python(p.Pxx[i]) f=p.freqs[i]}
      for j=0,vtmp.size-1 nqp.append(f,vtmp.x(j),p.tt[j])
    }
  }
  dealloc(a)
  return nqp
}

//** pycsd(vec1,vec2,samplingrate)
// this function calls python version of csd (cross-spectral density)
// returns an nqs with csd -- csd is non-directional
obfunc pycsd () { local sampr,a localobj v1,v2,str,nqp
  if(!INITPYWRAP) {printf("pycsd ERR0A: python.hoc not initialized properly\n") return nil}
  if(!nrnpython("from matplotlib.mlab import csd")) {printf("pycsd ERR0B: could not import csd from matplotlib.mlab!\n") return nil}  
  if(numarg()==0) {printf("pycsd(vec,samplingrate)\n") return nil}
  v1=$o1 v2=$o2 sampr=$3 str=new String()
  {p.vjnk1=v1.to_python() p.vjnk1=p.numpy.array(p.vjnk1)}
  {p.vjnk2=v2.to_python() p.vjnk2=p.numpy.array(p.vjnk2)}
  sprint(str.s,"[Pxy,freqs]=csd(vjnk1,vjnk2,Fs=%g)",sampr)
  nrnpython(str.s)
  nqp=new NQS("f","pow")
  nqp.v[0].from_python(p.freqs)
  nqp.v[1].from_python(p.Pxy)
  return nqp
}

//** pypsd(vec,samplingrate)
// this function calls python version of psd (power-spectral density)
// returns an nqs with psd
obfunc pypsd () { local sampr localobj v1,str,nqp
  if(!INITPYWRAP) {printf("pypsd ERR0A: python.hoc not initialized properly\n") return nil}
  if(!nrnpython("from matplotlib.mlab import psd")) {printf("pypsd ERR0B: could not import psd from matplotlib.mlab!\n") return nil}  
  if(numarg()==0) {printf("pypsd(vec,samplingrate)\n") return nil}
  v1=$o1 sampr=$2 str=new String()
  {p.vjnk1=v1.to_python() p.vjnk1=p.numpy.array(p.vjnk1)}
  sprint(str.s,"[Pxx,freqs]=psd(vjnk1,Fs=%g)",sampr)
  nrnpython(str.s)
  nqp=new NQS("f","pow")
  nqp.v[0].from_python(p.freqs)
  nqp.v[1].from_python(p.Pxx)
  return nqp
}

//** pycohere(vec1,vec2,samplingrate) 
// this function calls python version of cohere (coherence is normalized csd btwn vec1, vec2)
// returns an nqs with coherence
obfunc pycohere () { local sampr,a localobj v1,v2,str,nqp
  if(!INITPYWRAP) {printf("pycohere ERR0A: python.hoc not initialized properly\n") return nil}
  if(!nrnpython("from matplotlib.mlab import cohere")) {printf("pycohere ERR0B: could not import cohere from matplotlib.mlab!\n") return nil}  
  if(numarg()==0) {printf("pycohere(vec1,vec2,samplingrate)\n") return nil}
  v1=$o1 v2=$o2 sampr=$3 str=new String()
  {p.vjnk1=v1.to_python() p.vjnk1=p.numpy.array(p.vjnk1)}
  {p.vjnk2=v2.to_python() p.vjnk2=p.numpy.array(p.vjnk2)}
  sprint(str.s,"[Pxy,freqs]=cohere(vjnk1,vjnk2,Fs=%g)",sampr)
  nrnpython(str.s)
  nqp=new NQS("f","coh")
  nqp.v[0].from_python(p.freqs)
  nqp.v[1].from_python(p.Pxy)
  return nqp
}

Loading data, please wait...