def setUp(self):
self.netParams = snn.params('../data/mnist/network.yaml')
self.dataset = SMNIST(datasetPath=self.netParams['training']['path']['in'],
samplingTime=self.netParams['simulation']['Ts'],
sampleLength=self.netParams['simulation']['tSample'])
self.m = UpSampling2D(scale_factor=2, mode='nearest')
from datetime import datetime
import numpy as np
import matplotlib.pyplot as plt
import torch
from torch.utils.data import Dataset, DataLoader
import lib.snn as snn
import lib.spikeFileIO as io
import zipfile
import os
# CONSTANTS
USE_CUDA = torch.cuda.is_available()
#
netParams = snn.params('data/mnistMLP/network.yaml')
print(netParams)
# Dataset definition
class nmnistDataset(Dataset):
def __init__(self, datasetPath, sampleFile, samplingTime, sampleLength):
self.path = datasetPath
self.samples = np.loadtxt(sampleFile).astype('int')
self.samplingTime = samplingTime
self.nTimeBins = int(sampleLength / samplingTime)
def __getitem__(self, index):
inputIndex = self.samples[index, 0]
classLabel = self.samples[index, 1]
from tqdm import tqdm
import lib.snn as snn
from lib.datasets import SMNIST
from models.Classifiers import SlayerVgg16, SlayerSNN, SlayerSNN2
from lib.process.Training import Training
from itertools import combinations
# CONSTANTS:
USE_CUDA = torch.cuda.is_available()
EPOCHs = 6
SMALL = False
DATASETMODE = 'classification'
TRAIN = True
netParams = snn.params('network_specs/slayer_snn.yaml')
print(netParams)
if TRAIN:
device = torch.device("cuda" if USE_CUDA else "cpu")
# Create network instance.
model = SlayerSNN2(netParams, input_channels=1).to(device)
# Learning stats instance.
stats = snn.learningStats()
trainingSet = SMNIST(datasetPath=netParams['training']['path']['in'],
samplingTime=netParams['simulation']['Ts'],
sampleLength=netParams['simulation']['tSample'],
mode=DATASETMODE,
def visualize(self, layer, kernel, size=56, lr=0.1, upscaling_steps=12, upscaling_factor=1.2,
optimization_steps=20):
# generate random image
img = np.random.uniform(0, 255, (size, size, 3)) / 255
# register hook
activations = SaveFeatures(list(self.model.children())[layer])
# create tranformers;
# means = [0.485, 0.456, 0.406]
# stds = [0.229, 0.224, 0.225]
# normalize = transforms.Normalize(mean=means,
# std=stds)
tranformation = transforms.Compose([
# transforms.ToPILImage(),
# transforms.Resize(size),
transforms.ToTensor(),
# normalize,
])
netParams = snn.params('network_specs/slayer_cifar.yaml')
encoder_psp = encoderpsp(netParams)
encoder_spike = encoderSpikes(netParams)
encoder_psp.to(self.device)
encoder_spike.to(self.device)
for i in range(upscaling_steps):
img_tensor = tranformation(img)
img_tensor = img_tensor.unsqueeze(0).float()
img_spike = uniform_spike(img_tensor, netParams['simulation']['tSample'])
img_spike = img_spike.to(self.device)
img_voltage = encoder_psp(img_spike)
img_voltage = img_voltage.to(self.device)
img_opt = Variable(img_voltage, requires_grad=True)
optimizer = torch.optim.Adam([img_opt], lr=lr, weight_decay=1e-6)
for ii in range(optimization_steps):
optimizer.zero_grad()
spikes = encoder_spike(img_opt)
self.model(spikes)
loss = -activations.features[0, kernel].mean()
# loss = -img_opt.mean()
loss.backward()
optimizer.step()
print('Current loss: opt_step ', ii, 'upscaling step', i, loss.item())
# denormalization
img = img_opt.data.cpu().numpy()[0]
img = img.sum(axis=-1)
img = img - img.min()
img = img / img.max()
# for c, (m, s) in enumerate(zip(means, stds)):
# img[c] = s * img[c] + m
img = img.transpose(1, 2, 0)
output = img.copy()
plt.imshow(output), plt.show()
size = int(size * upscaling_factor)
img = resize(img, (size, size, 3), order=3)
# img = cv2.resize(img, (size, size), interpolation = cv2.INTER_CUBIC) # scale image up
img = cv2.blur(img, (3, 3)) # blur image to reduce high frequency patterns
# img = uniform_filter(img, 3)
# img = gaussian_filter(img, 0.08)
# blur = 5
# img = cv2.blur(img, (blur, blur))
# img[:, :, 0] = gaussian_filter(img[:, :, 0], 0.5)
# img[:, :, 1] = gaussian_filter(img[:, :, 1], 0.5)
# img[:, :, 2] = gaussian_filter(img[:, :, 2], 0.5)
# skimage.filters.gaussian_filter(im, 2, multichannel=True, mode='reflect', 'truncate=2')
cropped_output = np.clip(output, 0, 1)
fig = plt.figure()
plt.imshow(cropped_output)
plt.show()
plt.imsave("layer_" + str(layer) + "_filter_" + str(kernel) + ".jpg", cropped_output)
plt.close()
activations.close()
from lib.datasets.mnistdataset import SMNIST
from lib.utils import spikeTensorToProb, save_model, load_model
from lib.process.Training import Training
from lib.process.Evaluation import Evaluation
from models.Autoencoder import VAE
# CONSTANTS:
USE_CUDA = torch.cuda.is_available()
EPOCHs = 500
SMALL = True
DATASETMODE = 'autoencoderSpike'
MODEL_PTH = 'vae'
LR = 0.0001
netParams = snn.params('network_specs/vae.yaml')
print(netParams)
device = torch.device("cuda" if USE_CUDA else "cpu")
# Create network instance.
model = VAE(netParams, hidden_size=100, latent_size=2).to(device)
# Load model
load_model(MODEL_PTH, model)
# Define optimizer module.
optimizer = torch.optim.Adam(model.parameters(), lr=LR, amsgrad=True)
# Learning stats instance.
stats = snn.learningStats()
from lib.datasets.mnistdataset import SMNIST
from lib.utils import spikeTensorToProb, save_model, load_model
from lib.process.Training import Training
from lib.process.Evaluation import Evaluation
from models.Autoencoder import UpsamplingAutoencoder, SimpleAutoencoder
# CONSTANTS:
USE_CUDA = torch.cuda.is_available()
EPOCHs = 200
SMALL = False
DATASETMODE = 'autoencoderSpike'
MODEL_PTH = 'simple_autoencoder'
LR = 0.001
netParams = snn.params('network_specs/simple_autoencoder.yaml')
print(netParams)
device = torch.device("cuda" if USE_CUDA else "cpu")
# Create network instance.
model = SimpleAutoencoder(netParams, hidden_size=100,
latent_size=50).to(device)
# Load model
load_model(MODEL_PTH, model)
# Define optimizer module.
optimizer = torch.optim.Adam(model.parameters(), lr=LR, amsgrad=True)
# Learning stats instance.
stats = snn.learningStats()
