helper_functions.hpp

Go to the documentation of this file.

/*
 *  SNABSuite -- Spiking Neural Architecture Benchmark Suite
 *  Copyright (C) 2019  Christoph Ostrau
 *
 *  This program 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.
 *
 *  This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 */
#pragma once
#include <assert.h>

#include <chrono>
#include <cmath>
#include <cypress/cypress.hpp>
#include <fstream>
#include <string>
#include <utility>  //std::pair

namespace mnist_helper {
using namespace cypress;

typedef std::pair<std::vector<std::vector<Real>>, std::vector<uint16_t>>
    MNIST_DATA;
typedef std::pair<std::vector<std::vector<std::vector<Real>>>,
                  std::vector<uint16_t>>
    SPIKING_MNIST;
typedef std::vector<std::vector<std::vector<std::vector<Real>>>>
    CONVOLUTION_FILTER;
struct CONVOLUTION_LAYER {
    CONVOLUTION_FILTER filter;
    std::vector<size_t> input_sizes;
    std::vector<size_t> output_sizes;
    size_t stride;
    size_t padding;
};
typedef struct CONVOLUTION_LAYER CONVOLUTION_LAYER;
struct POOLING_LAYER {
    std::vector<size_t> input_sizes;
    std::vector<size_t> output_sizes;
    std::vector<size_t> size;
    size_t stride;
};
typedef struct POOLING_LAYER POOLING_LAYER;
enum LAYER_TYPE {Dense, Conv, Pooling};
MNIST_DATA loadMnistData(const size_t num_data, const std::string path);

void print_image(const std::vector<Real> &img, size_t wrap);

std::vector<std::vector<std::vector<Real>>> image_to_rate(
    const std::vector<std::vector<Real>> &images, const Real duration,
    const Real max_freq, size_t num_images, bool poisson = true);

SPIKING_MNIST mnist_to_spike(const MNIST_DATA &mnist_data, const Real duration,
                             const Real max_freq, size_t num_images,
                             bool poisson = true);

std::vector<MNIST_DATA> create_batches(const SPIKING_MNIST &mnist_data,
                                       const size_t batch_size, Real duration,
                                       Real pause, const bool shuffle = false,
                                       unsigned seed = 0);

cypress::Population<SpikeSourceArray> create_spike_source(
    Network &netw, const MNIST_DATA &spikes);

cypress::Population<SpikeSourceArray> &update_spike_source(
    cypress::Population<SpikeSourceArray> &source, const MNIST_DATA &spikes);

Json read_network(std::string path, bool msgpack = true);

template <typename T>
Real max_weight(const T &json)
{
    Real max = 0.0;
    for (size_t i = 0; i < json.size(); i++) {
        for (size_t j = 0; j < json[i].size(); j++) {
            Real tmp = Real(json[i][j]);
            if (tmp > max) {
                max = tmp;
            }
        }
    }
    return max;
}

template <typename T>
Real max_weight(const Matrix<T> &mat)
{
    Real max = 0.0;
    for (size_t i = 0; i < mat.size(); i++) {
        Real tmp = Real(mat[i]);
        if (tmp > max) {
            max = tmp;
        }
    }
    return max;
}

template <typename T>
Real min_weight(const T &json)
{
    Real min = 0.0;
    for (size_t i = 0; i < json.size(); i++) {
        for (size_t j = 0; j < json[i].size(); j++) {
            Real tmp = Real(json[i][j]);
            if (tmp < min) {
                min = tmp;
            }
        }
    }
    return min;
}

template <typename T>
Real min_weight(const Matrix<T> &json)
{
    Real min = 0.0;
    for (size_t i = 0; i < json.size(); i++) {
        Real tmp = Real(json[i]);
        if (tmp < min) {
            min = tmp;
        }
    }
    return min;
}

template <typename T>
Real max_weight_abs(const T &json)
{
    Real max = 0.0;
    for (size_t i = 0; i < json.size(); i++) {
        for (size_t j = 0; j < json[i].size(); j++) {
            Real tmp = fabs(Real(json[i][j]));
            if (tmp > max) {
                max = tmp;
            }
        }
    }
    return max;
}

template <typename T>
Real max_weight_abs(const Matrix<T> &json)
{
    Real max = 0.0;
    for (size_t i = 0; i < json.size(); i++) {
        Real tmp = fabs(Real(json[i]));
        if (tmp > max) {
            max = tmp;
        }
    }
    return max;
}

std::vector<LocalConnection> dense_weights_to_conn(const Matrix<Real> &mat,
                                                   Real scale, Real delay);

std::vector<LocalConnection> conv_weights_to_conn(const mnist_helper::CONVOLUTION_LAYER &layer,
                                                  Real scale, Real delay);

std::vector<std::vector<LocalConnection>> pool_to_conn(
    const mnist_helper::POOLING_LAYER &layer,Real max_pool_weight,
    Real pool_inhib_weight, Real delay, Real pool_delay);

std::vector<uint16_t> spikes_to_labels(const PopulationBase &pop, Real duration,
                                       Real pause, size_t batch_size);
void conv_spikes_per_kernel(const std::string& filename, const PopulationBase& pop,
                            Real duration, Real pause, size_t batch_size, Real norm = 0.0);

std::vector<std::vector<Real>> spikes_to_rates(const PopulationBase pop,
                                               Real duration, Real pause,
                                               size_t batch_size,
                                               Real norm = 0.0);

size_t compare_labels(std::vector<uint16_t> &label, std::vector<uint16_t> &res);

std::vector<Real> av_pooling_image(std::vector<Real> &image, size_t height,
                                   size_t width, size_t pooling_size);

MNIST_DATA scale_mnist(MNIST_DATA &data, size_t pooling_size = 3);

SPIKING_MNIST read_data_to_spike(const size_t num_images, bool train_data,
                                 const Real duration, const Real max_freq,
                                 bool poisson = true, bool scale_down = false);

std::vector<LocalConnection> conns_from_mat(
    const cypress::Matrix<Real> &weights, Real delay, Real scale_factor = 0.0);

void update_conns_from_mat(const std::vector<cypress::Matrix<Real>> &weights,
                           Network &netw, Real delay = 1.0,
                           Real scale_factor = 0.0);
}  // namespace mnist_helper