IZNeuron.H

Go to the documentation of this file.

/*!@file ModelNeuron/IZNeuron.H Class declarations for an izhikevich neuron */

// //////////////////////////////////////////////////////////////////// //
// The iLab Neuromorphic Vision C++ Toolkit - Copyright (C) 2001 by the //
// University of Southern California (USC) and the iLab at USC.         //
// See http://iLab.usc.edu for information about this project.          //
// //////////////////////////////////////////////////////////////////// //
// Major portions of the iLab Neuromorphic Vision Toolkit are protected //
// under the U.S. patent ``Computation of Intrinsic Perceptual Saliency //
// in Visual Environments, and Applications'' by Christof Koch and      //
// Laurent Itti, California Institute of Technology, 2001 (patent       //
// pending; application number 09/912,225 filed July 23, 2001; see      //
// http://pair.uspto.gov/cgi-bin/final/home.pl for current status).     //
// //////////////////////////////////////////////////////////////////// //
// This file is part of the iLab Neuromorphic Vision C++ Toolkit.       //
//                                                                      //
// The iLab Neuromorphic Vision C++ Toolkit is free software; you can   //
// redistribute it and/or modify it under the terms of the GNU General  //
// Public License as published by the Free Software Foundation; either  //
// version 2 of the License, or (at your option) any later version.     //
//                                                                      //
// The iLab Neuromorphic Vision C++ Toolkit is distributed in the hope  //
// that it will be useful, but WITHOUT ANY WARRANTY; without even the   //
// implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR      //
// PURPOSE.  See the GNU General Public License for more details.       //
//                                                                      //
// You should have received a copy of the GNU General Public License    //
// along with the iLab Neuromorphic Vision C++ Toolkit; if not, write   //
// to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,   //
// Boston, MA 02111-1307 USA.                                           //
// //////////////////////////////////////////////////////////////////// //
//
// Primary maintainer for this file: David Berg <dberg@usc.edu>
// $HeadURL: svn://ilab.usc.edu/trunk/saliency/src/ModelNeuron/IZNeuron.H $

#ifndef IZNEURON_H_DEFINED
#define IZNEURON_H_DEFINED

#include "Util/SimTime.H"
#include "ModelNeuron/IZNeuronBase.H"
#include "ModelNeuron/Synapse.H"
#include "Util/MathFunctions.H"
#include <queue>


// ######################################################################
//! An izhikevich Neural model as presented in his 2003 paper
// ######################################################################

typedef enum {AMPA,NMDA,GABAA,GABAB} SynapseType;

class IZNeuron : public IZNeuronBase
{
public:
  //! constructor
  /*! Constructor with default params
    @param timeStep is the integration time step, in milliseconds.
    See the general description for the other params. */
  inline IZNeuron(const SimTime timeStep = SimTime::MSECS(.1),
                  const double a = 0.15,          // dimensionless
                  const double b = 8,           // dimensionless 
                  const double c = -55.0,         // dimensionless
                  const double d = 200.0,         // dimensionless
                  const double k = 1,           // dimensionless
                  const double Cm = 20.0,        // farads
                  const double V_rest = -55.0,    // in millivolts
                  const double V_thresh = -40.0, // in millivolts
                  const double V_peak = 25.0,
                  const double itsa = .99);     // in millivolts

  //! Vistual destructor for safe inheritance
  virtual inline ~IZNeuron();

  inline void inputAMPA(const float spikes);
  inline void inputNMDA(const float spikes);
  inline void inputGABAA(const float spikes);
  inline void inputGABAB(const float spikes);
  inline uint getSpikes() const;
  inline Synapse* getSynapse(SynapseType synname);
  inline uint evolve(const SimTime& t);
  virtual inline void updateSpikeRate(const float spike);
  virtual inline float getSpikeRate() const;

private:

  AMPASynapse  ampa;
  NMDASynapse  nmda;
  GABAASynapse gabaa;
  GABABSynapse gabab;
  uint spikeCount;
  double itsSpikeRate;
  double itsAlpha;

};



// ######################################################################
//! An izhikevich Neural model that keeps track of its own spike rate
// ######################################################################

class IZNeuronSR : public IZNeuron
{
public:
  //! constructor
  /*! Constructor with default params
    @param timeStep is the integration time step, in milliseconds.
    See the general description for the other params. */
  inline IZNeuronSR(const SimTime timeStep = SimTime::MSECS(.1),
                    const double a = 0.15,          // dimensionless
                    const double b = 8,           // dimensionless 
                    const double c = -55.0,         // dimensionless
                    const double d = 200.0,         // dimensionless
                    const double k = 1,           // dimensionless
                    const double Cm = 20.0,        // farads
                    const double V_rest = -55.0,    // in millivolts
                    const double V_thresh = -40.0, // in millivolts
                    const double V_peak = 25.0,     // in millivolts
                    const float itsa = 200);   //window function in ms

  
  inline float getSpikeRate() const;
  inline void updateSpikeRate(const float spike);

private:
  std::deque<float> itsSr;
  std::vector<float> window;  
  float itsA;
};


// ######################################################################
// ##### Inline functions for IZNeuron:
// ######################################################################

inline IZNeuron::IZNeuron(const SimTime timeStep,
                          const double a,
                          const double b,
                          const double c,
                          const double d,
                          const double k,
                          const double cm, 
                          const double vr,
                          const double vth,
                          const double vp,
                          const double itsa) :
  IZNeuronBase(timeStep,a,b,c,d,k,cm,vr,vth,vp),ampa(timeStep),
  nmda(timeStep),gabaa(timeStep),gabab(timeStep),spikeCount(0),
  itsSpikeRate(0.0),itsAlpha(itsa)
{  }

inline IZNeuron::~IZNeuron()
{  }

inline void IZNeuron::inputAMPA(const float spikes)
{
  ampa.input((double)spikes);
}

inline void IZNeuron::inputNMDA(const float spikes)
{
  nmda.input((double)spikes);
}

inline void IZNeuron::inputGABAA(const float spikes)
{
  gabaa.input((double)spikes);
}

inline void IZNeuron::inputGABAB(const float spikes)
{
  gabab.input((double)spikes);
}

inline Synapse* IZNeuron::getSynapse(SynapseType synname)
{
  switch (synname)
    {
    case AMPA:
      return &ampa;
    case NMDA:
      return &nmda;
    case GABAA:
      return &gabaa;
    case GABAB:
      return &gabab;
    default:
      return new Synapse;  
    }
}

inline uint IZNeuron::evolve(const SimTime& t)
{
  const SimTime dt = SimTime::computeDeltaT((t - getTime()), getTimeStep());
  uint spike = 0;  

  for (SimTime tt = getTime(); tt < t; tt += dt)
    {
      //integrate all our synapses once
      ampa.integrate(dt);
      nmda.integrate(dt);
      gabaa.integrate(dt);
      gabab.integrate(dt);
      
      //sum up the currents
      double current = ampa.getI(getV()) + nmda.getI(getV()) 
        + gabaa.getI(getV()) + gabab.getI(getV());
      
      //set the current level in picoamps
      input(current);
      
      //integrate our neuron one time step
      spike += integrate(dt);

      //a virtual function with no implementation 
      updateSpikeRate(spike);
    }

  spikeCount = spike;
  setTime(t);
  ampa.setTime(t);
  nmda.setTime(t);
  gabaa.setTime(t);
  gabab.setTime(t);
  return spike;
}

inline void IZNeuron::updateSpikeRate(const float spike)
{
   itsSpikeRate *= itsAlpha;
   itsSpikeRate += (1-itsAlpha)*spike;
}

inline uint IZNeuron::getSpikes() const
{
  return spikeCount;
}

inline float IZNeuron::getSpikeRate() const
{
  return itsSpikeRate;
}

inline IZNeuronSR::IZNeuronSR(const SimTime timeStep,
                              const double a,
                              const double b,
                              const double c,
                              const double d,
                              const double k,
                              const double cm, 
                              const double vr,
                              const double vth,
                              const double vp,
                              const float itsa) :
  IZNeuron(timeStep,a,b,c,d,k,cm,vr,vth,vp),itsSr(),window(),itsA(itsa)
{
  const float aa = 1/(itsA*timeStep.msecs());
  const float fl = .001;
  SimTime end = SimTime::MSECS(1000);
  SimTime ii =  SimTime::ZERO();

  for (; ii  < end; ii += timeStep)
    {
      float temp = (aa*aa) * ii.msecs() * exp(-1 * aa * ii.msecs());
      if ( (temp < fl) && (ii > SimTime::MSECS(10)) ) break;
      window.push_back(temp);
    }
}


inline float IZNeuronSR::getSpikeRate() const
{
  std::vector<float>::const_iterator iter = window.begin();
  std::deque<float>::const_iterator iters = itsSr.begin();
  float val = 0;
  while ((iter != window.end()) && (iters != itsSr.end()))
    val += (*iter++) * (*iters++);
  return val;
}


inline void IZNeuronSR::updateSpikeRate(const float spike)
{
  itsSr.push_back(spike);
  while (itsSr.size() > window.size() )
    itsSr.pop_front();
}


#endif

// ######################################################################
/* So things look consistent in everyone's emacs... */
/* Local Variables: */
/* indent-tabs-mode: nil */
/* End: */

---