SparseConnection.h

Go to the documentation of this file.

/* 
* Copyright 2014-2018 Friedemann Zenke
*
* This file is part of Auryn, a simulation package for plastic
* spiking neural networks.
* 
* Auryn is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
* 
* Auryn is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
* 
* You should have received a copy of the GNU General Public License
* along with Auryn.  If not, see <http://www.gnu.org/licenses/>.
*
* If you are using Auryn or parts of it for your work please cite:
* Zenke, F. and Gerstner, W., 2014. Limits to high-speed simulations 
* of spiking neural networks using general-purpose computers. 
* Front Neuroinform 8, 76. doi: 10.3389/fninf.2014.00076
*/

#ifndef SPARSECONNECTION_H_
#define SPARSECONNECTION_H_

#include "auryn_definitions.h"
#include "AurynVector.h"
#include "Connection.h"
#include "System.h"
#include "ComplexMatrix.h"

#include <sstream>
#include <fstream>
#include <stdio.h>
#include <algorithm>

#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include <boost/random/uniform_real.hpp>
#include <boost/random/variate_generator.hpp>
#include <boost/random/exponential_distribution.hpp>
#include <boost/random/normal_distribution.hpp>
#include <boost/random/lognormal_distribution.hpp>

#define WARN_FILL_LEVEL 0.8

namespace auryn {

typedef ComplexMatrix<AurynWeight> ForwardMatrix;


class SparseConnection : public Connection
{
private:
        SpikeContainer * spikes;
        static bool has_been_seeded;
        bool has_been_allocated;
        void init();
        bool init_from_file(const char * filename);
        AurynLong dryrun_from_file(string filename);

protected:
        void virtual_serialize(boost::archive::binary_oarchive & ar, const unsigned int version ) 
        {
                Connection::virtual_serialize(ar,version);
                ar & *w;
        }

        void virtual_serialize(boost::archive::binary_iarchive & ar, const unsigned int version ) 
        {
                Connection::virtual_serialize(ar,version);
                ar & *w;
        }

        static boost::mt19937 sparse_connection_gen;

        AurynWeight wmin;

        AurynWeight wmax;

        bool skip_diagonal;

        void free();

        void allocate(AurynLong bufsize);

        std::vector<type_pattern> load_pattern_file( string filename, int nb_max_patterns);
        
public:
        bool patterns_ignore_gamma; 

        NeuronID patterns_every_pre;

        NeuronID patterns_every_post;

        bool wrap_patterns;

        ForwardMatrix * w; 

        SparseConnection();

        SparseConnection(const char * filename);

        SparseConnection(NeuronID rows, NeuronID cols);

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

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

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

        SparseConnection(SpikingGroup * source, NeuronGroup * destination, SparseConnection * con, string name="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);
        
        virtual ~SparseConnection();

        void allocate_manually(AurynLong expected_size);

        AurynLong estimate_required_nonzero_entires( AurynLong nonzero , double sigma = 5.);

        void seed(NeuronID randomseed);

        virtual AurynWeight get(NeuronID i, NeuronID j);

        virtual AurynWeight * get_ptr(NeuronID i, NeuronID j);

        virtual AurynWeight get_data(NeuronID i);

        virtual void set_data(NeuronID i, AurynWeight value);

        virtual void set(NeuronID i, NeuronID j, AurynWeight value);

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

        void random_data(AurynWeight mean, AurynWeight sigma); 

        void random_data_normal(AurynWeight mean, AurynWeight sigma); 

        void random_data_lognormal(AurynWeight m, AurynWeight s); 

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

        void random_col_data(AurynWeight mean, AurynWeight sigma); 

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

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

        virtual void set_all(AurynWeight weight);

        virtual void scale_all(AurynFloat value);

        virtual void clip(AurynWeight lo, AurynWeight hi);

        void set_upper_triangular(AurynWeight weight);

        virtual void sparse_set_data(AurynDouble sparseness, AurynWeight value);

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

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

        virtual void finalize();
        
        bool push_back(NeuronID i, NeuronID j, AurynWeight weight);

        AurynLong get_nonzero();

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

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


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

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

        virtual void propagate();

        void sanity_check();

        virtual AurynDouble sum();

        virtual void stats(AurynDouble &mean, AurynDouble &std);

        virtual void stats(AurynDouble &mean, AurynDouble &std, NeuronID zid);


        bool write_to_file(ForwardMatrix * m, string filename );

        virtual bool write_to_file(string filename);

        virtual bool load_from_complete_file(string filename);

        virtual bool load_from_file(string filename);

        bool load_from_file(ForwardMatrix * m, string filename, AurynLong data_size = 0 );

        virtual void set_min_weight(AurynWeight minimum_weight);

        AurynWeight get_min_weight() {
                return wmin;
        };

        virtual void set_max_weight(AurynWeight maximum_weight);

        AurynWeight get_max_weight() {
                return wmax;
        };

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

        std::vector<neuron_pair> get_post_partners(NeuronID i);

        std::vector<neuron_pair> get_pre_partners(NeuronID j);
};

} // namespace 

#endif /*SPARSECONNECTION_H_*/