def __init__(self, input_size, params):
super(SNNCategoricalPolicy, self).__init__()
self.slayer = snn.layer(params["neuron"], params["simulation"])
# self.encoder = CartPoleEncoder(200)
self.encoder = ImageEncoder()
self.fc1 = self.slayer.dense((input_size[0] * input_size[1] * 3), 50)
self.fc2 = self.slayer.dense(50, 2) # output of 2 classes
def __init__(self, netParams):
super(Network, self).__init__()
# initialize slayer
slayer = snn.layer(netParams['neuron'], netParams['simulation'])
self.slayer = slayer
self.conv = torch.nn.ModuleList([
slayer.conv(1, 8, (1, 3), padding=(0, 0), stride=(1, 2)),
slayer.conv(8, 16, (1, 3), padding=(0, 1), stride=(1, 2)),
slayer.conv(16, 32, (1, 3), padding=(0, 1), stride=(1, 2)),
slayer.conv(32, 64, (1, 3), padding=(0, 1), stride=(1, 2)),
])
self.fc = torch.nn.ModuleList([
slayer.dense(44 * 64, 512),
slayer.dense(512, 35),
])
self.convDelay = torch.nn.ModuleList([
slayer.delay(8),
slayer.delay(16),
slayer.delay(32),
slayer.delay(64),
])
self.delay = torch.nn.ModuleList([
slayer.delay(512),
])
def __init__(self, netParams):
super(Network, self).__init__()
# initialize slayer
slayer = snn.layer(netParams['neuron'], netParams['simulation'])
self.slayer = slayer
# define network functions
self.fc1 = slayer.dense(Nin, Nhid)
self.fc2 = slayer.dense(Nhid, Nout)
def __init__(self, config, inputs, outputs):
super(Network, self).__init__()
# Initialize SLAYER
slayer = snn.layer(config["neuron"], config["simulation"])
self.slayer = slayer
# Define network layers
self.fc1 = slayer.dense(inputs, config["network"]["hiddenSize"])
self.fc2 = slayer.dense(config["network"]["hiddenSize"], outputs)
def __init__(self, netParams):
super(Network, self).__init__()
# Initialize slayer
slayer = snn.layer(netParams['neuron'], netParams['simulation'])
self.slayer = slayer
# Define network functions
# The commented line below should be used if the input spikes were not reshaped
# self.fc1 = slayer.dense((34, 34, 2), 512)
self.fc1 = slayer.dense((34*34*2), 512)
self.fc2 = slayer.dense(512, 10)
def __init__(self, netParams):
super(Network, self).__init__()
# Inicializacia slayer-u
slayer = snn.layer(netParams['neuron'], netParams['simulation'])
self.slayer = slayer
# Definicia jednotlivych vrstiev siete
self.fc1 = slayer.dense((34*34*2), 2000)
self.fc2 = slayer.dense(2000,1500)
self.fc3 = slayer.dense(1500, 1000)
self.fc4 = slayer.dense(1000,500)
self.fc5 = slayer.dense(500,100)
self.fc6 = slayer.dense(100,10)
def __init__(self, netParams):
super(Network, self).__init__()
# initialize slayer
slayer = snn.layer(netParams['neuron'], netParams['simulation'])
self.slayer = slayer
# define network functions
self.conv1 = slayer.conv(2, 16, 5, padding=1)
self.conv2 = slayer.conv(16, 32, 3, padding=1)
self.conv3 = slayer.conv(32, 64, 3, padding=1)
self.pool1 = slayer.pool(2)
self.pool2 = slayer.pool(2)
self.fc1 = slayer.dense((8, 8, 64), 10)
def __init__(self, netParams):
super(Network, self).__init__()
# Inicializacia slayer-u
slayer = snn.layer(netParams['neuron'], netParams['simulation'])
self.slayer = slayer
# Definicia jednotlivych vrstiev siete
self.conv1 = slayer.conv(2, 16, 5, padding=1)
self.conv2 = slayer.conv(16, 32, 3, padding=1)
self.conv3 = slayer.conv(32, 64, 3, padding=1)
self.pool1 = slayer.pool(2)
self.pool2 = slayer.pool(2)
self.dr1 = slayer.dropout(0.5)
self.fc1 = slayer.dense((8, 8, 64), 10)
def __init__(
self,
params,
tact_input_size,
vis_input_size,
tact_output_size,
vis_output_size,
output_size,
):
super(SlayerMM, self).__init__()
self.slayer = snn.layer(params["neuron"], params["simulation"])
self.tactile = EncoderTact(params, tact_input_size, tact_output_size)
self.vision = EncoderVis(params, vis_input_size, vis_output_size)
self.fc1 = self.slayer.dense(60, output_size)
CURRENT_TEST_DIR = os.path.dirname(os.path.realpath(__file__))
sys.path.append(CURRENT_TEST_DIR + "/../src")
import unittest
import numpy as np
import matplotlib.pyplot as plt
import torch
import slayerSNN as snn
import slayerCuda
device = torch.device('cuda')
Ts = 0.1
netParams = snn.params('test_files/nmnistNet.yaml')
slayer = snn.layer(netParams['neuron'], netParams['simulation']).to(device)
# (N, C, H, W, D) = (2, 5, 6, 7, 50)
(N, C, H, W, D) = (5, 10, 20, 30, 500)
# Uncomment this to test large neuron sizes
# (N, C, H, W, D) = (5, 16, 128, 128, 500)
delay = slayer.delay((C, H, W)).to(device)
inTensor = torch.randn((N, C, H, W, D)).to(device)
def checkShift(inTensor, outTensor, shift, verbose=False):
if shift > 0:
error = torch.norm(inTensor[:-shift] - outTensor[shift:]).item()
elif shift == 0:
error = torch.norm(inTensor - outTensor).item()
def __init__(self, params, input_size, hidden_size, output_size):
super(SlayerMLP, self).__init__()
self.slayer = snn.layer(params["neuron"], params["simulation"])
self.fc1 = self.slayer.dense(input_size, hidden_size)
self.fc2 = self.slayer.dense(hidden_size, output_size)
def __init__(self, params, input_size, output_size):
super(EncoderTact, self).__init__()
self.slayer = snn.layer(params["neuron"], params["simulation"])
self.fc1 = self.slayer.dense(input_size, output_size)
def __init__(self, params):
super(SumPool, self).__init__()
self.slayer = snn.layer(params["neuron"], params["simulation"])
self.pool = self.slayer.pool(4)
