auryn::WeightPatternMonitor Class Reference

Records mean weights from a connection specified by one or two pattern files. Can be used to easily monitor the mean synaptic weight in assemblies or feed-forward connections of populations of neurons. More...

#include <WeightPatternMonitor.h>

Inheritance diagram for auryn::WeightPatternMonitor:

Collaboration diagram for auryn::WeightPatternMonitor:

Public Member Functions
	WeightPatternMonitor (Connection *source, string filename, AurynDouble binsize=10.0)
void	load_pre_patterns (string filename)
void	load_post_patterns (string filename)
void	load_patterns (string filename)
virtual	~WeightPatternMonitor ()
void	execute ()

Public Attributes
size_t	max_patterns

Protected Member Functions
void	init (Connection *source, string filename, AurynTime stepsize)
AurynWeight	compute_pattern_mean (const NeuronID i, const NeuronID j)
void	load_patterns (std::string filename, std::vector< type_pattern > &patterns)
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
Connection *	src
AurynTime	ssize
std::vector< type_pattern >	pre_patterns
std::vector< type_pattern >	post_patterns
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

Records mean weights from a connection specified by one or two pattern files. Can be used to easily monitor the mean synaptic weight in assemblies or feed-forward connections of populations of neurons.

Constructor & Destructor Documentation

WeightPatternMonitor()

WeightPatternMonitor::WeightPatternMonitor	(	Connection *	source,
		std::string	filename,
		AurynDouble	binsize = 10.0
	)

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

Here is the call graph for this function:

~WeightPatternMonitor()

WeightPatternMonitor::~WeightPatternMonitor ( )

virtual

{
}

Member Function Documentation

compute_pattern_mean()

AurynWeight WeightPatternMonitor::compute_pattern_mean ( const NeuronID  i, const NeuronID  j  )

protected

{
        AurynWeight sum = 0;
        // AurynFloat sum2 = 0;
        NeuronID n = 0;
        for ( NeuronID k = 0 ; k < pre_patterns[i].size() ; ++k ) {
                for ( NeuronID l = 0 ; l < post_patterns[j].size() ; ++l ) {
                        pattern_member p = pre_patterns[i][k];
                        pattern_member q = post_patterns[j][l];
                        AurynWeight * val = src->get_ptr(p.i,q.i);
                        if ( val ) {
                                sum += *val;
                                // sum2 += *val* *val;
                                n++;
                        }
                }
        }
        AurynFloat mean = sum/n;
        return mean;
}

Here is the call graph for this function:

execute()

void WeightPatternMonitor::execute ( )

virtual

Virtual execute function to be called at the end of central simulation loop in System

Reimplemented from auryn::Device.

{
        if (auryn::sys->get_clock()%ssize==0) {
                outfile << std::fixed << (auryn::sys->get_time()) << " ";

                int p = std::min(std::min(pre_patterns.size(),post_patterns.size()),max_patterns);

                for ( int i = 0 ; i < p ; ++i ) {
                        for ( int j = 0 ; j < p ; ++j ) {
                                outfile << std::scientific 
                                        << compute_pattern_mean(i,j) 
                                        << " ";
                        }
                }
                outfile << std::endl;
        }
}

Here is the call graph for this function:

init()

void WeightPatternMonitor::init ( Connection *  source, std::string  filename, AurynTime  stepsize  )

protected

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

        auryn::sys->register_device(this);

        src = source;
        ssize = stepsize;
        if ( ssize < 1 ) ssize = 1;

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

        max_patterns = 5;
}

Here is the call graph for this function:

load_patterns() [1/2]

void WeightPatternMonitor::load_patterns ( std::string  filename, std::vector< type_pattern > &  patterns  )

protected

Mother function for loading patterns

{
        std::ifstream fin (filename.c_str());
        if (!fin) {
                std::stringstream oss;
                oss << "WeightPatternMonitor:: "
                << "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;

        patterns.clear();

        type_pattern pattern;
        int total_pattern_size = 0;
        while(!fin.eof()) {

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

                if (line[0] == '#') continue;
                if (line == "") { 
                        if ( total_pattern_size > 0 ) {
                                std::stringstream oss;
                                oss << "WeightPatternMonitor:: 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.0 ;
                iss >>  pm.gamma ;
                pm.i = i ;
                pattern.push_back( pm ) ;
                total_pattern_size++;
        }

        fin.close();

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

Here is the call graph for this function:

load_patterns() [2/2]

void WeightPatternMonitor::load_patterns

(

std::string

filename

)

Loads patterns for symmetric assembly monitoring

{
        load_pre_patterns(filename);
        load_post_patterns(filename);
}

Here is the call graph for this function:

load_post_patterns()

void WeightPatternMonitor::load_post_patterns

(

std::string

filename

)

Loads post patterns for asymmetric monitoring. Each post pattern needs to be matched by a corresponding pre pattern otherwise there will be a crash.

{
        load_patterns(filename,post_patterns);
}

Here is the call graph for this function:

load_pre_patterns()

void WeightPatternMonitor::load_pre_patterns

(

std::string

filename

)

Loads pre patterns for asymmetric monitoring. Each pre pattern needs to be matched by a corresponding post pattern otherwise there will be a crash.

{
        load_patterns(filename,pre_patterns);
}

Here is the call graph for this function:

Member Data Documentation

max_patterns

size_t auryn::WeightPatternMonitor::max_patterns

Maximum number of patterns to record from

post_patterns

std::vector<type_pattern> auryn::WeightPatternMonitor::post_patterns

protected

pre_patterns

std::vector<type_pattern> auryn::WeightPatternMonitor::pre_patterns

protected

src

Connection* auryn::WeightPatternMonitor::src

protected

ssize

AurynTime auryn::WeightPatternMonitor::ssize

protected

---

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

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