auryn::WeightMonitor Class Reference

Monitors the evolution of a single or a set of weights. More...

#include <WeightMonitor.h>

Inheritance diagram for auryn::WeightMonitor:

Collaboration diagram for auryn::WeightMonitor:

Public Member Functions
	WeightMonitor (SparseConnection *source, string filename, AurynDouble interval=10.0)
	Default constructor. More...
	WeightMonitor (SparseConnection *source, ForwardMatrix *m, string filename, AurynDouble interval=10.0)
	Specific weight matrix constructor. More...
	WeightMonitor (SparseConnection *source, NeuronID i, NeuronID j, string filename, AurynDouble interval=10.0, RecordingMode mode=SINGLE, StateID z=0)
	Single weight constructor. More...
virtual	~WeightMonitor ()
void	execute ()
	propagate function used by System class internally More...
void	set_mat (ForwardMatrix *m)
	Sets target matrix to read from. More...
void	add_to_list_by_data_index (AurynLong index, StateID z=0)
	Adds a single element to the recording list which is identified by its data index and z-state. More...
void	add_to_list (AurynWeight *ptr)
	Adds a single element to the recording list which is identified by a pointer. More...
void	add_to_list (NeuronID i, NeuronID j, StateID z=0)
	Adds a single element identified matrix coordinates (row,col,z) to the recording list. More...
void	add_to_list (std::vector< neuron_pair > vec, string label="")
	Adds a list vector<neuron_pair> vec the the recording list. More...
void	add_equally_spaced (NeuronID number, NeuronID z=0)
	Adds number of elements to the recording list that are equally spaced in the data vector of the connection matrix. More...
void	load_pattern_connections (string filename, unsigned int maxcon=5, unsigned int maxpat=10, PatternMode patmod=ALLTOALL)
	Adds connections inside a pattern and between patterns. Since such lists can become large quickly the amount of patterns and connections for each pattern to be monitored can be limited by maxcon and maxpat. More...
void	load_pattern_connections (string filename_pre, string filename_post, unsigned int maxcon=5, unsigned int maxpat=10, PatternMode patmod=ALLTOALL)
void	load_data_range (AurynLong i, AurynLong j)
	Adds connections from a given range in the sparse matrix data array. More...

Protected Member Functions
void	init (SparseConnection *source, NeuronID i, NeuronID j, string filename, AurynTime interval)
void	record_single_synapses ()
void	record_synapse_groups ()
std::vector< type_pattern > *	load_patfile (string filename, unsigned int maxpat)
Protected Member Functions inherited from auryn::Monitor
virtual void	open_output_file (std::string filename)
virtual void	virtual_serialize (boost::archive::binary_oarchive &ar, const unsigned int version)
virtual void	virtual_serialize (boost::archive::binary_iarchive &ar, const unsigned int version)
virtual void	flush ()
	Flush to file. More...
	Monitor (std::string filename, std::string default_extension="dat")
	Standard constructor with file name. More...
	Monitor ()
	Constructor which does not open a text file for output. More...
std::string	generate_filename (std::string name_hint="")
	Generates a default filename from the device ID. More...
virtual	~Monitor ()
	Standard destructor. More...
Protected Member Functions inherited from auryn::Device
void	init ()
	Standard initializer to be called by the constructor. More...
	Device ()
	Standard constructor. More...
void	set_name (std::string s)
	Set device name. More...
std::string	get_name ()
	Get device name. More...
int	get_id ()
	Get numeric device id. More...
virtual	~Device ()
	Standard destructor. More...
virtual void	evolve ()

Protected Attributes
SparseConnection *	src
ForwardMatrix *	mat
RecordingMode	recordingmode
NeuronID	elem_i
NeuronID	elem_j
AurynTime	ssize
std::vector< AurynLong > *	element_list
std::vector< NeuronID >	group_indices
Protected Attributes inherited from auryn::Monitor
std::ofstream	outfile
std::string	fname
std::string	default_file_extension
bool	active
	Standard active switch. More...
Protected Attributes inherited from auryn::Device
std::string	device_name
	Identifying name for device. More...
bool	active
	Standard active switch. More...

Detailed Description

Monitors the evolution of a single or a set of weights.

This class perform online monitoring of synaptic weights in a Connection. The class supports different recording modes for single individual weights or multiple weights. Output is written to a human readable text file.

Todo:

Implement a new data_index based element list which can deal with Complex Matrix states in a clean fashion

Constructor & Destructor Documentation

WeightMonitor() [1/3]

WeightMonitor::WeightMonitor	(	SparseConnection *	source,
		std::string	filename,
		AurynDouble	interval = 10.0
	)

Default constructor.

This initializes the WeightMonitor and specifies and output file and a sampling interval. Per default WeightMonitor is in multi recording mode. That means it maintains a list of pointers to weights which you would like to monitor. This list is initally empty and needs to be populated after initializating with the appropriate add ... functions.

Parameters

source	The connection object to record from
filename	The file to record to
interval	The sampling interval in simulation interval in seconds

                                                                                                 : Monitor(filename)
{
        init(source,0,0,filename,interval/auryn_timestep);
}

Here is the call graph for this function:

WeightMonitor() [2/3]

WeightMonitor::WeightMonitor	(	SparseConnection *	source,
		ForwardMatrix *	m,
		std::string	filename,
		AurynDouble	interval = 10.0
	)

Specific weight matrix constructor.

This initializes the WeightMonitor and specifies and output file and a sampling interval. The constructor does not specify which weights to monitor. interpreted as range i..j in the data array of the source Connection. Note that in DATARANGE mode the Monitor could in principle also monitor zero connections. However in SINGLE it records only non-zero elements.

Parameters

source	The connection object to record from
filename	The file to record to
m	A pointer to the weight matrix to record from
interval	The sampling interval in simulation interval in seconds

                                                                                                                    : Monitor(filename)
{
        init(source,0,0,filename,interval/auryn_timestep);
        set_mat(m);
}

Here is the call graph for this function:

WeightMonitor() [3/3]

WeightMonitor::WeightMonitor	(	SparseConnection *	source,
		NeuronID	i,
		NeuronID	j,
		std::string	filename,
		AurynDouble	interval = 10.0,
		RecordingMode	mode = SINGLE,
		StateID	z = 0
	)

Single weight constructor.

This initializes the WeightMonitor and specifies and output file and a sampling interval. It moreover puts the WeightMonitor in RecordingMode mode SINGLE in which it records a single synaptic connection specified by i and j. If mode is set to DATARANGE instead, the arguments i and j are instead interpreted as range i..j in the data index array of the source Connection.

Parameters

source	The connection object to record from
i	Parameter i (either row position of synapse in WeightMatrix or start index in data array depending on mode)
j	Parameter j (either col position of synapse in WeightMatrix or stop index in data array depending on mode)
filename	The file to record to
interval	The sampling interval in simulation interval (1s default)
mode	The recording mode (one of RecordingMode datatype)
z	The z state the complex matrix state to record from

                                                                                                                                                        : Monitor(filename)
{
        init(source,i,j,filename,interval/auryn_timestep);

        // overwrite the following default values set in init
        recordingmode = mode;
        elem_i = i;
        elem_j = j;

        switch (recordingmode) {
                case DATARANGE : 
                        for (AurynLong c = elem_i ; c < elem_j ; ++c)
                                add_to_list_by_data_index(c,z) ;
                        break;
                case SINGLE :
                        add_to_list(i,j,z);
                        break;
                default:
                break;
        }
}

Here is the call graph for this function:

~WeightMonitor()

WeightMonitor::~WeightMonitor ( )

virtual

{
        delete element_list;

}

Member Function Documentation

add_equally_spaced()

void WeightMonitor::add_equally_spaced	(	NeuronID	number,
		NeuronID	z = 0
	)

Adds number of elements to the recording list that are equally spaced in the data vector of the connection matrix.

This effectively corresponds to a number of random connection matrix elements (if a random matrix is used). The second argument can be used to specify which complex synapse state should be used for this operation when complex synapses are used.

{
        if ( z >= mat->get_num_z_values() ) {
                auryn::logger->msg("WeightMonitor:: z too large. Trying to monitor complex "
                                "synaptic values which do not exist."
                                ,ERROR);
                return;
        }

        if ( number > src->get_nonzero() ) {
                auryn::logger->msg("WeightMonitor:: add_equally_spaced: "
        "Not enough elements in this Connection object",WARNING);
                number = src->get_nonzero();
        }

        for ( NeuronID i = 0 ; i < number ; ++i )
                add_to_list(mat->get_data_begin(z)+i*mat->get_nonzero()/number);

        std::stringstream oss;
        oss << "WeightMonitor:: "
                << "Added "
                << number 
                << " equally spaced values.";
        auryn::logger->msg(oss.str(),VERBOSE);
}

Here is the call graph for this function:

add_to_list() [1/3]

void WeightMonitor::add_to_list

(

AurynWeight *

ptr

)

Adds a single element to the recording list which is identified by a pointer.

{
        if ( ptr != NULL ) {
                element_list->push_back( mat->get_data_index(ptr) );
        }
}

Here is the call graph for this function:

add_to_list() [2/3]

void WeightMonitor::add_to_list	(	NeuronID	i,
		NeuronID	j,
		StateID	z = 0
	)

Adds a single element identified matrix coordinates (row,col,z) to the recording list.

{
        if ( mat->exists(i, j, z) ) {
                add_to_list_by_data_index( mat->get_data_index(i, j), z );
        } else {
                std::stringstream oss;
                oss << "WeightMonitor:: Tried adding element " 
                        << i << ", " 
                        << j << " " 
                        "z=" << z << " " 
                        << " but element does not exist";
                logger->msg(oss.str());
        }
}

Here is the call graph for this function:

add_to_list() [3/3]

void WeightMonitor::add_to_list	(	std::vector< neuron_pair >	vec,
		std::string	label = ""
	)

Adds a list vector<neuron_pair> vec the the recording list.

Such a list can for instance be generated by a SparseConnection with the get_block function.

{
        if ( recordingmode == ELEMENTLIST || recordingmode == GROUPS ) {
                std::stringstream oss;
                oss << "WeightMonitor:: Adding " << vec.size() << " elements to index list " << label;
                auryn::logger->msg(oss.str(),VERBOSE);

                if ( label.empty() )
                        outfile << "# Added list with " << vec.size() << " elements." << std::endl;
                else 
                        outfile << "# Added list " << label << " with " << vec.size() << " elements." << std::endl;

                for (std::vector<neuron_pair>::iterator iter = vec.begin() ; iter != vec.end() ; ++iter)
                {
                        add_to_list( (*iter).i, (*iter).j );
                }
        } else {
                std::stringstream oss;
                oss << "WeightMonitor:: "
                        << "Cannot add weight list. Not in ELEMENTLIST or GROUP mode."
                        << std::endl;
                auryn::logger->msg(oss.str(),ERROR);
        }
}

Here is the call graph for this function:

add_to_list_by_data_index()

void WeightMonitor::add_to_list_by_data_index	(	AurynLong	index,
		StateID	z = 0
	)

Adds a single element to the recording list which is identified by its data index and z-state.

Parameters

index	The index in the data array of this sparse matrix.
z	The id of the complex matrix state to record from.

{
        element_list->push_back( data_index + z*mat->get_statesize() );
}

Here is the call graph for this function:

execute()

void WeightMonitor::execute ( )

virtual

propagate function used by System class internally

Reimplemented from auryn::Device.

{
        if ( src->get_destination()->evolve_locally() ) {
                if (auryn::sys->get_clock()%ssize==0) {
                        outfile << std::fixed << auryn_timestep*(auryn::sys->get_clock()) << std::scientific << " ";
                        if ( recordingmode == GROUPS ) record_synapse_groups();
                        else record_single_synapses();
                        outfile << "\n";
                }
        }
}

Here is the call graph for this function:

init()

void WeightMonitor::init ( SparseConnection *  source, NeuronID  i, NeuronID  j, std::string  filename, AurynTime  interval  )

protected

{
        auryn::sys->register_device(this);
        src = source;
        set_mat(src->w);
        ssize = stepsize;
        if ( ssize < 1 ) ssize = 1;

        outfile << std::setiosflags(std::ios::fixed) << std::setprecision(6);

        std::stringstream oss;
        oss << "WeightMonitor:: "
                << "Initialized. Writing to file "
                << fname;
        auryn::logger->msg(oss.str(),VERBOSE);

        // default behavior
        recordingmode = ELEMENTLIST;
        element_list = new std::vector<AurynLong>;
        group_indices.push_back(0); // important for group mode
        elem_i = 0;
        elem_j = 0;
}

Here is the call graph for this function:

load_data_range()

void WeightMonitor::load_data_range	(	AurynLong	i,
		AurynLong	j
	)

Adds connections from a given range in the sparse matrix data array.

{
        if ( !src->get_destination()->evolve_locally() ) return; 

        if ( j > mat->get_nonzero() )
                j = mat->get_nonzero();
        std::stringstream oss;
        oss << "WeightMonitor:: "
                << "Adding data range i="
                << i
                << " j="
                << j;
        auryn::logger->msg(oss.str(),VERBOSE);
        for ( NeuronID a = i ; a < j ; ++a )
                element_list->push_back( a );
        outfile << "# Added data range " << i << "-" << j << "." << std::endl;
}

Here is the call graph for this function:

load_patfile()

std::vector< type_pattern > * WeightMonitor::load_patfile ( std::string  filename, unsigned int  maxpat  )

protected

{

        std::vector<type_pattern> * patterns = new std::vector<type_pattern>;


        std::ifstream fin (filename.c_str());
        if (!fin) {
                std::stringstream oss;
                oss << "WeightMonitor:: "
                << "There was a problem opening file "
                << filename
                << " for reading."
                << std::endl;
                auryn::logger->msg(oss.str(),ERROR);
                throw AurynOpenFileException();
        }

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


        type_pattern pattern;
        int total_pattern_size = 0;
        while( !fin.eof() && patterns->size() < maxpat ) {

                line.clear();
                fin.getline (buffer,255);
                line = buffer;

                if (line[0] == '#') continue;
                if (line == "") { 
                        if ( total_pattern_size > 0 ) {
                                std::stringstream oss;
                                oss << "WeightMonitor:: Read pattern " 
                                        << patterns->size() 
                                        << " with pattern size "
                                        << total_pattern_size
                                        << " ( "
                                        << pattern.size()
                                        << " on rank )";
                                auryn::logger->msg(oss.str(),VERBOSE);

                                patterns->push_back(pattern);
                                pattern.clear();
                                total_pattern_size = 0;
                        }
                        continue;
                }

                std::stringstream iss (line);
                NeuronID i ;
                iss >> i ;
                pattern_member pm;
                pm.gamma = 1 ;
                iss >>  pm.gamma ;
                pm.i = i ;
                pattern.push_back( pm ) ;
                total_pattern_size++;
        }
        fin.close();



        return patterns;
}

Here is the call graph for this function:

load_pattern_connections() [1/2]

void WeightMonitor::load_pattern_connections	(	std::string	filename,
		unsigned int	maxcon = 5,
		unsigned int	maxpat = 10,
		PatternMode	patmod = ALLTOALL
	)

Adds connections inside a pattern and between patterns. Since such lists can become large quickly the amount of patterns and connections for each pattern to be monitored can be limited by maxcon and maxpat.

Parameters

filename	The filename of the .pat file
maxcon	maximum number of connection per pattern or between patterns
maxpat	maximum number of patterns to read from .pat file
patmod	ALLTOALL means from all patterns to all patterns. ASSEMBLIES_ONLY only adds connections inside single patterns.

{
        load_pattern_connections( filename, filename, maxcon, maxpat, patmod );
}

load_pattern_connections() [2/2]

void WeightMonitor::load_pattern_connections	(	std::string	filename_pre,
		std::string	filename_post,
		unsigned int	maxcon = 5,
		unsigned int	maxpat = 10,
		PatternMode	patmod = ALLTOALL
	)

{
        if ( !src->get_destination()->evolve_locally() ) return ;

        std::vector<type_pattern> * patterns_pre = load_patfile(filename_pre, maxpat);
        std::vector<type_pattern> * patterns_post = patterns_pre;

        if ( filename_pre.compare(filename_post) ) 
                patterns_pre = load_patfile(filename_post, maxpat);



        for ( unsigned int i = 0 ; i < patterns_pre->size() ; ++i ) {
                for ( unsigned int j = 0 ; j < patterns_post->size() ; ++j ) {
                        if ( patmod==ASSEMBLIES_ONLY && i != j ) continue;
                        std::vector<neuron_pair> list;
                        for ( unsigned int k = 0 ; k < patterns_pre->at(i).size() ; ++k ) {
                                for ( unsigned int l = 0 ; l < patterns_post->at(j).size() ; ++l ) {
                                                neuron_pair p;
                                                p.i = patterns_pre->at(i)[k].i;
                                                p.j = patterns_post->at(j)[l].i;
                                                AurynWeight * ptr =  mat->get_ptr(p.i,p.j);
                                                if ( ptr != NULL ) { // make sure we are counting connections that do exist
                                                        list.push_back( p );
                                                }
                                        if ( list.size() >= maxcon ) break;
                                }
                                if ( list.size() >= maxcon ) break;
                        }


                        std::stringstream oss;
                        oss << "(connections " << i << " to " << j << ")";
                        add_to_list(list,oss.str());
                        group_indices.push_back(element_list->size());
                }
        }



        std::stringstream oss;
        oss << "WeightMonitor:: Finished loading connections from n_pre=" 
                << patterns_pre->size() 
                << " and n_post="
                << patterns_post->size() 
                << " patterns";
        auryn::logger->msg(oss.str(),NOTIFICATION);


        if ( patterns_pre != patterns_post ) 
                delete patterns_post;
        delete patterns_pre;

}

Here is the call graph for this function:

record_single_synapses()

void WeightMonitor::record_single_synapses ( )

protected

{
        for (std::vector<AurynLong>::iterator iter = element_list->begin() ; iter != element_list->end() ; ++iter) {
                // the following is a workaround for the old WeightMonitor data_index ptr log to work with the new state vector 
                // based ComplexMatrix class
                // thus we need to translate the data index to a state variable z and the actual new data_index
                const AurynLong data_index = (*iter)%src->w->get_statesize();
                const StateID z = (*iter)/src->w->get_statesize();
                outfile << mat->get_data( data_index, z ) << " ";
        }
}

Here is the call graph for this function:

record_synapse_groups()

void WeightMonitor::record_synapse_groups ( )

protected

{
        for ( unsigned int i = 1 ; i < group_indices.size() ; ++i ) {
                AurynDouble sum = 0;
                AurynDouble sum2 = 0;

                for ( unsigned int k = group_indices[i-1] ; k < group_indices[i] ; ++k ) {
                        sum += mat->get_data( element_list->at(k) );
                        sum2 += pow( mat->get_data( element_list->at(k) ), 2);
                }
                NeuronID n = group_indices[i]-group_indices[i-1];
                AurynDouble mean = sum/n;
                AurynDouble stdev = sqrt(sum2/n-mean*mean);
                outfile << mean << " " << stdev << "   ";
        }
}

Here is the call graph for this function:

set_mat()

void WeightMonitor::set_mat

(

ForwardMatrix *

m

)

Sets target matrix to read from.

{
        mat = m;
}

Member Data Documentation

elem_i

NeuronID auryn::WeightMonitor::elem_i

protected

elem_j

NeuronID auryn::WeightMonitor::elem_j

protected

element_list

std::vector<AurynLong>* auryn::WeightMonitor::element_list

protected

group_indices

std::vector<NeuronID> auryn::WeightMonitor::group_indices

protected

mat

ForwardMatrix* auryn::WeightMonitor::mat

protected

recordingmode

RecordingMode auryn::WeightMonitor::recordingmode

protected

src

SparseConnection* auryn::WeightMonitor::src

protected

ssize

AurynTime auryn::WeightMonitor::ssize

protected

---

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

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