auryn::ProfilePoissonGroup Class Reference

A SpikingGroup that creates poissonian spikes with a given rate and spatial profile. More...

#include <ProfilePoissonGroup.h>

Inheritance diagram for auryn::ProfilePoissonGroup:

Collaboration diagram for auryn::ProfilePoissonGroup:

Public Member Functions
	ProfilePoissonGroup (NeuronID n, AurynDouble rate=5.)
virtual	~ProfilePoissonGroup ()
virtual void	evolve ()
void	set_rate (AurynDouble rate)
void	normalize_profile ()
void	set_profile (AurynFloat *newprofile)
void	set_profile (auryn_vector_float *newprofile)
void	set_flat_profile ()
void	set_gaussian_profile (AurynDouble mean, AurynDouble sigma, AurynDouble floor=0.0)
AurynDouble	get_rate ()
void	seed (int s)
Public Member Functions inherited from auryn::SpikingGroup
void	add_state_vector (std::string key, AurynStateVector *state_vector)
	Adds a state vector passed as an argument to the dictinary. More...
void	remove_state_vector (std::string key)
	Removes a state vector passed as an argument to the dictinary. More...
AurynStateVector *	find_state_vector (std::string key)
	Returns existing state vector by name or NULL if it does not exist. More...
AurynStateVector *	get_state_vector (std::string key)
	Creates a new or returns an existing state vector by name. More...
AurynStateVector *	get_existing_state_vector (std::string key)
	Returns an existing state with the supplied name. More...
AurynStateVector *	create_state_vector (std::string key)
	Creates a new state vector and throws an exception if a vector with the same name exists. More...
AurynState *	get_state_variable (std::string key)
	Creates a new group-wide state variable or returns an existing group-wide variable by name then returns a pointer to it. More...
void	randomize_state_vector_gauss (std::string state_vector_name, AurynState mean, AurynState sigma, int seed=12239)
	Randomizes the content of a state vector with Gaussian random numbers. Seeding is MPI save. More...
	SpikingGroup (NeuronID size, NodeDistributionMode mode=AUTO)
	Default constructor. More...
virtual	~SpikingGroup ()
	Default destructor. More...
virtual void	evolve_traces ()
	Evolves traces. More...
void	set_name (std::string s)
	Set connection name. More...
std::string	get_name ()
	Retrieves the groups name. More...
std::string	get_file_name ()
	Extracts the class name of the connection from the file name. More...
std::string	get_log_name ()
	Returns a string which is the combination of file and connection name for logging. More...
void	inc_num_spike_attributes (int x)
	Instructs SpikingGroup to increase the number of spike attributes by x. More...
int	get_num_spike_attributes ()
void	conditional_evolve ()
	Conditional evolve functino which is called by System. More...
unsigned int	get_locked_rank ()
	Returns locked rank for SpikingGroups which are not distributed across all ranks. More...
unsigned int	get_locked_range ()
	Returns locked range of ranks for SpikingGroups which are not distributed across all ranks. More...
SpikeContainer *	get_spikes ()
	Returns pointer to a spike container that contains spikes which arrive in this timestep from all neurons in this group. More...
SpikeContainer *	get_spikes_immediate ()
	Returns pointer to SpikeContainer of spikes generated during the last evolve() step. More...
AttributeContainer *	get_attributes ()
	Returns pointer to Attributecontainer for usage in propagating Connection objects. Same as get_spikes_immediate(), however might be overwritten to contain Spikes that have been delayed. More...
AttributeContainer *	get_attributes_immediate ()
	Returns pointer to Attributecontainer of spikes generated during the last evolve() step. More...
NeuronID	get_size ()
	Returns the size of the group. More...
NeuronID	get_pre_size ()
	Returns the size of the group. More...
NeuronID	calculate_rank_size (int rank=-1)
	Determines rank size and stores it in local variable. More...
NeuronID	get_rank_size ()
	Returns the size on this rank. More...
NeuronID	get_post_size ()
	Returns the size on this rank. More...
void	set_clock_ptr (AurynTime *clock)
bool	evolve_locally ()
	Returns true if the calling instance has units which are integrated on the current rank. More...
NeuronID	get_uid ()
	Get the unique ID of the class. More...
Trace *	get_pre_trace (AurynFloat x)
	Returns a pre trace with time constant x. More...
void	add_pre_trace (Trace *tr)
	Adds trace to pretrace stack of a connection. More...
Trace *	get_post_trace (AurynFloat x)
	Returns a post trace with time constant x. More...
void	add_post_trace (Trace *tr)
	Adds trace to posttrace stack of a connection. More...
void	push_spike (NeuronID spike)
	Pushes a local NeuronID as spike into the axonal SpikeDelay buffer. More...
void	push_attribute (AurynFloat attrib)
	Pushes a spike attribute into the axonal SpikeDelay buffer. More...
void	clear_spikes ()
	Clears all spikes stored in the delays which is useful to reset a network during runtime. More...
Trace *	get_post_state_trace (std::string state_name="mem", AurynFloat tau=10e-3, AurynFloat b=0.0)
	Returns a post trace of a neuronal state variable e.g. the membrane potential with time constant tau. More...
Trace *	get_post_state_trace (AurynStateVector *state, AurynFloat tau=10e-3, AurynFloat b=0.0)
	Returns a post trace of a neuronal state variable specified by pointer. More...
void	set_delay (int d)
	Sets axonal delay for this SpikingGroup. More...
virtual bool	write_to_file (const char *filename)
	Writes current states of SpikingGroup to human-readible textfile if implemented in derived class. More...
virtual bool	load_from_file (const char *filename)
	Reads current states of SpikingGroup to human-readible textfile if implemented in derived class. More...
NeuronID	ranksize ()
	Returns size (num of neurons) on the current rank. More...
NeuronID	global2rank (NeuronID i)
	Converts global NeuronID within the SpikingGroup to the local NeuronID on this rank. More...
NeuronID	rank2global (NeuronID i)
	Converts local NeuronID from the local rank to a global NeuronID. More...
bool	localrank (NeuronID i)
	Checks if the global NeuronID i is integrated on this MPI rank. More...
NeuronID	get_vector_size ()
	Rank size but rounded up to multiples of 4 (or potentially some other and larger number in future versions) for SSE compatibility. More...

Protected Attributes
NeuronID	x
AurynDouble	jumpsize
boost::uniform_01 *	dist
boost::variate_generator< boost::mt19937 &, boost::uniform_01<> > *	die
auryn_vector_float *	profile
	stores the spatial distribution of relative firing rates More...
Protected Attributes inherited from auryn::SpikingGroup
std::vector< Trace * >	pretraces
	Pretraces. More...
std::vector< Trace * >	posttraces
	Posttraces. More...
std::vector< Trace * >	post_state_traces
	Post state traces. More...
std::vector< AurynFloat >	post_state_traces_spike_biases
std::vector< AurynStateVector * >	post_state_traces_states
std::string	group_name
	Identifying name for object. More...
NeuronID	size
	Stores the size of the group. More...
NeuronID	rank_size
	Stores the size of the group on this rank. More...
SpikeContainer *	spikes
	SpikeContainers to store spikes produced during one step of evolve. More...
AttributeContainer *	attribs

Static Protected Attributes
static boost::mt19937	gen = boost::mt19937()
Static Protected Attributes inherited from auryn::SpikingGroup
static AurynTime *	clock_ptr = NULL

Additional Inherited Members
Public Attributes inherited from auryn::SpikingGroup
SpikeDelay *	delay
bool	active
	Toggles group active. More...
std::map< std::string, AurynStateVector * >	state_vectors
std::map< std::string, AurynState >	state_variables
Protected Member Functions inherited from auryn::SpikingGroup
virtual void	load_input_line (NeuronID i, const char *buf)
virtual std::string	get_output_line (NeuronID i)
virtual void	virtual_serialize (boost::archive::binary_oarchive &ar, const unsigned int version)
	Implementatinon of serialize function for writing. More...
virtual void	virtual_serialize (boost::archive::binary_iarchive &ar, const unsigned int version)
	Implementatinon of serialize function for reading. More...
void	free ()
	Frees potentially allocated memory. More...

Detailed Description

A SpikingGroup that creates poissonian spikes with a given rate and spatial profile.

This SpikingGroup is a logic extension of PoissonGroup for (relatively) stationary, but not uniform firing rates. It uses a similar algorithm as PoissonGroup to generate spikes in which each random number yields a spike, but uses a warped output array in which neurons can have different firing probabilities in each timestep. The resulting implementation requires the computation of the cumulative firing probability accross the group in every timestep. It is therefore substantially slower than PoissonGroup, but presumably much faster than drawing random numbers for each neuron in each time step. To set the firing rate profile use the function set_profile which needs to point to an array at which the firing rate profile is stored.

Constructor & Destructor Documentation

ProfilePoissonGroup()

ProfilePoissonGroup::ProfilePoissonGroup	(	NeuronID	n,
		AurynDouble	rate = 5.
	)

Standard constructor.

Parameters

n	is the size of the SpikingGroup, i.e. the number of Poisson neurons.
rate	is the mean firing rate of all poisson neurons in the group.

                                                                       : SpikingGroup( n ) 
{
        init(rate);
}

~ProfilePoissonGroup()

ProfilePoissonGroup::~ProfilePoissonGroup ( )

virtual

Default destructor

{
        if ( evolve_locally() ) {
                delete dist;
                delete die;
        }
}

Here is the call graph for this function:

Member Function Documentation

evolve()

void ProfilePoissonGroup::evolve ( )

virtual

Evolve function for internal use by System

Implements auryn::SpikingGroup.

Reimplemented in auryn::MovingBumpGroup, and auryn::AuditoryBeepGroup.

{
        while ( x < get_rank_size() ) {
                // std::cout << x << std::endl;
                jumpsize -= profile->data[x];
                if ( jumpsize < 0 ) { // reached jump target -> spike
                        push_spike ( x );
                        AurynDouble r = -log((*die)()+1e-20)/lambda;
                        jumpsize = r/auryn_timestep; 
                }
                x++;
        }
        x -= get_rank_size();
}

Here is the call graph for this function:

get_rate()

AurynDouble ProfilePoissonGroup::get_rate

(

)

Standard getter for the firing rate variable.

{
        return lambda;
}

normalize_profile()

void ProfilePoissonGroup::normalize_profile

(

)

{
        AurynDouble sum = 0.0;
        for ( NeuronID i = 0 ; i < get_rank_size() ; ++i ) {
                sum += profile->data[i];
        }

        AurynDouble normalization_factor = get_rank_size()/sum;
        for ( NeuronID i = 0 ; i < get_rank_size() ; ++i ) {
                profile->data[i] *= normalization_factor ;
        }
}

Here is the call graph for this function:

seed()

void ProfilePoissonGroup::seed

(

int

s

)

Use this to seed the random number generator.

{
                gen.seed(s); 
}

set_flat_profile()

void ProfilePoissonGroup::set_flat_profile

(

)

{
        for ( NeuronID i = 0 ; i < get_rank_size() ; ++i ) {
                profile->data[i] = 1.0;
        }
}

Here is the call graph for this function:

set_gaussian_profile()

void ProfilePoissonGroup::set_gaussian_profile	(	AurynDouble	mean,
		AurynDouble	sigma,
		AurynDouble	floor = 0.0
	)

{
        for ( NeuronID i = 0 ; i < get_size() ; ++i ) {
                if ( localrank(i) )
                        profile->data[global2rank(i)] = exp(-pow((i-mean),2)/(2*sigma*sigma))*(1.0-floor)+floor;
        }

        normalize_profile();

        std::stringstream oss;
        oss << "ProfilePoissonGroup:: Setting gaussian profile with mean=" 
                << mean
                << " and sigma="
                << sigma
                << " and floor="
                << floor;
        auryn::logger->msg(oss.str(),VERBOSE);
}

Here is the call graph for this function:

set_profile() [1/2]

void ProfilePoissonGroup::set_profile

(

AurynFloat *

newprofile

)

Sets firing rate profile to the array elements given in newprofile

Expects a vector of the size n of the SpikingGroup.

{
        for ( NeuronID i = 0 ; i < get_size() ; ++i ) {
                if ( localrank( i ) ) 
                        profile->data[global2rank(i)] = newprofile[i];
        }

        normalize_profile();

        std::stringstream oss;
        oss << "ProfilePoissonGroup:: Successfully set external profile." ;
        auryn::logger->msg(oss.str(),NOTIFICATION);
}

Here is the call graph for this function:

set_profile() [2/2]

void ProfilePoissonGroup::set_profile

(

auryn_vector_float *

newprofile

)

Sets firing rate profile to a state vector

Note, does not normalize the profile to a probability distribution! Net firing rate can change! Expects a state vector with appropriate size on the rank which is smaller than or equal to the size of this group.

{
        for ( NeuronID i = 0 ; i < get_rank_size() ; ++i ) {
                profile->data[i] = newprofile->data[i];
        }

        // normalize_profile();

        std::stringstream oss;
        oss << "ProfilePoissonGroup:: Successfully set external profile." ;
        auryn::logger->msg(oss.str(),NOTIFICATION);
}

Here is the call graph for this function:

set_rate()

void ProfilePoissonGroup::set_rate

(

AurynDouble

rate

)

Setter for the firing rate of all neurons. This can be used to change the firing rate during the simulation. Note that changes might have a short latency due to the internal workings of the simulator. Try avoid setting the firing rate in every other timestep because it will reduce performance.

{
        lambda = rate;
    if ( evolve_locally() ) {
                if ( rate > 0.0 ) {
                  AurynDouble r = -log((*die)())/lambda;
                  jumpsize = (r/auryn_timestep);
                  x = 0;
                } else {
                        // if the rate is zero this triggers one spike at the end of time/groupsize
                        // this is the easiest way to take care of the zero rate case, which should 
                        // be avoided in any case.
                        x = std::numeric_limits<NeuronID>::max(); 
                }
    }
}

Here is the call graph for this function:

Member Data Documentation

die

boost::variate_generator<boost::mt19937&, boost::uniform_01<> >* auryn::ProfilePoissonGroup::die

protected

dist

boost::uniform_01* auryn::ProfilePoissonGroup::dist

protected

gen

boost::mt19937 ProfilePoissonGroup::gen = boost::mt19937()

staticprotected

jumpsize

AurynDouble auryn::ProfilePoissonGroup::jumpsize

protected

profile

auryn_vector_float* auryn::ProfilePoissonGroup::profile

protected

stores the spatial distribution of relative firing rates

x

NeuronID auryn::ProfilePoissonGroup::x

protected

---

The documentation for this class was generated from the following files:

• /home/zenke/auryn/src/auryn/ProfilePoissonGroup.h
• /home/zenke/auryn/src/auryn/ProfilePoissonGroup.cpp