Jump to: navigation, search

This page is obsolete and will be deleted. It describes the original RGC implementation that is part of the Synapse project. This work has now moved to the vistaproj and vismodel directories, separating from the virtual environment, vrn, and other elements of the Synapse project.

We have implemented software to simulate to the spiking output of retinal ganglion cells. The full simulation path combines physically accurate stimulus generation ISET, the spiking simulator, and a decision mechanism. The simulation pipeline begins by specifying calibrated spectral images (photon spectral power distributions). These are transformed into an irradiance image at the retina and then cone photoreceptor absorptions. The ganglion cell spikes are predicted by specifying a receptive field and using the basic computing model for retinal spikes validated by (Pillow et al.). Finally, we apply classifiers (SVM) to the spiking output data to measure the information contained in the spikes.

The code was developed by Guillaume Leseur, David Janssen, and Brian Wandell

You can find an overview presentation of the project here.

The programming pages, with details about the matlab code, are here.



Using Tortoise to checkout the synapse code

The RGC code depends on both ISET and the vismodel directory in the vistaproj repository. In the past, we set out to integrate this code with the Synapse project, but that is no longer our mission.

To check-out the directory on Linux use

 svn co https://white.stanford.edu/srepos/vistaproj/vismodel 

On a Windows machine you can use tortoisesvn as in the image at the right.

Running the RGC code requires a version later than Matlab 2008a, because we use the new 'class' implementation.

The Synapse code that implements the visual recognition network required Python

* Windows version of Python
* Linux version of Python 
* MAC version of Python 

but we do not use that code for the vismodel implementation of the RGC project.

You must add the vistaproj/vismodel directories to your path.

To set the ISET path, go to your ISET directory and type "isetPath(pwd)".

Code overview

This is a very general overview. A more specific introduction to RGC programming is provided elsewhere.

The RGC functions are inside the visual recognition network (vrn) part of the Synapse directory. The VRN directory includes a variety of routines that coordinate with the RGC code. This includes routines for integrating the spiking simulator with the virtual environment, the gbvs (saliency) package, spike-spike transformations (sst), and spike classifiers.

Some of the VRN functions require only Matlab; others require both Matlab and Python.

You can browse the RGC directories using the synapse svn browser. The RGC directory contains multiple sub-directories:

  • customLib
  • data
  • isetLib - Routines that integrate the computations with ISET and the virtual environment
  • rgcLib - Functions for the retinal ganglion cell simulator; name-space: rgcFunctionName.
  • scripts - Scripts; name space: s_rgcScriptName.


To run a simulation with calibrated (photon) images you will need to use ISET. The ISET Matlab toolbox (version 4.0) is available from the ee SVN repository. Please contact Brian Wandell or Joyce Farrell about getting the most recent version. You will need a license (although it is free to you).

The RGC routines that interface with ISET are in the isetLib directory. The main part of the code requiring ISET is the cones absorptions computation (scene2Absorptions function), while the spikes computation (rgcComputeSpikes) runs without ISET.

Without ISET

For calibrated analyses that accurately account for photon levels, lens blurring, and cone absorptions you must include ISET. If you wish to just test ideas without calibration, you can run the RGC functions without ISET.

An example of some rgc code can be found in the s_rgcEdgePopOut.m script, it consists in three main steps:

  1. Building some data that will be the input of the network
  2. Computing the spikes using rgcConesToSpikes.m
  3. Plotting the resulting output.

A simpler example is in s_rgcCreateBasicSimulation.m



We are using ISET and the RGC code to model performance in psychophysical tasks (e.g., contrast sensitivity to gratings). Those applications are described in a rgc perception page.

The idea is to create models of the optics and cone photon catches using ISET. The RGC code converts these cone absorptions into spikes from retinal ganglion cells. We then use SVM spike classifiers to evaluate the information available in the retinal ganglion cell spike trains.

See the s_rgcClassifyExample script that runs the spikeClassify function.

The retinal ganglion cell parameters can be modified to explore the consequences of various spatial and temporal properties.

The script s_rgcContrastSensitivity.m has been worked through a fair amount and is a good example.

You can also find an example of spikes classification with the s_rgcClassifyExample script. Using a low resolution layer, we can get an almost perfect classification:


You can find a more developped example in s_rgcContrastPerFrequency.m where we are computing the ability for the system to distinguish between vertical sines and an uniform signal, depending on contrast and frequency. If you run the script without any changes and display (1-errorHist), you should get something close to:

BOLD Imaging

We plan to use these simulations to model the relationship between the spiking activity and the BOLD response in V1. The rgc BOLD methods are not yet developed, just planned.

Stick in the Mayhew reference on modeling BOLD from spikes. Look-up table thing.

References and older notes

Old RGC page material is here

SVM toolbox written in Matlab

| Brian simulator

Personal tools