auryn::SparseConnection Class Reference

The base class to create sparse random connections. More...

#include <SparseConnection.h>

Inheritance diagram for auryn::SparseConnection:

Collaboration diagram for auryn::SparseConnection:

Public Member Functions
	SparseConnection ()
	Empty constructor which should not be used – TODO should be deprecated at some point. More...
	SparseConnection (const char *filename)
	Load from wmat file constructor which should not be used – TODO should be deprecated at some point. More...
	SparseConnection (NeuronID rows, NeuronID cols)
	Deprecated constructor for manual filling. More...
	SparseConnection (SpikingGroup *source, NeuronGroup *destination, const char *filename, TransmitterType transmitter=GLUT)
	Deprecated constructor for loading from file. More...
	SparseConnection (SpikingGroup *source, NeuronGroup *destination, TransmitterType transmitter=GLUT, string name="SparseConnection")
	Constructor for manual filling. More...
	SparseConnection (SpikingGroup *source, NeuronGroup *destination, AurynWeight weight, AurynDouble sparseness=0.05, TransmitterType transmitter=GLUT, string name="SparseConnection")
	Default constructor which sets up a random sparse matrix with fixed weight between the source and destination group. More...
	SparseConnection (SpikingGroup *source, NeuronGroup *destination, SparseConnection *con, string name="SparseConnection")
	This constructor tries to clone a connection by guessing all parameters except source and destination from another connection instance. More...
	SparseConnection (SpikingGroup *source, NeuronGroup *destination, AurynWeight weight, AurynDouble sparseness, NeuronID lo_row, NeuronID hi_row, NeuronID lo_col, NeuronID hi_col, TransmitterType transmitter=GLUT)
	Sparse block constructor. More...
virtual	~SparseConnection ()
	The default destructor. More...
void	allocate_manually (AurynLong expected_size)
	Is used whenever memory has to be allocated manually. Automatically adjusts for number of ranks and for security margin. More...
AurynLong	estimate_required_nonzero_entires (AurynLong nonzero, double sigma=5.)
	This function estimates the required size of the nonzero entry buffer. More...
void	seed (NeuronID randomseed)
	This function seeds the pseudo random number generator for all random fill operatios. More...
virtual AurynWeight	get (NeuronID i, NeuronID j)
	Returns weight value of a given element if it exists. More...
virtual AurynWeight *	get_ptr (NeuronID i, NeuronID j)
	Returns pointer to given weight element if it exists. Returns NULL if element does not exist. More...
virtual AurynWeight	get_data (NeuronID i)
	Returns weight value of a given element referenced by index in the data array. More...
virtual void	set_data (NeuronID i, AurynWeight value)
	Sets weight value of a given element referenced by its index in the data array. More...
virtual void	set (NeuronID i, NeuronID j, AurynWeight value)
	Sets a single connection to value if it exists. More...
virtual void	set (std::vector< neuron_pair > element_list, AurynWeight value)
	Sets a list of connection to value if they exists. More...
void	random_data (AurynWeight mean, AurynWeight sigma)
	Synonym for random_data. More...
void	random_data_normal (AurynWeight mean, AurynWeight sigma)
	Set weights of all existing connections randomly using a normal distrubtion. More...
void	random_data_lognormal (AurynWeight m, AurynWeight s)
	Set weights of all existing connections randomly using a lognormal distribution. More...
void	init_random_binary (AurynFloat prob=0.5, AurynWeight wlo=0.0, AurynWeight whi=1.0)
	Initialize with random binary at wlo and whi. More...
void	random_col_data (AurynWeight mean, AurynWeight sigma)
	Sets weights in cols to the same value drewn from a Gaussian distribution. More...
void	set_block (NeuronID lo_row, NeuronID hi_row, NeuronID lo_col, NeuronID hi_col, AurynWeight weight)
	Sets all weights of existing connections in a block spanned by the first 4 parameters to the value given. More...
void	scale_block (NeuronID lo_row, NeuronID hi_row, NeuronID lo_col, NeuronID hi_col, AurynWeight alpha)
	Scale all weights of existing connections in a block spanned by the first 4 parameters to the value given. More...
virtual void	set_all (AurynWeight weight)
	Sets all weights of existing connections to the given value. More...
virtual void	scale_all (AurynFloat value)
	Scales all weights in the weight matrix with the given value. More...
virtual void	clip (AurynWeight lo, AurynWeight hi)
	Clip weights. More...
void	set_upper_triangular (AurynWeight weight)
	Sets weights in a upper triangular matrix. More...
virtual void	sparse_set_data (AurynDouble sparseness, AurynWeight value)
	Sets a sparse random subset of connection elements wight the given value. More...
void	connect_random (AurynWeight weight=1.0, AurynDouble sparseness=0.05, bool skip_diag=false)
	Connect src and dst SpikingGroup and NeuronGroup randomly with given sparseness. More...
void	connect_block_random (AurynWeight weight, AurynDouble sparseness, NeuronID lo_row, NeuronID hi_row, NeuronID lo_col, NeuronID hi_col, bool skip_diag=false)
	Underlying sparse fill method. More...
virtual void	finalize ()
	Finalizes connection after random or manual initialization of the weights. More...
bool	push_back (NeuronID i, NeuronID j, AurynWeight weight)
	Pushes a single element to the ComplexMatrix. More...
AurynLong	get_nonzero ()
	Returns number of nonzero elements in this SparseConnection. More...
void	put_pattern (type_pattern *pattern, AurynWeight strength, bool overwrite)
	Puts cell assembly to existing sparse weights. More...
void	put_pattern (type_pattern *pattern1, type_pattern *pattern2, AurynWeight strength, bool overwrite)
	Puts cell assembly or synfire pattern to existing sparse weights. More...
void	load_patterns (string filename, AurynWeight strength, int nb_max_patterns=10000, bool overwrite=false, bool chainmode=false)
	Reads first n patterns from a .pat file and adds them as Hebbian assemblies onto an existing weight matrix. More...
void	load_pre_post_patterns (std::string pre_file, std::string post_file, AurynWeight strength, int nb_max_patterns=10000, bool overwrite=false)
	Reads patterns from two files and connects them. More...
virtual void	propagate ()
	Internally used propagate method. More...
void	sanity_check ()
	Quick an dirty function that checks if all units on the local rank are connected. More...
virtual AurynDouble	sum ()
	Computes sum of all weight elements in the Connection. More...
virtual void	stats (AurynDouble &mean, AurynDouble &std)
	Computes mean and variance of weights in default weight matrix. More...
virtual void	stats (AurynDouble &mean, AurynDouble &std, NeuronID zid)
	Computes mean and variance of weights for matrix state zid. More...
bool	write_to_file (ForwardMatrix *m, string filename)
	Writes rank specific weight matrix on the same rank to a file. More...
virtual bool	write_to_file (string filename)
	Writes rank specific default weight matrix on the same rank to a file. More...
virtual bool	load_from_complete_file (string filename)
	Loads weight matrix from a single file. More...
virtual bool	load_from_file (string filename)
	Loads weight matrix from Matrix Market (wmat) file. More...
bool	load_from_file (ForwardMatrix *m, string filename, AurynLong data_size=0)
	Loads weight matrix from Matrix Market (wmat) file to specified weight matrix. More...
virtual void	set_min_weight (AurynWeight minimum_weight)
	Sets minimum weight (for plastic connections). More...
AurynWeight	get_min_weight ()
	Gets minimum weight (for plastic connections). More...
virtual void	set_max_weight (AurynWeight maximum_weight)
	Sets maximum weight (for plastic connections). More...
AurynWeight	get_max_weight ()
	Gets maximum weight (for plastic connections). More...
std::vector< neuron_pair >	get_block (NeuronID lo_row, NeuronID hi_row, NeuronID lo_col, NeuronID hi_col)
	Returns a vector of ConnectionsID of a block specified by the arguments. More...
std::vector< neuron_pair >	get_post_partners (NeuronID i)
	Returns a vector of ConnectionsID of postsynaptic parterns of neuron i. More...
std::vector< neuron_pair >	get_pre_partners (NeuronID j)
	Returns a vector of ConnectionsID of presynaptic parterns of neuron i. More...
Public Member Functions inherited from auryn::Connection
	Connection ()
	Connection (NeuronID rows, NeuronID cols)
	Connection (SpikingGroup *source, NeuronGroup *destination, TransmitterType transmitter=GLUT, std::string name="Connection")
virtual	~Connection ()
void	set_size (NeuronID i, NeuronID j)
void	set_name (std::string name)
	Set name of connection. More...
std::string	get_name ()
	Returns name of connection. 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...
AurynStateVector *	get_target_vector ()
	Returns target state vector if one is defined. More...
NeuronID	get_m_rows ()
	Get number of rows (presynaptic) in connection. More...
NeuronID	get_n_cols ()
	Get number of columns (postsynaptic) in connection. More...
TransmitterType	get_transmitter ()
	Returns transmitter type. More...
void	set_target (AurynWeight *ptr)
	Sets target state of this connection directly via a pointer. More...
void	set_target (AurynStateVector *ptr)
	Sets target state of this connection directly via a StateVector. More...
void	set_receptor (AurynStateVector *ptr)
	Same as set_target. More...
void	set_transmitter (AurynStateVector *ptr)
	Same as set_target. More...
void	set_transmitter (TransmitterType transmitter)
	Sets target state of this connection for a given receptor as one of Auryn's default transmitter types. More...
void	set_receptor (string state_name)
	Sets target state of this connection directly the name of a state vector. More...
void	set_target (string state_name)
	Same as set_receptor. More...
void	set_transmitter (string state_name)
	Same as set_receptor, but DEPRECATED. More...
void	set_source (SpikingGroup *source)
	Sets source SpikingGroup of this connection. More...
SpikingGroup *	get_source ()
	Returns pointer to the presynaptic group. More...
void	set_destination (NeuronGroup *source)
	Sets destination SpikingGroup of this connection. More...
NeuronGroup *	get_destination ()
	Returns pointer to the postsynaptic group. More...
virtual void	evolve ()
	Evolve method to update internal connection state. Called by System run method. More...
void	conditional_propagate ()
	DEPRECATED. (Such connections should not be registered in the first place) Calls propagate only if the postsynaptic NeuronGroup exists on the local rank. More...
Trace *	get_pre_trace (const AurynDouble tau)
	Returns a pointer to a presynaptic trace object. More...
Trace *	get_post_trace (const AurynDouble tau)
	Returns a pointer to a postsynaptic trace object. More...
Trace *	get_post_state_trace (const string state_name, const AurynDouble tau, const AurynDouble jump_size=0.0)
	Returns a pointer to a postsynaptic state trace object. More...
void	transmit (const NeuronID id, const AurynWeight amount)
	Default way to transmit a spike to a postsynaptic partner. More...
void	targeted_transmit (SpikingGroup *target_group, AurynStateVector *target_state, const NeuronID id, const AurynWeight amount)
	Transmits a spike to a given target group and state. More...
void	safe_transmit (NeuronID id, AurynWeight amount)
	Same as transmit but first checks if the target neuron exists and avoids segfaults that way (but it's also slower). More...
SpikeContainer *	get_pre_spikes ()
	Supplies pointer to SpikeContainer of all presynaptic spikes. More...
SpikeContainer *	get_post_spikes ()
	Returns pointer to SpikeContainer for postsynaptic spikes on this node. More...
void	add_number_of_spike_attributes (int x)
	Set up spike delay to accomodate x additional spike attributes. More...
AurynFloat	get_spike_attribute (const NeuronID i, const int attribute_id=0)
	Returns spike attribute belonging to the spike at position i in the get_spikes() SpikeContainer. More...

Public Attributes
bool	patterns_ignore_gamma
	Switch that toggles for the load_patterns function whether or not to use the intensity (gamma) value. Default is false. More...
NeuronID	patterns_every_pre
	The every_pre parameter allows to skip presynaptically over pattern IDs when loading patterns. Default is 1. This can be useful to when loading patterns into the exc->inh connections and there significantly less inhibitory cells than exc ones. More...
NeuronID	patterns_every_post
	The every_post parameter allows to skip postsynaptically over pattern IDs when loading patterns. Default is 1. This can be useful to when loading patterns into the exc->inh connections and there significantly less inhibitory cells than exc ones. More...
bool	wrap_patterns
	Switch that toggles the behavior when loading a pattern to wrap neuron IDs back onto existing cells via the modulo function. More...
ForwardMatrix *	w
	A pointer that points per default to the ComplexMatrix that stores the connectinos. More...
Public Attributes inherited from auryn::Connection
SpikingGroup *	src
	Pointer to the source group of this connection. More...
NeuronGroup *	dst
	Pointer to the destination group of this connection. More...

Protected Member Functions
void	virtual_serialize (boost::archive::binary_oarchive &ar, const unsigned int version)
void	virtual_serialize (boost::archive::binary_iarchive &ar, const unsigned int version)
void	free ()
void	allocate (AurynLong bufsize)
std::vector< type_pattern >	load_pattern_file (string filename, int nb_max_patterns)
	Reads patterns from a .pat file and returns a vector with the patterns. More...
Protected Member Functions inherited from auryn::Connection
void	init (TransmitterType transmitter=GLUT)

Protected Attributes
AurynWeight	wmin
AurynWeight	wmax
bool	skip_diagonal
Protected Attributes inherited from auryn::Connection
TransmitterType	trans
AurynStateVector *	target_state_vector
AurynFloat *	target
	A more direct reference on the first element of the target_state_vector. More...
NeuronID	number_of_spike_attributes
	Number of spike attributes to expect with each spike transmitted through this connection. More...
NeuronID	spike_attribute_offset
	Stores spike attribute offset in attribute array. More...

Static Protected Attributes
static boost::mt19937	sparse_connection_gen = boost::mt19937()

Detailed Description

The base class to create sparse random connections.

This direct derivative of the virtual Connection type is the most commonly used class to create connections in Auryn. It makes use of the ComplexMatrix container to memory efficiently store synaptic weights and to make them easily accessible in a feed-forward manner for spike propagation.

Most plastic connection types such as TripletConnection inherit from SparseConnecion via the intermediate Duplexconnection.

Constructor & Destructor Documentation

SparseConnection() [1/8]

auryn::SparseConnection::SparseConnection

(

)

Empty constructor which should not be used – TODO should be deprecated at some point.

SparseConnection() [2/8]

SparseConnection::SparseConnection

(

const char *

filename

)

Load from wmat file constructor which should not be used – TODO should be deprecated at some point.

                                                        : Connection()
{
        init();
        if (! init_from_file(filename) )
                throw AurynMMFileException();
}

SparseConnection() [3/8]

SparseConnection::SparseConnection	(	NeuronID	rows,
		NeuronID	cols
	)

Deprecated constructor for manual filling.

Deprecated:

                                                               : Connection(rows,cols)
{
        init();
}

SparseConnection() [4/8]

SparseConnection::SparseConnection	(	SpikingGroup *	source,
		NeuronGroup *	destination,
		const char *	filename,
		TransmitterType	transmitter = GLUT
	)

Deprecated constructor for loading from file.

Deprecated:

                                                                                                                                       : Connection(source, destination, transmitter)
{
        init();
        if (! init_from_file(filename) )
                throw AurynMMFileException();
}

SparseConnection() [5/8]

SparseConnection::SparseConnection	(	SpikingGroup *	source,
		NeuronGroup *	destination,
		TransmitterType	transmitter = GLUT,
		std::string	name = "SparseConnection"
	)

Constructor for manual filling.

        : Connection(source,destination,transmitter,name)
{
        init();
        std::stringstream oss;
        oss << get_log_name() << "Setting up SparseConnection without connecting it. Needs to be manually connected!";
        auryn::logger->msg(oss.str(),VERBOSE);
}

Here is the call graph for this function:

SparseConnection() [6/8]

SparseConnection::SparseConnection	(	SpikingGroup *	source,
		NeuronGroup *	destination,
		AurynWeight	weight,
		AurynDouble	sparseness = 0.05,
		TransmitterType	transmitter = GLUT,
		std::string	name = "SparseConnection"
	)

Default constructor which sets up a random sparse matrix with fixed weight between the source and destination group.

The constructor takes the weight and sparseness as secondary arguments. The latter allows Auryn to allocate the approximately right amount of memory inadvance. It is good habit to specify at time of initialization also a connection name and the transmitter type. Both can be set separately with set_transmitter and set_name if the function call gets too long and ugly. A connection name is often handy during debugging and the transmitter type is a crucial for obvious resons ...

        : Connection(source,destination,transmitter,name)
{
        init();
        std::stringstream oss;

        AurynLong anticipatedsize = (AurynLong) (estimate_required_nonzero_entires ( sparseness*src->get_pre_size()*dst->get_post_size() ) );
        oss << get_log_name() << "Assuming memory demand for pre #" << src->get_pre_size() << " and post #" << dst->get_post_size() 
                                                                                                        << std::scientific << std::setprecision(4) << " ( total " << anticipatedsize << ")";
        auryn::logger->msg(oss.str(),VERBOSE);
        allocate(anticipatedsize);
        connect_random(weight,sparseness,skip_diagonal);
}

Here is the call graph for this function:

SparseConnection() [7/8]

SparseConnection::SparseConnection	(	SpikingGroup *	source,
		NeuronGroup *	destination,
		SparseConnection *	con,
		std::string	name = "SparseConnection"
	)

This constructor tries to clone a connection by guessing all parameters except source and destination from another connection instance.

        : Connection(source,destination)
{
        set_transmitter(con->get_transmitter());
        AurynDouble sparseness = get_nonzero()/(con->get_m_rows()*con->get_n_cols());
        AurynDouble mean,std; con->stats(mean,std);
        AurynLong anticipatedsize = (AurynLong) (estimate_required_nonzero_entires ( sparseness*src->get_pre_size()*dst->get_post_size() ) );
        allocate(anticipatedsize);
        connect_random(mean,sparseness,con->skip_diagonal);
}

Here is the call graph for this function:

SparseConnection() [8/8]

SparseConnection::SparseConnection	(	SpikingGroup *	source,
		NeuronGroup *	destination,
		AurynWeight	weight,
		AurynDouble	sparseness,
		NeuronID	lo_row,
		NeuronID	hi_row,
		NeuronID	lo_col,
		NeuronID	hi_col,
		TransmitterType	transmitter = GLUT
	)

Sparse block constructor.

This constructor initializes the connection with random sparse weights, but only fills a "block" as specified instead of the entire matrix.

        : Connection(source,destination,transmitter)
{
        NeuronID rows = hi_row - lo_row;
        NeuronID cols = hi_col - lo_col;
        init();
        allocate((AurynLong) ( estimate_required_nonzero_entires( sparseness*rows*cols ) ));
        w->clear();
        connect_block_random(weight,sparseness,lo_row,hi_row,lo_col,hi_col,skip_diagonal);
        finalize();
}

Here is the call graph for this function:

~SparseConnection()

SparseConnection::~SparseConnection ( )

virtual

The default destructor.

{
        free();
}

Here is the call graph for this function:

Member Function Documentation

allocate()

void SparseConnection::allocate ( AurynLong  bufsize )

protected

Allocates memory for a given sparse connectivity matrix. Usually ComplexMatrix or ComplexMatrix

{
        NeuronID m = get_m_rows();  
        NeuronID n = get_n_cols();

        std::stringstream oss;
        oss << get_log_name() << "Allocating sparse matrix (" << m << ", " << n << ") with space for "  << std::scientific << std::setprecision(4) << (double) bufsize <<  " nonzero elements ";

        auryn::logger->msg(oss.str(),VERBOSE);

        AurynLong maxsize = m*n;
        
        w = new ForwardMatrix ( m, n , std::min(maxsize,bufsize) );

        has_been_allocated = true;
}

Here is the call graph for this function:

allocate_manually()

void SparseConnection::allocate_manually

(

AurynLong

expected_size

)

Is used whenever memory has to be allocated manually. Automatically adjusts for number of ranks and for security margin.

{
        AurynDouble dilution = (AurynDouble) dst->get_rank_size()/dst->get_size();
        allocate( estimate_required_nonzero_entires ( dilution*expected_size ) );
}

Here is the call graph for this function:

clip()

void SparseConnection::clip ( AurynWeight  lo, AurynWeight  hi  )

virtual

Clip weights.

{
        for ( AurynWeight * ptr = w->get_data_begin() ; ptr != w->get_data_end()  ; ++ptr ) {
                if ( *ptr < lo )
                        *ptr = lo;
                else
                        if ( *ptr > hi )
                                *ptr = hi;
        }
}

Here is the call graph for this function:

connect_block_random()

void SparseConnection::connect_block_random	(	AurynWeight	weight,
		AurynDouble	sparseness,
		NeuronID	lo_row,
		NeuronID	hi_row,
		NeuronID	lo_col,
		NeuronID	hi_col,
		bool	skip_diag = false
	)

Underlying sparse fill method.

Set dist_optimized to false and seed all ranks the same to get the same matrix independent of the number of ranks. Called internally or when you know what you are doing.

{
        // do some sanity checks
        if ( sparseness <= 0.0 ) {
                auryn::logger->msg("Trying to set up a SparseConnection with sparseness smaller or equal to zero, which doesn't make sense",ERROR);
                throw AurynGenericException();
        }
        if ( sparseness > 1.0 ) {
                auryn::logger->msg("Sparseness larger than 1 not allowed. Setting to 1.",WARNING);
                sparseness = 1.0;
        }

        if ( weight < get_min_weight() ) {
                auryn::logger->msg("Weight smaller than minimal weight. Updating minimal weight and proceeding.",WARNING);
                set_min_weight(weight);
        }

        int r = 0; // these variables are used to speed up building the matrix if the destination is distributed
        int s = 1;

        r = sys->mpi_rank()-dst->get_locked_rank(); 
        s = dst->get_locked_range();

        // correction for "refractoriness"
        double lambda = 1.0/(1.0/sparseness-1.0);
        boost::exponential_distribution<> dist(lambda);
        boost::variate_generator<boost::mt19937&, boost::exponential_distribution<> > die(SparseConnection::sparse_connection_gen, dist);

        if (!has_been_allocated)
                throw AurynConnectionAllocationException();

        AurynLong idim = (hi_row-lo_row);
        AurynLong jdim = (hi_col-lo_col)/s;
        if ( (hi_col-lo_col)%s > r ) { // some ranks have one more "carry" neuron
                jdim += 1;
        }

        // we keep track of the real valued jump size ...
    AurynDouble jump = 0.0;
        // ... and the discretized position along the weight matrix
    AurynLong x = (AurynLong) die();

        if ( sparseness == 1.0 ) x = 0; // for dense matrices
    AurynLong stop = idim*jdim;
    AurynLong count = 0;
    NeuronID i = 0;
    NeuronID j = 0;
    while ( x < stop ) {
                i = lo_row+x/jdim;
                j = lo_col + s*(x%jdim) + r; // be carfule with this line ... it already was the cause of a lot of headaches
                if ( (j >= lo_col) && (!skip_diag || i!=j)) {
                        try {
                                if ( push_back(i,j,weight) )
                                        count++;
                        }
                        catch ( AurynMatrixDimensionalityException )
                        {
                                std::stringstream oss;
                                oss << get_log_name() 
                                        <<"Trying to add elements outside of matrix (i=" 
                                        << i 
                                        << "j="
                                        << j 
                                        << ", "
                                        << count 
                                        << "th element) ";
                                auryn::logger->msg(oss.str(),ERROR);
                                return;
                        } 
                        catch ( AurynMatrixPushBackException )
                        {
                                std::stringstream oss;
                                oss << get_log_name() 
                                        << "Failed pushing back element. Maybe due to out of order pushing? "
                                        << " (" << i << "," << j << ") "
                                        << " with count=" << count 
                                        << " in connect_block_random ( fill_level= " << w->get_fill_level() << " )";
                                auryn::logger->msg(oss.str(),ERROR);
                                return;
                        } 
                        catch ( AurynMatrixBufferException )
                        {
                                std::stringstream oss;
                                oss << get_log_name() 
                                        <<"Buffer full after pushing " 
                                        << count 
                                        << " elements."
                                        << " There are pruned connections!";
                                auryn::logger->msg(oss.str(),ERROR);
                                return;
                        } 
                }

                if ( sparseness < 1.0 ) { 
                        // here we add our random exponential jump which was corrected
                        // for the 1.0 "refractory period" to account for the fact that
                        // we can have only one connection per "slot"
                        jump += die()+1.0;

                        // here we discretize this jump
                        AurynLong discrete_jump = jump;

                        // but keep the rest for the next jump to avoid discretization biases
                        jump -= discrete_jump;

                        // now we added discrete_jump to x and we are ready for the next connection
                        x += discrete_jump;
                } else { // dense matrices
                        x += 1 ;
                }
        }

        std::stringstream oss;
        oss << get_log_name() << "Finished connect_block_random ["
                << lo_row << ", " << hi_row << ", " << lo_col << ", " << hi_col <<  "] " << " (stop count " 
                << std::scientific << std::setprecision(4) << (double) stop 
                << ") and successfully pushed " << (double) count <<  " entries. " 
        << "Resulting overall sparseness " << 1.*get_nonzero()/src->get_pre_size()/dst->get_post_size();
        auryn::logger->msg(oss.str(),VERBOSE);
}

Here is the call graph for this function:

connect_random()

void SparseConnection::connect_random	(	AurynWeight	weight = 1.0,
		AurynDouble	sparseness = 0.05,
		bool	skip_diag = false
	)

Connect src and dst SpikingGroup and NeuronGroup randomly with given sparseness.

This function should be usually called from the constructor directly.

{
        if ( dst->evolve_locally() ) { // if there are no local units there is no need for synapses
                std::stringstream oss;
                oss << get_log_name() <<"Randomfill with weight "<< weight <<  " and sparseness " << sparseness;
                auryn::logger->msg(oss.str(),VERBOSE);
                w->clear();
                connect_block_random(weight,sparseness,0,get_m_rows(),0,get_n_cols(),skip_diag);
        }
        finalize();
}

Here is the call graph for this function:

estimate_required_nonzero_entires()

AurynLong SparseConnection::estimate_required_nonzero_entires	(	AurynLong	nonzero,
		double	sigma = 5.
	)

This function estimates the required size of the nonzero entry buffer.

It's typicall used internally or when you know what you are doing.

{
        return std::min( (AurynLong)( nonzero + sigma*sqrt(1.0*nonzero) ), (AurynLong)(get_m_rows()*get_n_cols()) ) ;
}

Here is the call graph for this function:

finalize()

void SparseConnection::finalize ( )

virtual

Finalizes connection after random or manual initialization of the weights.

Essentially pads zeros or non-existing elements at the end of ComplexMatrix. Called interally or after manually filling matrices.

Implements auryn::Connection.

Reimplemented in auryn::TripletConnection, auryn::LPTripletConnection, auryn::MinimalTripletConnection, auryn::STDPwdConnection, auryn::TripletScalingConnection, auryn::STDPConnection, and auryn::DuplexConnection.

{
        w->fill_na();
        if ( dst->evolve_locally() ) {
                std::stringstream oss;
                oss << get_log_name() << "Finalized with fill level " << w->get_fill_level();
                auryn::logger->msg(oss.str(),VERBOSE);
                if (w->get_fill_level()<WARN_FILL_LEVEL)
                {
                        std::stringstream oss2;
                        oss2 << get_log_name() <<"Wasteful fill level (" << w->get_fill_level() << ")! Make sure everything is in order!";
                        auryn::logger->msg(oss2.str(),WARNING);
                }
        }
}

Here is the call graph for this function:

free()

void SparseConnection::free ( )

protected

{
        delete w;
}

get()

AurynWeight SparseConnection::get ( NeuronID  i, NeuronID  j  )

virtual

Returns weight value of a given element if it exists.

Implements auryn::Connection.

{
        return w->get(i,j);
}

Here is the call graph for this function:

get_block()

std::vector< neuron_pair > SparseConnection::get_block	(	NeuronID	lo_row,
		NeuronID	hi_row,
		NeuronID	lo_col,
		NeuronID	hi_col
	)

Returns a vector of ConnectionsID of a block specified by the arguments.

{
        std::vector<neuron_pair> clist;
        for ( NeuronID i = 0 ; i < get_m_rows() ; ++i ) 
        {
                for ( NeuronID * j = w->get_row_begin(i) ; j != w->get_row_end(i) ; ++j )
                {
                        if (i >= lo_row && i < hi_row && *j >= lo_col && *j < hi_col ) {
                                neuron_pair a;
                                a.i = i;
                                a.j = *j;
                                clist.push_back( a );
                        }
                }
        }
        return clist;
}

Here is the call graph for this function:

get_data()

AurynWeight SparseConnection::get_data ( NeuronID  i )

virtual

Returns weight value of a given element referenced by index in the data array.

Implements auryn::Connection.

{
        return w->get_data(i);
}

Here is the call graph for this function:

get_max_weight()

AurynWeight auryn::SparseConnection::get_max_weight ( )

inline

Gets maximum weight (for plastic connections).

                                     {
                return wmax;
        };

Here is the call graph for this function:

get_min_weight()

AurynWeight auryn::SparseConnection::get_min_weight ( )

inline

Gets minimum weight (for plastic connections).

                                     {
                return wmin;
        };

Here is the call graph for this function:

get_nonzero()

AurynLong SparseConnection::get_nonzero ( )

virtual

Returns number of nonzero elements in this SparseConnection.

Implements auryn::Connection.

{
        return w->get_nonzero();
}

Here is the call graph for this function:

get_post_partners()

std::vector< neuron_pair > SparseConnection::get_post_partners

(

NeuronID

i

)

Returns a vector of ConnectionsID of postsynaptic parterns of neuron i.

{
        std::vector<neuron_pair> clist;
        for ( NeuronID * j = w->get_row_begin(i) ; j != w->get_row_end(i) ; ++j )
        {
                neuron_pair a;
                a.i = i;
                a.j = *j;
                clist.push_back( a );
        }
        return clist;
}

Here is the call graph for this function:

get_pre_partners()

std::vector< neuron_pair > SparseConnection::get_pre_partners

(

NeuronID

j

)

Returns a vector of ConnectionsID of presynaptic parterns of neuron i.

{
        std::vector<neuron_pair> clist;
        for ( NeuronID i = 0 ; i < get_m_rows() ; ++i ) 
        {
                if ( get_ptr(i,j) != NULL ) {
                        neuron_pair a;
                        a.i = i;
                        a.j = j;
                        clist.push_back( a );
                }
        }
        return clist;
}

Here is the call graph for this function:

get_ptr()

AurynWeight * SparseConnection::get_ptr ( NeuronID  i, NeuronID  j  )

virtual

Returns pointer to given weight element if it exists. Returns NULL if element does not exist.

Implements auryn::Connection.

{
        return w->get_ptr(i,j);
}

Here is the call graph for this function:

init_random_binary()

void SparseConnection::init_random_binary	(	AurynFloat	prob = 0.5,
		AurynWeight	wlo = 0.0,
		AurynWeight	whi = 1.0
	)

Initialize with random binary at wlo and whi.

Parameters

wlo	The lower weight value.
whi	The higher weight value.
prob	the probability for the higher value.

{
        std::stringstream oss;
        oss << get_log_name() << "randomizing non-zero connections (gaussian) with binary weights between " 
                << wlo << " and " << whi ;
        auryn::logger->msg(oss.str(),NOTIFICATION);

        boost::uniform_real<> dist(0.0, 1.0);
        boost::variate_generator<boost::mt19937&, boost::uniform_real<> > die(SparseConnection::sparse_connection_gen, dist);
        AurynWeight rv;

        for ( AurynLong i = 0 ; i<w->get_nonzero() ; ++i ) {
                rv = die();
                if ( rv<prob ) {
                        w->set_data(i,whi);
                } else {
                        w->set_data(i,wlo);
                }
        }
}

Here is the call graph for this function:

load_from_complete_file()

bool SparseConnection::load_from_complete_file ( std::string  filename )

virtual

Loads weight matrix from a single file.

Since a single file might contain a lot more elements than memory required this function performs a dry run during which it counts the required number of elements. This function should be optimized to avoid on large clusters the complete hammering of the fileserver. An idea would be to let one rank do all the work and distribute the established file-counts to all the stations

{
        AurynLong datasize = dryrun_from_file(filename);
        std::stringstream oss;
        oss << "Loading from complete wmat file "
                << "(all ranks in the same file). Element count: "
                << datasize 
                << ".";
        auryn::logger->msg(oss.str(),NOTIFICATION);
        bool returnvalue = load_from_file(w,filename,datasize);
        finalize();
        return returnvalue;
}

Here is the call graph for this function:

load_from_file() [1/2]

bool SparseConnection::load_from_file ( std::string  filename )

virtual

Loads weight matrix from Matrix Market (wmat) file.

This function expects an Auryn readable Matrix Market file such as generated by write_to_file methods which only includes weight elements which belong on this very rank. To load wmat files containing all weights indepent of rank use the load_from_complete_file method. Note that these methods only store information of the first element of a ComplexMatrix. To store all informtion of a ComplexMatrix use the mechanisms in place to save the network state which are implemented in the System class.

Implements auryn::Connection.

Reimplemented in auryn::RateModulatedConnection.

{
        bool result = load_from_file(w,filename);
        finalize();
        return result;
}

Here is the call graph for this function:

load_from_file() [2/2]

bool SparseConnection::load_from_file	(	ForwardMatrix *	m,
		std::string	filename,
		AurynLong	data_size = 0
	)

Loads weight matrix from Matrix Market (wmat) file to specified weight matrix.

This function expects an Auryn readable Matrix Market file such as generated by write_to_file methods which only includes weight elements which belong on this very rank. To load wmat files containing all weights indepent of rank use the load_from_complete_file method.

{
        if ( !dst->evolve_locally() ) return true;

        char buffer[256];
        std::ifstream infile (filename.c_str());
        if (!infile) {
                std::stringstream oss;
                oss << get_log_name() << "Can't open input file " << filename;
                auryn::logger->msg(oss.str(),ERROR);
                throw AurynOpenFileException();
        }

        set_name(filename);

        NeuronID i,j;
        AurynLong k;
        unsigned int count = 0;
        unsigned int pushback_count = 0;
        float val;

        // read connection details
        infile.getline (buffer,256); count++;
        std::string header("%%MatrixMarket matrix coordinate real general");
        if (header.compare(buffer)!=0)
        {
                std::stringstream oss;
                oss << get_log_name() << "Input format not recognized.";
                auryn::logger->msg(oss.str(),ERROR);
                return false;
        }
        while ( buffer[0]=='%' ) {
          infile.getline (buffer,256);
          count++;
        }

        sscanf (buffer,"%u %u %lu",&i,&j,&k);
        set_size(i,j);

        if ( data_size ) { 
                k = data_size;
        }
        
        if ( m->get_datasize() >= k ) {
                m->clear();
        } else {
                std::stringstream oss;
                oss << get_log_name() << "Buffer too small ("
                        << m->get_datasize()
                        << " -> "
                        << k
                        << " elements). Reallocating.";
                auryn::logger->msg(oss.str() ,NOTIFICATION);
                m->resize_buffer_and_clear(k);
        }

        std::stringstream oss;
        oss << get_name() 
                << ": Reading from file ("
                << get_m_rows()<<"x"<<get_n_cols()
                << " @ "<<1.*k/(src->get_size()*dst->get_rank_size())<<")";
        auryn::logger->msg(oss.str(),NOTIFICATION);


        while ( infile.getline (buffer,255) )
        {
                count++;
                sscanf (buffer,"%u %u %e",&i,&j,&val);
                try {
                        if ( dst->localrank(j-1) ) {
                                m->push_back(i-1,j-1,val);
                                pushback_count++;
                        }
                }
                catch ( AurynMatrixPushBackException )
                {
                        std::stringstream oss;
                        oss << get_log_name() << "Push back failed. Error in line=" << count << ", "
                                << " i=" << i 
                                << " j=" << j 
                                << " v=" << val << ". "
                                << " After pushing " << pushback_count << " elements. "
                                << " Bad row major order?";
                        auryn::logger->msg(oss.str(),ERROR);
                        throw AurynMMFileException();
                        return false;
                } 
                catch ( AurynMatrixBufferException )
                {
                        std::stringstream oss;
                        oss << get_name() 
                                << ": Buffer full after pushing " 
                                << count << " elements."
                                << " There are pruned connections!";
                        auryn::logger->msg(oss.str(),ERROR);
                        return false;
                } 
                catch ( AurynMatrixDimensionalityException )
                {
                        std::stringstream oss;
                        oss << get_log_name() 
                                <<"Trying to add elements outside of matrix (i=" 
                                << i 
                                << ", j="
                                << j 
                                << ", "
                                << count 
                                << "th element) ";
                        auryn::logger->msg(oss.str(),ERROR);
                        return false;
                } 
        }


        infile.close();

        if ( pushback_count != m->get_nonzero() ) { // this should never happen without an exception above, but better be save than sorry
                oss.str("");
                oss << get_log_name() 
                        << pushback_count 
                        << " elements pushed, but only "
                        << m->get_nonzero()
                        << " in matrix matrix.";
                auryn::logger->msg(oss.str(),ERROR);
        } else {
                oss.str("");
                oss << get_log_name() << "OK, " 
                        << pushback_count 
                        << " elements pushed.";
                auryn::logger->msg(oss.str(),VERBOSE);
        }

        m->fill_na();
        // finalize(); // commented this line out because it only acts on w

        return true;
}

Here is the call graph for this function:

load_pattern_file()

std::vector< type_pattern > SparseConnection::load_pattern_file ( string  filename, int  nb_max_patterns  )

protected

Reads patterns from a .pat file and returns a vector with the patterns.

Parameters

filename	The file to load
nb_max_patterns	The maximum number of patterns to load.

Returns

A vector with elements of type_pattern. Returns an empty vector on file error.

{
        std::vector<type_pattern> patterns;

        std::ifstream fin (filename.c_str());
        if (!fin) {
                std::stringstream oss2;
                oss2 << get_log_name() << "There was a problem opening file " << filename << " for reading.";
                auryn::logger->msg(oss2.str(),WARNING);
                return patterns;
        } else {
                std::stringstream oss;
                oss << get_log_name() << "Loading patterns from " << filename << " ...";
                auryn::logger->msg(oss.str(),NOTIFICATION);
        }

        unsigned int patcount = 0 ;

        NeuronID mindimension = std::min( get_m_rows()*patterns_every_pre, get_n_cols()*patterns_every_post );
        bool istoolarge = false;
        

        type_pattern pattern;
        char buffer[256];
        std::string line;

        while(!fin.eof()) {
                line.clear();
                fin.getline (buffer,255);
                line = buffer;

                if(line[0] == '#') continue;
                if ( patcount >= nb_max_patterns ) break;
                if (line == "") { 
                        if ( pattern.size() > 0 ) {
                                // put_pattern( &pattern, strength, overwrite );
                                patterns.push_back(pattern);
                                patcount++;
                                pattern.clear();
                        }
                        continue;
                }

                pattern_member pm;
                std::stringstream iss (line);
                pm.gamma = 1 ; 
                iss >>  pm.i ;
                if ( !wrap_patterns && !istoolarge && pm.i > mindimension ) { 
                        std::stringstream oss;
                        oss << get_log_name() << "Some elements of pattern " << patcount << " are larger than the underlying NeuronGroups!";
                        auryn::logger->msg(oss.str(),WARNING);
                        istoolarge = true;
                }
                iss >>  pm.gamma ;
                if ( patterns_ignore_gamma ) 
                        pm.gamma = 1;
                pattern.push_back(pm) ;
        }

        fin.close();

        return patterns;
}

Here is the call graph for this function:

load_patterns()

void SparseConnection::load_patterns	(	std::string	filename,
		AurynWeight	strength,
		int	nb_max_patterns = 10000,
		bool	overwrite = false,
		bool	chainmode = false
	)

Reads first n patterns from a .pat file and adds them as Hebbian assemblies onto an existing weight matrix.

Parameters

filename	The file to read the patterns from
strength	The strength to set or add to connections within a pattern (depending on setting of overwrite)
nb_max_patterns	The maximum number of patterns to load (default 10000)
overwrite	Whether to add strength to each connection in the pattern or whether to set the connection to he value specified (default false)
chainmode	If set to true the function does not create cell assemblies but a synfire chain architecture in which each pattern is connected to the next as a chain.

{
        std::vector<type_pattern> patterns = load_pattern_file( filename, nb_max_patterns );

        if ( chainmode ) {
                for ( int i = 0 ; i < patterns.size()-1 ; ++i ) {
                        put_pattern( &(patterns[i]), &(patterns[i+1]), strength, overwrite );
                }
        } else {
                for ( int i = 0 ; i < patterns.size() ; ++i ) {
                        put_pattern( &(patterns[i]), strength, overwrite );
                }
        }

        // put_pattern( &pattern, strength );

        std::stringstream oss;
        oss << get_log_name() << "Added " << patterns.size() << " patterns";
        auryn::logger->msg(oss.str(),NOTIFICATION);
}

Here is the call graph for this function:

load_pre_post_patterns()

void SparseConnection::load_pre_post_patterns	(	std::string	pre_file,
		std::string	post_file,
		AurynWeight	strength,
		int	nb_max_patterns = 10000,
		bool	overwrite = false
	)

Reads patterns from two files and connects them.

Parameters

pre_file	File containint the presynaptic patterns
post_file	File containint the postsynaptic patterns
strength	Synaptic strength value of a connection
nb_max_patterns	The maximum number of patterns to load (default 10000)
overwrite	Whether to add or set strength to each connection (default false)

This function can be used to connect a bunch of populations in one group to different populations in another group. The two pattern files must have the same number of patterns stored.

{
        std::vector<type_pattern> pre_patterns = load_pattern_file( pre_file, nb_max_patterns );
        std::vector<type_pattern> post_patterns = load_pattern_file( post_file, nb_max_patterns );

        // check if both files supplied the same number of patterns
        if ( pre_patterns.size() != post_patterns.size() ) {
                auryn::logger->error("Error loading patterns. Number of patterns in prefile and postfile does not match. Aborting.");
                return;
        }

        for ( int i = 0 ; i < pre_patterns.size() ; ++i ) {
                put_pattern( &(pre_patterns[i]), &(post_patterns[i]), strength, overwrite );
        }

        std::stringstream oss;
        oss << get_log_name() << "Added " << pre_patterns.size() << " patterns";
        auryn::logger->msg(oss.str(),NOTIFICATION);
}

Here is the call graph for this function:

propagate()

void SparseConnection::propagate ( )

virtual

Internally used propagate method.

This method propagates spikes in the main simulation loop. Should usually not be called directly by the user.

Implements auryn::Connection.

Reimplemented in auryn::TripletConnection, auryn::LPTripletConnection, auryn::MinimalTripletConnection, auryn::STPConnection, auryn::TripletScalingConnection, auryn::STDPwdConnection, auryn::RateModulatedConnection, auryn::PairInteractionConnection, auryn::SymmetricSTDPConnection, auryn::DelayConnection, auryn::STDPConnection, auryn::ABSConnection, and auryn::TripletDecayConnection.

{
        for (SpikeContainer::const_iterator spike = src->get_spikes()->begin() ;
                        spike != src->get_spikes()->end() ; 
                        ++spike ) {
                for ( AurynLong c = w->get_row_begin_index(*spike) ;
                                c < w->get_row_end_index(*spike) ;
                                ++c ) {
                        transmit( w->get_colind(c) , w->get_value(c) );
                }
        }
}

Here is the call graph for this function:

push_back()

bool SparseConnection::push_back	(	NeuronID	i,
		NeuronID	j,
		AurynWeight	weight
	)

Pushes a single element to the ComplexMatrix.

Note that Auryn sparse matrices need to be filled row by row in column increasing order (similar to writing in a text document). Hence, usually this function is called internally during weight initialization through a connect_random method. However, it can also be invoked manually to build custum weight matrices on the fly. The recommended method however is to build specific weight matrices in another high level programming language such as Python and to save the in the Auryn specific Matrix Market format which can then be loaded using load_from_file or load_from_complete_file methods.

{
        if ( dst->localrank(j) ) {
                w->push_back(i,j,weight);
                return true;
        }
        return false;
}

Here is the call graph for this function:

put_pattern() [1/2]

void SparseConnection::put_pattern	(	type_pattern *	pattern,
		AurynWeight	strength,
		bool	overwrite
	)

Puts cell assembly to existing sparse weights.

TODO add more explanation here.

{
        std::stringstream oss;
        oss << get_log_name() << "Putting assembly ( size " << pattern->size() << " )";
        auryn::logger->msg(oss.str(),VERBOSE);

        put_pattern( pattern, pattern, strength, overwrite );
}

Here is the call graph for this function:

put_pattern() [2/2]

void SparseConnection::put_pattern	(	type_pattern *	pattern1,
		type_pattern *	pattern2,
		AurynWeight	strength,
		bool	overwrite
	)

Puts cell assembly or synfire pattern to existing sparse weights.

TODO add more explanation here.

{
        type_pattern::iterator iter_pre,iter_post;
        for ( iter_post = pattern2->begin() ; iter_post != pattern2->end() ; ++iter_post ) {
                if ( (*iter_post).i%patterns_every_post != 0 ) continue;
                NeuronID j = (*iter_post).i/patterns_every_post;
                if ( wrap_patterns ) 
                        j = j % get_n_cols();
                if ( j < dst->get_size() && dst->localrank( j ) ) {
                        for ( iter_pre = pattern1->begin() ; iter_pre != pattern1->end() ; ++iter_pre ) {
                                if ( (*iter_pre).i%patterns_every_pre != 0 ) continue;
                                NeuronID i = (*iter_pre).i/patterns_every_pre;
                                if ( wrap_patterns ) 
                                        i = i % get_m_rows();
                                if ( i < src->get_size() && w->exists( i, j ) ) { 
                                        if ( overwrite ) {
                                                set( i, j, (*iter_post).gamma*strength);
                                        } else {
                                                AurynWeight current_weight = get( i, j );
                                                set( i, j, current_weight + (*iter_post).gamma*strength);
                                        }
                                }
                        }
                }
        }
}

Here is the call graph for this function:

random_col_data()

void SparseConnection::random_col_data	(	AurynWeight	mean,
		AurynWeight	sigma
	)

Sets weights in cols to the same value drewn from a Gaussian distribution.

{
        std::stringstream oss;
        oss << get_log_name() << "Randomly scaling cols (gaussian) with mean=" << mean << " sigma=" << sigma ;
        auryn::logger->msg(oss.str(),VERBOSE);

        boost::normal_distribution<> dist((double)mean, (double)sigma);
        boost::variate_generator<boost::mt19937&, boost::normal_distribution<> > die(SparseConnection::sparse_connection_gen, dist);
        AurynWeight rv;

        for ( NeuronID i = 0 ; i<get_n_cols() ; ++i ) {
                rv = die();
                if ( rv<0 ) rv = 0;
                w->set_col(i,rv);
        }
}

Here is the call graph for this function:

random_data()

void SparseConnection::random_data	(	AurynWeight	mean,
		AurynWeight	sigma
	)

Synonym for random_data.

{
        random_data_normal(mean, sigma);
}

Here is the call graph for this function:

random_data_lognormal()

void SparseConnection::random_data_lognormal	(	AurynWeight	m,
		AurynWeight	s
	)

Set weights of all existing connections randomly using a lognormal distribution.

{
        std::stringstream oss;
        oss << get_log_name() << "randomizing non-zero connections (lognormal) with mean=" 
                << mean << " sigma=" << sigma ;
        auryn::logger->msg(oss.str(),NOTIFICATION);

        boost::lognormal_distribution<> dist((double)mean, (double)sigma);
        boost::variate_generator<boost::mt19937&, boost::lognormal_distribution<> > die(SparseConnection::sparse_connection_gen, dist);
        AurynWeight rv;

        for ( AurynLong i = 0 ; i<w->get_nonzero() ; ++i ) {
                rv = die();
                w->set_data(i,rv);
        }

        clip(get_min_weight(), get_max_weight());
}

Here is the call graph for this function:

random_data_normal()

void SparseConnection::random_data_normal	(	AurynWeight	mean,
		AurynWeight	sigma
	)

Set weights of all existing connections randomly using a normal distrubtion.

{
        std::stringstream oss;
        oss << get_log_name() << "randomizing non-zero connections (gaussian) with mean=" << mean << " sigma=" << sigma ;
        auryn::logger->msg(oss.str(),NOTIFICATION);

        boost::normal_distribution<> dist((double)mean, (double)sigma);
        boost::variate_generator<boost::mt19937&, boost::normal_distribution<> > die(SparseConnection::sparse_connection_gen, dist);
        AurynWeight rv;

        for ( AurynLong i = 0 ; i<w->get_nonzero() ; ++i ) {
                rv = die();
                if ( rv<get_min_weight() ) rv = get_min_weight();
                if ( rv>get_max_weight() ) rv = get_max_weight();
                w->set_data(i,rv);
        }
}

Here is the call graph for this function:

sanity_check()

void SparseConnection::sanity_check

(

)

Quick an dirty function that checks if all units on the local rank are connected.

{
        if ( dst->evolve_locally() == false ) return;

        AurynFloat * sum = new AurynFloat[dst->get_size()];
        for ( NeuronID i = 0 ; i < dst->get_size() ; ++i ) sum[i] = 0.0;

        NeuronID * ind = w->get_ind_begin(); // first element of index array
        AurynWeight * data = w->get_data_begin();
        for ( NeuronID i = 0 ; i < src->get_size() ; ++i ) {
                for (NeuronID * c = w->get_row_begin(i) ; 
                                c < w->get_row_end(i) ; 
                                ++c ) {
                        AurynWeight value = data[c-ind]; 
                        sum[*c] += value;
                }
        }

        NeuronID unconnected_count = 0 ;
        double total_weight = 0;
        for ( NeuronID i = 0 ; i < dst->get_size() ; ++i ) {
                total_weight += sum[i];
                if ( sum[i] == 0 && dst->localrank(i) ) {
                        unconnected_count++;
                        std::stringstream oss;
                        oss << "Sanity check: Neuron "
                                << i 
                                << " local (" 
                                << dst->global2rank(i) 
                                << ") has no inputs." ;
                        auryn::logger->msg(oss.str(),WARNING);
                }
        }

        auryn::logger->parameter("sanity_check:total weight",total_weight);

        if ( unconnected_count ) { 
                std::stringstream oss;
                oss << "Sanity check failed ("
                        << get_name()
                        << "). Found " 
                        << unconnected_count
                        << " unconnected neurons.";
                auryn::logger->msg(oss.str(),WARNING);
        }

        delete [] sum;

        //  row count - outputs

        AurynFloat * sum_rows = new AurynFloat[src->get_size()];
        for ( NeuronID i = 0 ; i < src->get_size() ; ++i ) sum_rows[i] = 0.0;

        for ( NeuronID i = 0 ; i < src->get_size() ; ++i ) {
                for (NeuronID * c = w->get_row_begin(i) ; 
                                c != w->get_row_end(i) ; 
                                ++c ) {
                        AurynWeight value = data[c-ind]; 
                        sum_rows[i] += value;
                }
        }

        for ( NeuronID i = 0 ; i < src->get_size() ; ++i ) {
                if ( sum_rows[i] == 0  ) {
                        std::stringstream oss;
                        oss << "Sanity check: Neuron "
                         << i 
                         << " local (" 
                         << src->global2rank(i) 
                         << ") has no outputs on this rank. This might be normal when run distributed." ;
                        auryn::logger->msg(oss.str(),VERBOSE);
                        if ( w->get_row_begin(i) != w->get_row_end(i) ) {
                                auryn::logger->msg("wmat inconsistency",ERROR);
                        }
                }
        }


        delete [] sum_rows;
}

Here is the call graph for this function:

scale_all()

void SparseConnection::scale_all ( AurynFloat  value )

virtual

Scales all weights in the weight matrix with the given value.

{
        w->scale_all( value );
}

Here is the call graph for this function:

scale_block()

void SparseConnection::scale_block	(	NeuronID	lo_row,
		NeuronID	hi_row,
		NeuronID	lo_col,
		NeuronID	hi_col,
		AurynWeight	alpha
	)

Scale all weights of existing connections in a block spanned by the first 4 parameters to the value given.

{
        for ( NeuronID i = 0 ; i < get_m_rows() ; ++i ) 
        {
                for ( NeuronID * j = w->get_row_begin(i) ; j != w->get_row_end(i) ; ++j )
                {
                        if (i >= lo_row && i < hi_row && *j >= lo_col && *j < hi_col )
                          w->get_data_begin()[j-w->get_row_begin(0)] *= alpha;
                }
        }

        clip(get_min_weight(), get_max_weight());
}

Here is the call graph for this function:

seed()

void SparseConnection::seed

(

NeuronID

randomseed

)

This function seeds the pseudo random number generator for all random fill operatios.

{
        std::stringstream oss;
        oss << get_log_name() << "Seeding with " << randomseed;
        auryn::logger->msg(oss.str(),VERBOSE);
        SparseConnection::sparse_connection_gen.seed(randomseed); 
        has_been_seeded = true;
}

Here is the call graph for this function:

set() [1/2]

void SparseConnection::set ( NeuronID  i, NeuronID  j, AurynWeight  value  )

virtual

Sets a single connection to value if it exists.

Implements auryn::Connection.

{
        value = std::max(value,get_min_weight());
        w->set(i,j,value);
}

Here is the call graph for this function:

set() [2/2]

void SparseConnection::set ( std::vector< neuron_pair >  element_list, AurynWeight  value  )

virtual

Sets a list of connection to value if they exists.

{
        for (std::vector<neuron_pair>::iterator iter = element_list.begin() ; iter != element_list.end() ; ++iter)
        {
                w->set((*iter).i, (*iter).j,value);
        }
}

Here is the call graph for this function:

set_all()

void SparseConnection::set_all ( AurynWeight  weight )

virtual

Sets all weights of existing connections to the given value.

{
        w->set_all( weight );
}

Here is the call graph for this function:

set_block()

void SparseConnection::set_block	(	NeuronID	lo_row,
		NeuronID	hi_row,
		NeuronID	lo_col,
		NeuronID	hi_col,
		AurynWeight	weight
	)

Sets all weights of existing connections in a block spanned by the first 4 parameters to the value given.

{
        AurynWeight temp = std::max(weight,get_min_weight());
        for ( NeuronID i = 0 ; i < get_m_rows() ; ++i ) 
        {
                for ( NeuronID * j = w->get_row_begin(i) ; j != w->get_row_end(i) ; ++j )
                {
                        if (i >= lo_row && i < hi_row && *j >= lo_col && *j < hi_col )
                          w->get_data_begin()[j-w->get_row_begin(0)] = temp;
                }
        }
}

Here is the call graph for this function:

set_data()

void SparseConnection::set_data ( NeuronID  i, AurynWeight  value  )

virtual

Sets weight value of a given element referenced by its index in the data array.

{
        w->set_data(i,value);
}

Here is the call graph for this function:

set_max_weight()

void SparseConnection::set_max_weight ( AurynWeight  maximum_weight )

virtual

Sets maximum weight (for plastic connections).

Reimplemented in auryn::TripletScalingConnection, and auryn::STDPwdConnection.

{
        wmax = maximum_weight;
}

set_min_weight()

void SparseConnection::set_min_weight ( AurynWeight  minimum_weight )

virtual

Sets minimum weight (for plastic connections).

Reimplemented in auryn::TripletScalingConnection.

{
        wmin = minimum_weight;
}

set_upper_triangular()

void SparseConnection::set_upper_triangular

(

AurynWeight

weight

)

Sets weights in a upper triangular matrix.

{
        w->set_all( 0.0 );
        AurynWeight temp = std::max(weight,get_min_weight());
        for ( NeuronID i = 0 ; i < get_m_rows() ; ++i ) 
        {
                for ( NeuronID * j = w->get_row_begin(i) ; j != w->get_row_end(i) ; ++j )
                {
                        if ( i <=  *j )
                          w->get_data_begin()[j-w->get_row_begin(0)] = temp;
                }
        }
}

Here is the call graph for this function:

sparse_set_data()

void SparseConnection::sparse_set_data ( AurynDouble  sparseness, AurynWeight  value  )

virtual

Sets a sparse random subset of connection elements wight the given value.

{
        std::stringstream oss;
        oss << get_log_name() << ": setting data sparsely with sparseness=" << sparseness << " value=" << value ;
        auryn::logger->msg(oss.str(),VERBOSE);

        boost::exponential_distribution<> dist(sparseness);
        boost::variate_generator<boost::mt19937&, boost::exponential_distribution<> > die(SparseConnection::sparse_connection_gen, dist);

    AurynLong x = (AurynLong) die();
    AurynLong stop = w->get_datasize();

        while ( x < stop ) {
                set_data(x,value);
                x += die();
        }
}

Here is the call graph for this function:

stats() [1/2]

void SparseConnection::stats ( AurynDouble &  mean, AurynDouble &  std  )

virtual

Computes mean and variance of weights in default weight matrix.

Returns mean and variance of default weight matrix (typically referenced as w in a given SparseConnection

Reimplemented in auryn::RateModulatedConnection.

{
        stats(mean, std, 0);
}

stats() [2/2]

void SparseConnection::stats ( AurynDouble &  mean, AurynDouble &  std, NeuronID  zid  )

virtual

Computes mean and variance of weights for matrix state zid.

Implements auryn::Connection.

{
        double sum = 0; // needs double here -- machine precision really matters here
        double sum2 = 0;

        for ( AurynWeight * iter = w->get_data_begin(zid) ; iter != w->get_data_end(zid) ; ++iter ) {
                sum  += *iter;
                sum2 += (*iter * *iter);
        }

        NeuronID count = w->get_nonzero();

        if ( count <= 1 ) {
                mean = sum;
                std = 0;
                return;
        }

        mean = sum/count;
        std = sqrt((sum2-sum*sum/count)/(count-1));
}

Here is the call graph for this function:

sum()

AurynDouble SparseConnection::sum ( )

virtual

Computes sum of all weight elements in the Connection.

{
        AurynFloat sum = 0;

        for ( AurynWeight * iter = w->get_data_begin() ; iter != w->get_data_end() ; ++iter ) {
                sum  += *iter;
        }
        
        return sum;
}

Here is the call graph for this function:

virtual_serialize() [1/2]

void auryn::SparseConnection::virtual_serialize ( boost::archive::binary_oarchive &  ar, const unsigned int  version  )

inlineprotectedvirtual

Serialization function for saving the Connection state. Implement in derived classes to save additional information.

Reimplemented from auryn::Connection.

        {
                Connection::virtual_serialize(ar,version);
                ar & *w;
        }

Here is the call graph for this function:

virtual_serialize() [2/2]

void auryn::SparseConnection::virtual_serialize ( boost::archive::binary_iarchive &  ar, const unsigned int  version  )

inlineprotectedvirtual

Serialization function for loading the Connection state. Implement in derived classes to save additional information.

Reimplemented from auryn::Connection.

        {
                Connection::virtual_serialize(ar,version);
                ar & *w;
        }

Here is the call graph for this function:

write_to_file() [1/2]

bool SparseConnection::write_to_file	(	ForwardMatrix *	m,
		std::string	filename
	)

Writes rank specific weight matrix on the same rank to a file.

This function writes all synaptic weights from the specified weight matrix which are stored on the same rank to a Matrix Market file in real coordinate format. The file can later be read with load_from_file to continue a simulation or can be processed offline using standard tools such as MATLAB or Python.

{
        if ( !dst->evolve_locally() ) return true;

        std::ofstream outfile;
        outfile.open(filename.c_str(),std::ios::out);
        if (!outfile) {
                std::stringstream oss;
            oss << "Can't open output file " << filename;
                auryn::logger->msg(oss.str(),ERROR);
                throw AurynOpenFileException();
        }

        outfile << "%%MatrixMarket matrix coordinate real general\n" 
                << "% Auryn weight matrix. Has to be kept in row major order for load operation.\n" 
                << "% Connection name: " << get_name() << "\n"
                << "% Locked range: " << dst->get_locked_range() << "\n"
                << "%\n"
                << get_m_rows() << " " << get_n_cols() << " " << m->get_nonzero() << std::endl;

        AurynLong count = 0;
        for ( NeuronID i = 0 ; i < get_m_rows() ; ++i ) 
        {
                outfile << std::setprecision(7);
                for ( NeuronID * j = m->get_row_begin(i) ; j != m->get_row_end(i) ; ++j )
                {
                        outfile << i+1 << " " << *j+1 << " " << std::scientific << m->get_data_begin()[j-m->get_row_begin(0)] << std::fixed << "\n";
                        ++count;
                }
        }

        if ( count != m->get_nonzero() ) {
                logger->msg("SparseConnection:: count inconsistency while writing MatrixMarket to file.", WARNING);
        }

        outfile.close();
        return true;
}

Here is the call graph for this function:

write_to_file() [2/2]

bool SparseConnection::write_to_file ( std::string  filename )

virtual

Writes rank specific default weight matrix on the same rank to a file.

This call is a shortcut for write_to_file(w, filename) where w is the default weight matrix of the underlying SparseConnectoin.

Implements auryn::Connection.

Reimplemented in auryn::RateModulatedConnection.

{
        return write_to_file(w,filename.c_str());
}

Here is the call graph for this function:

Member Data Documentation

patterns_every_post

NeuronID auryn::SparseConnection::patterns_every_post

The every_post parameter allows to skip postsynaptically over pattern IDs when loading patterns. Default is 1. This can be useful to when loading patterns into the exc->inh connections and there significantly less inhibitory cells than exc ones.

patterns_every_pre

NeuronID auryn::SparseConnection::patterns_every_pre

The every_pre parameter allows to skip presynaptically over pattern IDs when loading patterns. Default is 1. This can be useful to when loading patterns into the exc->inh connections and there significantly less inhibitory cells than exc ones.

patterns_ignore_gamma

bool auryn::SparseConnection::patterns_ignore_gamma

Switch that toggles for the load_patterns function whether or not to use the intensity (gamma) value. Default is false.

skip_diagonal

bool auryn::SparseConnection::skip_diagonal

protected

Switch that specifies whether or not to skip diagonal elemens during random connect. This is usefull for random connects to exclude autapses from the connections.

sparse_connection_gen

boost::mt19937 SparseConnection::sparse_connection_gen = boost::mt19937()

staticprotected

/brief Static random number generator used for random connect

w

ForwardMatrix* auryn::SparseConnection::w

A pointer that points per default to the ComplexMatrix that stores the connectinos.

wmax

AurynWeight auryn::SparseConnection::wmax

protected

/brief Maximum allowed weight value

This property is stored for Connection objects with plasticity. The value can be set and accessed with the setters get_max_weight() and set_max_weight(x)

wmin

AurynWeight auryn::SparseConnection::wmin

protected

/brief Minimum allowed weight value

This property is stored for Connection objects with plasticity. The value can be set and accessed with the setters get_min_weight() and set_min_weight(x)

wrap_patterns

bool auryn::SparseConnection::wrap_patterns

Switch that toggles the behavior when loading a pattern to wrap neuron IDs back onto existing cells via the modulo function.

---

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

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