def test(network, data, labels):
activities = torch.zeros(len(data), RUN_TIME, len(SUBJECTS)) # data_size * run_time * classes
true_labels = torch.from_numpy(np.array(labels))
for index, image_batch in enumerate(tqdm(data)):
network_input = encode_image_batch(image_batch)
network.run(network_input, time=RUN_TIME)
spikes = network.monitors["OUT"].get("s")
activities[index, :, :] = spikes[-RUN_TIME:, 0]
assignments = assign_labels(activities, true_labels, len(SUBJECTS))
predicated_labels = all_activity(activities, assignments[0], len(SUBJECTS))
print(classification_report(true_labels, predicated_labels))
def predict(labeled_batches):
print(f"predicting {len(labeled_batches)} batches...")
n_samples = len(labeled_batches)
n_classes = len(TARGETS)
true_labels = torch.zeros(n_samples)
activities = torch.zeros(n_samples, ENCODE_WINDOW, n_classes)
sample_idx = 0
for label, img_batch in tqdm(labeled_batches):
run_sinle_batch(img_batch)
activities[sample_idx, :, :] = get_result_activity()
sample_idx += 1
assignments, _, _ = assign_labels(activities, true_labels, n_classes)
pred_labels = all_activity(activities, assignments, n_classes)
return pred_labels
update_interval)
print(
"\nAll activity accuracy: %.2f (last), %.2f (average), %.2f (best)"
% (accuracy["all"][-1], np.mean(
accuracy["all"]), np.max(accuracy["all"])))
print(
"Proportion weighting accuracy: %.2f (last), %.2f (average), %.2f (best)\n"
% (
accuracy["proportion"][-1],
np.mean(accuracy["proportion"]),
np.max(accuracy["proportion"]),
))
# Assign labels to excitatory layer neurons.
assignments, proportions, rates = assign_labels(
spike_record, labels, num_classes, rates)
#Add the current label to the list of labels for this update_interval
labels[i % update_interval] = label[0]
# Run the network on the input.
choice = np.random.choice(int(n_neurons / num_classes),
size=n_clamp,
replace=False)
clamp = {"Ae": per_class * label.long() + torch.Tensor(choice).long()}
inputs = {"X": image.view(time, 480, 480, 3)}
network.run(inputs=inputs, time=time, clamp=clamp)
# Get voltage recording.
exc_voltages = exc_voltage_monitor.get("v")
inh_voltages = inh_voltage_monitor.get("v")
def main(seed=0,
n_neurons=100,
n_train=60000,
n_test=10000,
inhib=100,
lr=1e-2,
lr_decay=1,
time=350,
dt=1,
theta_plus=0.05,
theta_decay=1e7,
intensity=1,
progress_interval=10,
update_interval=250,
plot=False,
train=True,
gpu=False):
assert n_train % update_interval == 0 and n_test % update_interval == 0, \
'No. examples must be divisible by update_interval'
params = [
seed, n_neurons, n_train, inhib, lr, lr_decay, time, dt, theta_plus,
theta_decay, intensity, progress_interval, update_interval
]
test_params = [
seed, n_neurons, n_train, n_test, inhib, lr, lr_decay, time, dt,
theta_plus, theta_decay, intensity, progress_interval, update_interval
]
model_name = '_'.join([str(x) for x in params])
np.random.seed(seed)
if gpu:
torch.set_default_tensor_type('torch.cuda.FloatTensor')
torch.cuda.manual_seed_all(seed)
else:
torch.manual_seed(seed)
n_examples = n_train if train else n_test
n_sqrt = int(np.ceil(np.sqrt(n_neurons)))
n_classes = 10
# Build network.
if train:
network = DiehlAndCook2015v2(n_inpt=784,
n_neurons=n_neurons,
inh=inhib,
dt=dt,
norm=78.4,
theta_plus=theta_plus,
theta_decay=theta_decay,
nu=[0, lr])
else:
network = load(os.path.join(params_path, model_name + '.pt'))
network.connections['X', 'Y'].update_rule = NoOp(
connection=network.connections['X', 'Y'],
nu=network.connections['X', 'Y'].nu)
network.layers['Y'].theta_decay = 0
network.layers['Y'].theta_plus = 0
# Load MNIST data.
dataset = MNIST(path=data_path, download=True)
if train:
images, labels = dataset.get_train()
else:
images, labels = dataset.get_test()
images = images.view(-1, 784)
images *= intensity
# Record spikes during the simulation.
spike_record = torch.zeros(update_interval, time, n_neurons)
full_spike_record = torch.zeros(n_examples, n_neurons).long()
# Neuron assignments and spike proportions.
if train:
assignments = -torch.ones_like(torch.Tensor(n_neurons))
proportions = torch.zeros_like(torch.Tensor(n_neurons, n_classes))
rates = torch.zeros_like(torch.Tensor(n_neurons, n_classes))
ngram_scores = {}
else:
path = os.path.join(params_path,
'_'.join(['auxiliary', model_name]) + '.pt')
assignments, proportions, rates, ngram_scores = torch.load(
open(path, 'rb'))
# Sequence of accuracy estimates.
curves = {'all': [], 'proportion': [], 'ngram': []}
predictions = {scheme: torch.Tensor().long() for scheme in curves.keys()}
if train:
best_accuracy = 0
spikes = {}
for layer in set(network.layers):
spikes[layer] = Monitor(network.layers[layer],
state_vars=['s'],
time=time)
network.add_monitor(spikes[layer], name='%s_spikes' % layer)
# Train the network.
if train:
print('\nBegin training.\n')
else:
print('\nBegin test.\n')
inpt_axes = None
inpt_ims = None
spike_ims = None
spike_axes = None
weights_im = None
assigns_im = None
perf_ax = None
start = t()
for i in range(n_examples):
if i % progress_interval == 0:
print(f'Progress: {i} / {n_examples} ({t() - start:.4f} seconds)')
start = t()
if i % update_interval == 0 and i > 0:
if train:
network.connections['X', 'Y'].update_rule.nu[1] *= lr_decay
if i % len(labels) == 0:
current_labels = labels[-update_interval:]
else:
current_labels = labels[i % len(images) - update_interval:i %
len(images)]
# Update and print accuracy evaluations.
curves, preds = update_curves(curves,
current_labels,
n_classes,
spike_record=spike_record,
assignments=assignments,
proportions=proportions,
ngram_scores=ngram_scores,
n=2)
print_results(curves)
for scheme in preds:
predictions[scheme] = torch.cat(
[predictions[scheme], preds[scheme]], -1)
# Save accuracy curves to disk.
to_write = ['train'] + params if train else ['test'] + params
f = '_'.join([str(x) for x in to_write]) + '.pt'
torch.save((curves, update_interval, n_examples),
open(os.path.join(curves_path, f), 'wb'))
if train:
if any([x[-1] > best_accuracy for x in curves.values()]):
print(
'New best accuracy! Saving network parameters to disk.'
)
# Save network to disk.
network.save(os.path.join(params_path, model_name + '.pt'))
path = os.path.join(
params_path,
'_'.join(['auxiliary', model_name]) + '.pt')
torch.save((assignments, proportions, rates, ngram_scores),
open(path, 'wb'))
best_accuracy = max([x[-1] for x in curves.values()])
# Assign labels to excitatory layer neurons.
assignments, proportions, rates = assign_labels(
spike_record, current_labels, n_classes, rates)
# Compute ngram scores.
ngram_scores = update_ngram_scores(spike_record,
current_labels, n_classes,
2, ngram_scores)
print()
# Get next input sample.
image = images[i % len(images)]
sample = poisson(datum=image, time=time, dt=dt)
inpts = {'X': sample}
# Run the network on the input.
network.run(inpts=inpts, time=time)
retries = 0
while spikes['Y'].get('s').sum() < 1 and retries < 3:
retries += 1
image *= 2
sample = poisson(datum=image, time=time, dt=dt)
inpts = {'X': sample}
network.run(inpts=inpts, time=time)
# Add to spikes recording.
spike_record[i % update_interval] = spikes['Y'].get('s').t()
full_spike_record[i] = spikes['Y'].get('s').t().sum(0).long()
# Optionally plot various simulation information.
if plot:
# _input = image.view(28, 28)
# reconstruction = inpts['X'].view(time, 784).sum(0).view(28, 28)
_spikes = {layer: spikes[layer].get('s') for layer in spikes}
input_exc_weights = network.connections[('X', 'Y')].w
square_weights = get_square_weights(
input_exc_weights.view(784, n_neurons), n_sqrt, 28)
# square_assignments = get_square_assignments(assignments, n_sqrt)
# inpt_axes, inpt_ims = plot_input(_input, reconstruction, label=labels[i], axes=inpt_axes, ims=inpt_ims)
spike_ims, spike_axes = plot_spikes(_spikes,
ims=spike_ims,
axes=spike_axes)
weights_im = plot_weights(square_weights, im=weights_im)
# assigns_im = plot_assignments(square_assignments, im=assigns_im)
# perf_ax = plot_performance(curves, ax=perf_ax)
plt.pause(1e-8)
network.reset_() # Reset state variables.
print(f'Progress: {n_examples} / {n_examples} ({t() - start:.4f} seconds)')
i += 1
if i % len(labels) == 0:
current_labels = labels[-update_interval:]
else:
current_labels = labels[i % len(images) - update_interval:i %
len(images)]
# Update and print accuracy evaluations.
curves, preds = update_curves(curves,
current_labels,
n_classes,
spike_record=spike_record,
assignments=assignments,
proportions=proportions,
ngram_scores=ngram_scores,
n=2)
print_results(curves)
for scheme in preds:
predictions[scheme] = torch.cat([predictions[scheme], preds[scheme]],
-1)
if train:
if any([x[-1] > best_accuracy for x in curves.values()]):
print('New best accuracy! Saving network parameters to disk.')
# Save network to disk.
if train:
network.save(os.path.join(params_path, model_name + '.pt'))
path = os.path.join(
params_path, '_'.join(['auxiliary', model_name]) + '.pt')
torch.save((assignments, proportions, rates, ngram_scores),
open(path, 'wb'))
if train:
print('\nTraining complete.\n')
else:
print('\nTest complete.\n')
print('Average accuracies:\n')
for scheme in curves.keys():
print('\t%s: %.2f' % (scheme, float(np.mean(curves[scheme]))))
# Save accuracy curves to disk.
to_write = ['train'] + params if train else ['test'] + params
f = '_'.join([str(x) for x in to_write]) + '.pt'
torch.save((curves, update_interval, n_examples),
open(os.path.join(curves_path, f), 'wb'))
# Save results to disk.
results = [
np.mean(curves['all']),
np.mean(curves['proportion']),
np.mean(curves['ngram']),
np.max(curves['all']),
np.max(curves['proportion']),
np.max(curves['ngram'])
]
to_write = params + results if train else test_params + results
to_write = [str(x) for x in to_write]
name = 'train.csv' if train else 'test.csv'
if not os.path.isfile(os.path.join(results_path, name)):
with open(os.path.join(results_path, name), 'w') as f:
if train:
f.write(
'random_seed,n_neurons,n_train,inhib,lr,lr_decay,time,timestep,theta_plus,theta_decay,intensity,'
'progress_interval,update_interval,mean_all_activity,mean_proportion_weighting,'
'mean_ngram,max_all_activity,max_proportion_weighting,max_ngram\n'
)
else:
f.write(
'random_seed,n_neurons,n_train,n_test,inhib,lr,lr_decay,time,timestep,theta_plus,theta_decay,'
'intensity,progress_interval,update_interval,mean_all_activity,mean_proportion_weighting,'
'mean_ngram,max_all_activity,max_proportion_weighting,max_ngram\n'
)
with open(os.path.join(results_path, name), 'a') as f:
f.write(','.join(to_write) + '\n')
if labels.numel() > n_examples:
labels = labels[:n_examples]
else:
while labels.numel() < n_examples:
if 2 * labels.numel() > n_examples:
labels = torch.cat(
[labels, labels[:n_examples - labels.numel()]])
else:
labels = torch.cat([labels, labels])
# Compute confusion matrices and save them to disk.
confusions = {}
for scheme in predictions:
confusions[scheme] = confusion_matrix(labels, predictions[scheme])
to_write = ['train'] + params if train else ['test'] + test_params
f = '_'.join([str(x) for x in to_write]) + '.pt'
torch.save(confusions, os.path.join(confusion_path, f))
# Save full spike record to disk.
torch.save(full_spike_record, os.path.join(spikes_path, f))
accuracy['proportion'].append(
100 *
torch.sum(labels[i - update_interval:i].long() == proportion_pred)
/ update_interval)
print(
'\nAll activity accuracy: %.2f (last), %.2f (average), %.2f (best)'
% (accuracy['all'][-1], np.mean(
accuracy['all']), np.max(accuracy['all'])))
print(
'Proportion weighting accuracy: %.2f (last), %.2f (average), %.2f (best)\n'
% (accuracy['proportion'][-1], np.mean(
accuracy['proportion']), np.max(accuracy['proportion'])))
# Assign labels to excitatory layer neurons.
assignments, proportions, rates = assign_labels(
spike_record, labels[i - update_interval:i], 10, rates)
# Get next input sample.
sample = next(data_loader)
inpts = {'X': sample}
# Run the network on the input.
choice = np.random.choice(int(n_neurons / 10), size=n_clamp, replace=False)
clamp = {'Ae': per_class * labels[i].long() + torch.Tensor(choice).long()}
network.run(inpts=inpts, time=time, clamp=clamp)
# Get voltage recording.
exc_voltages = exc_voltage_monitor.get('v')
inh_voltages = inh_voltage_monitor.get('v')
# Add to spikes recording.
np.mean(accuracy["all"]),
np.max(accuracy["all"]),
)
)
print(
"Proportion weighting accuracy: %.2f (last), %.2f (average), %.2f (best)\n"
% (
accuracy["proportion"][-1],
np.mean(accuracy["proportion"]),
np.max(accuracy["proportion"]),
)
)
# Assign labels to excitatory layer neurons.
assignments, proportions, rates = assign_labels(
spike_record, label_tensor[step - update_interval : step], 10, rates
)
# Run the network on the input.
network.run(inpts=inpts, time=time, input_time_dim=1)
# Get voltage recording.
exc_voltages = exc_voltage_monitor.get("v")
inh_voltages = inh_voltage_monitor.get("v")
# Add to spikes recording.
spike_record[step % update_interval] = spikes["Ae"].get("s").t()
# Optionally plot various simulation information.
if plot:
inpt = inpts["X"].view(time, 784).sum(0).view(28, 28)
# Save network to disk.
path = os.path.join('..', '..', 'params', data, model)
if not os.path.isdir(path):
os.makedirs(path)
network.save(os.path.join(path, model_name + '.pt'))
path = os.path.join(
path, '_'.join(['auxiliary', model_name]) + '.pt')
torch.save((assignments, proportions, rates, ngram_scores),
open(path, 'wb'))
best_accuracy = max([x[-1] for x in curves.values()])
# Assign labels to excitatory layer neurons.
assignments, proportions, rates = assign_labels(
spike_record, current_labels, n_classes, rates)
# Compute ngram scores.
ngram_scores = update_ngram_scores(spike_record, current_labels,
n_classes, 2, ngram_scores)
print()
# Get next input sample.
image = images[i]
sample = bernoulli(datum=image, time=time, dt=dt,
max_prob=0.5).unsqueeze(1).unsqueeze(1)
inpts = {'X': sample}
# Run the network on the input.
network.run(inpts=inpts, time=time)
def main(seed=0, n_train=60000, n_test=10000, c_low=1, c_high=25, p_low=0.5, kernel_size=(16,), stride=(2,),
n_filters=25, crop=4, lr=0.01, lr_decay=1, time=100, dt=1, theta_plus=0.05, theta_decay=1e-7, intensity=1,
norm=0.2, progress_interval=10, update_interval=250, plot=False, train=True, gpu=False):
assert n_train % update_interval == 0 and n_test % update_interval == 0, \
'No. examples must be divisible by update_interval'
params = [
seed, kernel_size, stride, n_filters, crop, lr, lr_decay, n_train, c_low, c_high, p_low, time, dt,
theta_plus, theta_decay, intensity, norm, progress_interval, update_interval
]
model_name = '_'.join([str(x) for x in params])
if not train:
test_params = [
seed, kernel_size, stride, n_filters, crop, lr, lr_decay, n_train, n_test, c_low, c_high, p_low, time, dt,
theta_plus, theta_decay, intensity, norm, progress_interval, update_interval
]
np.random.seed(seed)
if gpu:
torch.set_default_tensor_type('torch.cuda.FloatTensor')
torch.cuda.manual_seed_all(seed)
else:
torch.manual_seed(seed)
side_length = 28 - crop * 2
n_inpt = side_length ** 2
input_shape = [side_length, side_length]
n_examples = n_train if train else n_test
n_classes = 10
if _pair(kernel_size) == input_shape:
conv_size = [1, 1]
else:
conv_size = (int((input_shape[0] - _pair(kernel_size)[0]) / _pair(stride)[0]) + 1,
int((input_shape[1] - _pair(kernel_size)[1]) / _pair(stride)[1]) + 1)
# Build network.
if train:
network = Network()
input_layer = Input(n=n_inpt, traces=True, trace_tc=5e-2)
output_layer = DiehlAndCookNodes(
n=n_filters * conv_size[0] * conv_size[1], traces=True, rest=-65.0, reset=-60.0,
thresh=-52.0, refrac=5, decay=1e-2, trace_tc=5e-2, theta_plus=theta_plus, theta_decay=theta_decay
)
input_output_conn = LocallyConnectedConnection(
input_layer, output_layer, kernel_size=kernel_size, stride=stride, n_filters=n_filters,
nu=[0, lr], update_rule=PostPre, wmin=0, wmax=1, norm=norm, input_shape=input_shape
)
w = torch.zeros(n_filters, *conv_size, n_filters, *conv_size)
for fltr1 in range(n_filters):
for fltr2 in range(n_filters):
if fltr1 != fltr2:
for j in range(conv_size[0]):
for k in range(conv_size[1]):
x1, y1 = fltr1 // np.sqrt(n_filters), fltr1 % np.sqrt(n_filters)
x2, y2 = fltr2 // np.sqrt(n_filters), fltr2 % np.sqrt(n_filters)
w[fltr1, j, k, fltr2, j, k] = max(-c_high, -c_low * np.sqrt(euclidean([x1, y1], [x2, y2])))
w = w.view(n_filters * conv_size[0] * conv_size[1], n_filters * conv_size[0] * conv_size[1])
recurrent_conn = Connection(output_layer, output_layer, w=w)
plt.matshow(w)
plt.colorbar()
network.add_layer(input_layer, name='X')
network.add_layer(output_layer, name='Y')
network.add_connection(input_output_conn, source='X', target='Y')
network.add_connection(recurrent_conn, source='Y', target='Y')
else:
network = load_network(os.path.join(params_path, model_name + '.pt'))
network.connections['X', 'Y'].update_rule = NoOp(
connection=network.connections['X', 'Y'], nu=network.connections['X', 'Y'].nu
)
network.layers['Y'].theta_decay = 0
network.layers['Y'].theta_plus = 0
conv_size = network.connections['X', 'Y'].conv_size
locations = network.connections['X', 'Y'].locations
conv_prod = int(np.prod(conv_size))
n_neurons = n_filters * conv_prod
# Voltage recording for excitatory and inhibitory layers.
voltage_monitor = Monitor(network.layers['Y'], ['v'], time=time)
network.add_monitor(voltage_monitor, name='output_voltage')
# Load MNIST data.
dataset = MNIST(path=data_path, download=True)
if train:
images, labels = dataset.get_train()
else:
images, labels = dataset.get_test()
images *= intensity
images = images[:, crop:-crop, crop:-crop]
# Record spikes during the simulation.
spike_record = torch.zeros(update_interval, time, n_neurons)
# Neuron assignments and spike proportions.
if train:
assignments = -torch.ones_like(torch.Tensor(n_neurons))
proportions = torch.zeros_like(torch.Tensor(n_neurons, 10))
rates = torch.zeros_like(torch.Tensor(n_neurons, 10))
ngram_scores = {}
else:
path = os.path.join(params_path, '_'.join(['auxiliary', model_name]) + '.pt')
assignments, proportions, rates, ngram_scores = torch.load(open(path, 'rb'))
if train:
best_accuracy = 0
# Sequence of accuracy estimates.
curves = {'all': [], 'proportion': [], 'ngram': []}
predictions = {
scheme: torch.Tensor().long() for scheme in curves.keys()
}
spikes = {}
for layer in set(network.layers):
spikes[layer] = Monitor(network.layers[layer], state_vars=['s'], time=time)
network.add_monitor(spikes[layer], name=f'{layer}_spikes')
# Train the network.
if train:
print('\nBegin training.\n')
else:
print('\nBegin test.\n')
spike_ims = None
spike_axes = None
weights_im = None
# Calculate linear increase every update interval.
if train:
n_increase = int(p_low * n_examples) / update_interval
increase = (c_high - c_low) / n_increase
increases = 0
inhib = c_low
start = t()
for i in range(n_examples):
if i % progress_interval == 0:
print(f'Progress: {i} / {n_examples} ({t() - start:.4f} seconds)')
start = t()
if i % update_interval == 0 and i > 0:
if train:
network.connections['X', 'Y'].update_rule.nu[1] *= lr_decay
if increases < n_increase:
inhib = inhib + increase
print(f'\nIncreasing inhibition to {inhib}.\n')
w = torch.zeros(n_filters, *conv_size, n_filters, *conv_size)
for fltr1 in range(n_filters):
for fltr2 in range(n_filters):
if fltr1 != fltr2:
for j in range(conv_size[0]):
for k in range(conv_size[1]):
x1, y1 = fltr1 // np.sqrt(n_filters), fltr1 % np.sqrt(n_filters)
x2, y2 = fltr2 // np.sqrt(n_filters), fltr2 % np.sqrt(n_filters)
w[fltr1, j, k, fltr2, j, k] = max(-c_high, -c_low * np.sqrt(euclidean([x1, y1], [x2, y2])))
w = w.view(n_filters * conv_size[0] * conv_size[1], n_filters * conv_size[0] * conv_size[1])
network.connections['Y', 'Y'].w = w
if i % len(labels) == 0:
current_labels = labels[-update_interval:]
else:
current_labels = labels[i % len(images) - update_interval:i % len(images)]
# Update and print accuracy evaluations.
curves, preds = update_curves(
curves, current_labels, n_classes, spike_record=spike_record, assignments=assignments,
proportions=proportions, ngram_scores=ngram_scores, n=2
)
print_results(curves)
for scheme in preds:
predictions[scheme] = torch.cat([predictions[scheme], preds[scheme]], -1)
# Save accuracy curves to disk.
to_write = ['train'] + params if train else ['test'] + params
f = '_'.join([str(x) for x in to_write]) + '.pt'
torch.save((curves, update_interval, n_examples), open(os.path.join(curves_path, f), 'wb'))
if train:
if any([x[-1] > best_accuracy for x in curves.values()]):
print('New best accuracy! Saving network parameters to disk.')
# Save network to disk.
network.save(os.path.join(params_path, model_name + '.pt'))
path = os.path.join(params_path, '_'.join(['auxiliary', model_name]) + '.pt')
torch.save((assignments, proportions, rates, ngram_scores), open(path, 'wb'))
best_accuracy = max([x[-1] for x in curves.values()])
# Assign labels to excitatory layer neurons.
assignments, proportions, rates = assign_labels(spike_record, current_labels, 10, rates)
# Compute ngram scores.
ngram_scores = update_ngram_scores(spike_record, current_labels, 10, 2, ngram_scores)
print()
# Get next input sample.
image = images[i % update_interval].contiguous().view(-1)
sample = poisson(datum=image, time=time, dt=dt)
inpts = {'X': sample}
# Run the network on the input.
network.run(inpts=inpts, time=time)
retries = 0
while spikes['Y'].get('s').sum() < 5 and retries < 3:
retries += 1
image *= 2
sample = poisson(datum=image, time=time, dt=dt)
inpts = {'X': sample}
network.run(inpts=inpts, time=time)
# Add to spikes recording.
spike_record[i % update_interval] = spikes['Y'].get('s').t()
# Optionally plot various simulation information.
if plot:
_spikes = {
'X': spikes['X'].get('s').view(side_length ** 2, time),
'Y': spikes['Y'].get('s').view(n_filters * conv_prod, time)
}
spike_ims, spike_axes = plot_spikes(spikes=_spikes, ims=spike_ims, axes=spike_axes)
weights_im = plot_locally_connected_weights(
network.connections[('X', 'Y')].w, n_filters, kernel_size, conv_size, locations, side_length, im=weights_im
)
plt.pause(1e-8)
network.reset_() # Reset state variables.
print(f'Progress: {n_examples} / {n_examples} ({t() - start:.4f} seconds)')
i += 1
if i % len(labels) == 0:
current_labels = labels[-update_interval:]
else:
current_labels = labels[i % len(images) - update_interval:i % len(images)]
# Update and print accuracy evaluations.
curves, preds = update_curves(
curves, current_labels, n_classes, spike_record=spike_record, assignments=assignments,
proportions=proportions, ngram_scores=ngram_scores, n=2
)
print_results(curves)
for scheme in preds:
predictions[scheme] = torch.cat([predictions[scheme], preds[scheme]], -1)
if train:
if any([x[-1] > best_accuracy for x in curves.values()]):
print('New best accuracy! Saving network parameters to disk.')
# Save network to disk.
network.save(os.path.join(params_path, model_name + '.pt'))
path = os.path.join(params_path, '_'.join(['auxiliary', model_name]) + '.pt')
torch.save((assignments, proportions, rates, ngram_scores), open(path, 'wb'))
if train:
print('\nTraining complete.\n')
else:
print('\nTest complete.\n')
print('Average accuracies:\n')
for scheme in curves.keys():
print('\t%s: %.2f' % (scheme, float(np.mean(curves[scheme]))))
# Save accuracy curves to disk.
to_write = ['train'] + params if train else ['test'] + params
f = '_'.join([str(x) for x in to_write]) + '.pt'
torch.save((curves, update_interval, n_examples), open(os.path.join(curves_path, f), 'wb'))
# Save results to disk.
results = [
np.mean(curves['all']), np.mean(curves['proportion']), np.mean(curves['ngram']),
np.max(curves['all']), np.max(curves['proportion']), np.max(curves['ngram'])
]
to_write = params + results if train else test_params + results
to_write = [str(x) for x in to_write]
name = 'train.csv' if train else 'test.csv'
if not os.path.isfile(os.path.join(results_path, name)):
with open(os.path.join(results_path, name), 'w') as f:
if train:
f.write(
'random_seed,kernel_size,stride,n_filters,crop,lr,lr_decay,n_train,c_low,c_high,p_low,time,timestep,theta_plus,'
'theta_decay,intensity,norm,progress_interval,update_interval,mean_all_activity,'
'mean_proportion_weighting,mean_ngram,max_all_activity,max_proportion_weighting,max_ngram\n'
)
else:
f.write(
'random_seed,kernel_size,stride,n_filters,crop,lr,lr_decay,n_train,n_test,c_low,c_high,p_low,time,timestep,'
'theta_plus,theta_decay,intensity,norm,progress_interval,update_interval,mean_all_activity,'
'mean_proportion_weighting,mean_ngram,max_all_activity,max_proportion_weighting,max_ngram\n'
)
with open(os.path.join(results_path, name), 'a') as f:
f.write(','.join(to_write) + '\n')
if labels.numel() > n_examples:
labels = labels[:n_examples]
else:
while labels.numel() < n_examples:
if 2 * labels.numel() > n_examples:
labels = torch.cat([labels, labels[:n_examples - labels.numel()]])
else:
labels = torch.cat([labels, labels])
# Compute confusion matrices and save them to disk.
confusions = {}
for scheme in predictions:
confusions[scheme] = confusion_matrix(labels, predictions[scheme])
to_write = ['train'] + params if train else ['test'] + test_params
f = '_'.join([str(x) for x in to_write]) + '.pt'
torch.save(confusions, os.path.join(confusion_path, f))
def main(args):
if args.update_steps is None:
args.update_steps = max(
250 // args.batch_size, 1
) #Its value is 16 # why is it always multiplied with step? #update_steps is how many batch to classify before updating the graphs
update_interval = args.update_steps * args.batch_size # Value is 240 #update_interval is how many pictures to classify before updating the graphs
# Sets up GPU use
torch.backends.cudnn.benchmark = False
if args.gpu and torch.cuda.is_available():
torch.cuda.manual_seed_all(
args.seed
) #to enable reproducability of the code to get the same result
else:
torch.manual_seed(args.seed)
# Determines number of workers to use
if args.n_workers == -1:
args.n_workers = args.gpu * 4 * torch.cuda.device_count()
n_sqrt = int(np.ceil(np.sqrt(args.n_neurons)))
if args.reduction == "sum": #could have used switch to improve performance
reduction = torch.sum #weight updates for the batch
elif args.reduction == "mean":
reduction = torch.mean
elif args.reduction == "max":
reduction = max_without_indices
else:
raise NotImplementedError
# Build network.
network = DiehlAndCook2015v2( #Changed here
n_inpt=784, # input dimensions are 28x28=784
n_neurons=args.n_neurons,
inh=args.inh,
dt=args.dt,
norm=78.4,
nu=(1e-4, 1e-2),
reduction=reduction,
theta_plus=args.theta_plus,
inpt_shape=(1, 28, 28),
)
# Directs network to GPU
if args.gpu:
network.to("cuda")
# Load MNIST data.
dataset = MNIST(
PoissonEncoder(time=args.time, dt=args.dt),
None,
root=os.path.join(ROOT_DIR, "data", "MNIST"),
download=True,
train=True,
transform=transforms.Compose( #Composes several transforms together
[
transforms.ToTensor(),
transforms.Lambda(lambda x: x * args.intensity)
]),
)
test_dataset = MNIST(
PoissonEncoder(time=args.time, dt=args.dt),
None,
root=os.path.join(ROOT_DIR, "data", "MNIST"),
download=True,
train=False,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Lambda(lambda x: x * args.intensity)
]),
)
# Neuron assignments and spike proportions.
n_classes = 10 #changed
assignments = -torch.ones(args.n_neurons) #assignments is set to -1
proportions = torch.zeros(args.n_neurons,
n_classes) #matrix of 100x10 filled with zeros
rates = torch.zeros(args.n_neurons,
n_classes) #matrix of 100x10 filled with zeros
# Set up monitors for spikes and voltages
spikes = {}
for layer in set(network.layers):
spikes[layer] = Monitor(
network.layers[layer], state_vars=["s"], time=args.time
) # Monitors: Records state variables of interest. obj:An object to record state variables from during network simulation.
network.add_monitor(
spikes[layer], name="%s_spikes" % layer
) #state_vars: Iterable of strings indicating names of state variables to record.
#param time: If not ``None``, pre-allocate memory for state variable recording.
weights_im = None
spike_ims, spike_axes = None, None
# Record spikes for length of update interval.
spike_record = torch.zeros(update_interval, args.time, args.n_neurons)
if os.path.isdir(
args.log_dir): #checks if the path is a existing directory
shutil.rmtree(
args.log_dir) # is used to delete an entire directory tree
# Summary writer.
writer = SummaryWriter(
log_dir=args.log_dir, flush_secs=60
) #SummaryWriter: these utilities let you log PyTorch models and metrics into a directory for visualization
#flush_secs: in seconds, to flush the pending events and summaries to disk.
for epoch in range(args.n_epochs): #default is 1
print("\nEpoch: {epoch}\n")
labels = []
# Create a dataloader to iterate and batch data
dataloader = DataLoader( #It represents a Python iterable over a dataset
dataset,
batch_size=args.batch_size, #how many samples per batch to load
shuffle=
True, #set to True to have the data reshuffled at every epoch
num_workers=args.n_workers,
pin_memory=args.
gpu, #If True, the data loader will copy Tensors into CUDA pinned memory before returning them.
)
for step, batch in enumerate(
dataloader
): #Enumerate() method adds a counter to an iterable and returns it in a form of enumerate object
print("Step:", step)
global_step = 60000 * epoch + args.batch_size * step
if step % args.update_steps == 0 and step > 0:
# Convert the array of labels into a tensor
label_tensor = torch.tensor(labels)
# Get network predictions.
all_activity_pred = all_activity(spikes=spike_record,
assignments=assignments,
n_labels=n_classes)
proportion_pred = proportion_weighting(
spikes=spike_record,
assignments=assignments,
proportions=proportions,
n_labels=n_classes,
)
writer.add_scalar(
tag="accuracy/all vote",
scalar_value=torch.mean(
(label_tensor.long() == all_activity_pred).float()),
global_step=global_step,
)
#Vennila: Records the accuracies in each step
value = torch.mean(
(label_tensor.long() == all_activity_pred).float())
value = value.item()
accuracy.append(value)
print("ACCURACY:", value)
writer.add_scalar(
tag="accuracy/proportion weighting",
scalar_value=torch.mean(
(label_tensor.long() == proportion_pred).float()),
global_step=global_step,
)
writer.add_scalar(
tag="spikes/mean",
scalar_value=torch.mean(torch.sum(spike_record, dim=1)),
global_step=global_step,
)
square_weights = get_square_weights(
network.connections["X", "Y"].w.view(784, args.n_neurons),
n_sqrt,
28,
)
img_tensor = colorize(square_weights, cmap="hot_r")
writer.add_image(
tag="weights",
img_tensor=img_tensor,
global_step=global_step,
dataformats="HWC",
)
# Assign labels to excitatory layer neurons.
assignments, proportions, rates = assign_labels(
spikes=spike_record,
labels=label_tensor,
n_labels=n_classes,
rates=rates,
)
labels = []
labels.extend(
batch["label"].tolist()
) #for each batch or 16 pictures the labels of it is added to this list
# Prep next input batch.
inpts = {"X": batch["encoded_image"]}
if args.gpu:
inpts = {
k: v.cuda()
for k, v in inpts.items()
} #.cuda() is used to set up and run CUDA operations in the selected GPU
# Run the network on the input.
t0 = time()
network.run(inputs=inpts, time=args.time, one_step=args.one_step
) # Simulate network for given inputs and time.
t1 = time() - t0
# Add to spikes recording.
s = spikes["Y"].get("s").permute((1, 0, 2))
spike_record[(step * args.batch_size) %
update_interval:(step * args.batch_size %
update_interval) + s.size(0)] = s
writer.add_scalar(tag="time/simulation",
scalar_value=t1,
global_step=global_step)
# if(step==1):
# input_exc_weights = network.connections["X", "Y"].w
# an_array = input_exc_weights.detach().cpu().clone().numpy()
# #print(np.shape(an_array))
# data = asarray(an_array)
# savetxt('data.csv',data)
# print("Beginning weights saved")
# if(step==3749):
# input_exc_weights = network.connections["X", "Y"].w
# an_array = input_exc_weights.detach().cpu().clone().numpy()
# #print(np.shape(an_array))
# data2 = asarray(an_array)
# savetxt('data2.csv',data2)
# print("Ending weights saved")
# Plot simulation data.
if args.plot:
input_exc_weights = network.connections["X", "Y"].w
# print("Weights:",input_exc_weights)
square_weights = get_square_weights(
input_exc_weights.view(784, args.n_neurons), n_sqrt, 28)
spikes_ = {
layer: spikes[layer].get("s")[:, 0]
for layer in spikes
}
spike_ims, spike_axes = plot_spikes(spikes_,
ims=spike_ims,
axes=spike_axes)
weights_im = plot_weights(square_weights, im=weights_im)
plt.pause(1e-8)
# Reset state variables.
network.reset_state_variables()
print(end_accuracy()) #Vennila
def main(args):
update_interval = args.update_steps * args.batch_size
# Sets up GPU use
torch.backends.cudnn.benchmark = False
if args.gpu and torch.cuda.is_available():
torch.cuda.manual_seed_all(args.seed)
else:
torch.manual_seed(args.seed)
# Determines number of workers to use
if args.n_workers == -1:
args.n_workers = args.gpu * 4 * torch.cuda.device_count()
n_sqrt = int(np.ceil(np.sqrt(args.n_neurons)))
if args.reduction == "sum":
reduction = torch.sum
elif args.reduction == "mean":
reduction = torch.mean
elif args.reduction == "max":
reduction = max_without_indices
else:
raise NotImplementedError
# Build network.
network = DiehlAndCook2015v2(
n_inpt=784,
n_neurons=args.n_neurons,
inh=args.inh,
dt=args.dt,
norm=78.4,
nu=(0.0, 1e-2),
reduction=reduction,
theta_plus=args.theta_plus,
inpt_shape=(1, 28, 28),
)
# Directs network to GPU.
if args.gpu:
network.to("cuda")
# Load MNIST data.
dataset = MNIST(
PoissonEncoder(time=args.time, dt=args.dt),
None,
root=os.path.join(ROOT_DIR, "data", "MNIST"),
download=True,
train=True,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Lambda(lambda x: x * args.intensity)
]),
)
dataset, valid_dataset = torch.utils.data.random_split(
dataset, [59000, 1000])
test_dataset = MNIST(
PoissonEncoder(time=args.time, dt=args.dt),
None,
root=os.path.join(ROOT_DIR, "data", "MNIST"),
download=True,
train=False,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Lambda(lambda x: x * args.intensity)
]),
)
# Neuron assignments and spike proportions.
n_classes = 10
assignments = -torch.ones(args.n_neurons)
proportions = torch.zeros(args.n_neurons, n_classes)
rates = torch.zeros(args.n_neurons, n_classes)
# Set up monitors for spikes and voltages
spikes = {}
for layer in set(network.layers):
spikes[layer] = Monitor(network.layers[layer],
state_vars=["s"],
time=args.time)
network.add_monitor(spikes[layer], name="%s_spikes" % layer)
weights_im = None
spike_ims, spike_axes = None, None
# Record spikes for length of update interval.
spike_record = torch.zeros(update_interval, args.time, args.n_neurons)
if os.path.isdir(args.log_dir):
shutil.rmtree(args.log_dir)
# Summary writer.
writer = SummaryWriter(log_dir=args.log_dir, flush_secs=60)
for epoch in range(args.n_epochs):
print(f"\nEpoch: {epoch}\n")
labels = []
# Get training data loader.
dataloader = DataLoader(
dataset=dataset,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.n_workers,
pin_memory=args.gpu,
)
for step, batch in enumerate(dataloader):
print(f"Step: {step} / {len(dataloader)}")
global_step = 60000 * epoch + args.batch_size * step
if step % args.update_steps == 0 and step > 0:
# Disable learning.
network.train(False)
# Get test data loader.
valid_dataloader = DataLoader(
dataset=valid_dataset,
batch_size=args.test_batch_size,
shuffle=True,
num_workers=args.n_workers,
pin_memory=args.gpu,
)
test_labels = []
test_spike_record = torch.zeros(len(valid_dataset), args.time,
args.n_neurons)
t0 = time()
for test_step, test_batch in enumerate(valid_dataloader):
# Prep next input batch.
inpts = {"X": test_batch["encoded_image"]}
if args.gpu:
inpts = {k: v.cuda() for k, v in inpts.items()}
# Run the network on the input (inference mode).
network.run(inpts=inpts,
time=args.time,
one_step=args.one_step)
# Add to spikes recording.
s = spikes["Y"].get("s").permute((1, 0, 2))
test_spike_record[(test_step * args.test_batch_size
):(test_step * args.test_batch_size) +
s.size(0)] = s
# Plot simulation data.
if args.valid_plot:
input_exc_weights = network.connections["X", "Y"].w
square_weights = get_square_weights(
input_exc_weights.view(784, args.n_neurons),
n_sqrt, 28)
spikes_ = {
layer: spikes[layer].get("s")[:, 0]
for layer in spikes
}
spike_ims, spike_axes = plot_spikes(spikes_,
ims=spike_ims,
axes=spike_axes)
weights_im = plot_weights(square_weights,
im=weights_im)
plt.pause(1e-8)
# Reset state variables.
network.reset_()
test_labels.extend(test_batch["label"].tolist())
t1 = time() - t0
writer.add_scalar(tag="time/test",
scalar_value=t1,
global_step=global_step)
# Convert the list of labels into a tensor.
test_label_tensor = torch.tensor(test_labels)
# Get network predictions.
all_activity_pred = all_activity(
spikes=test_spike_record,
assignments=assignments,
n_labels=n_classes,
)
proportion_pred = proportion_weighting(
spikes=test_spike_record,
assignments=assignments,
proportions=proportions,
n_labels=n_classes,
)
writer.add_scalar(
tag="accuracy/valid/all vote",
scalar_value=100 * torch.mean(
(test_label_tensor.long()
== all_activity_pred).float()),
global_step=global_step,
)
writer.add_scalar(
tag="accuracy/valid/proportion weighting",
scalar_value=100 * torch.mean(
(test_label_tensor.long() == proportion_pred).float()),
global_step=global_step,
)
square_weights = get_square_weights(
network.connections["X", "Y"].w.view(784, args.n_neurons),
n_sqrt,
28,
)
img_tensor = colorize(square_weights, cmap="hot_r")
writer.add_image(
tag="weights",
img_tensor=img_tensor,
global_step=global_step,
dataformats="HWC",
)
# Convert the array of labels into a tensor
label_tensor = torch.tensor(labels)
# Get network predictions.
all_activity_pred = all_activity(spikes=spike_record,
assignments=assignments,
n_labels=n_classes)
proportion_pred = proportion_weighting(
spikes=spike_record,
assignments=assignments,
proportions=proportions,
n_labels=n_classes,
)
writer.add_scalar(
tag="accuracy/train/all vote",
scalar_value=100 * torch.mean(
(label_tensor.long() == all_activity_pred).float()),
global_step=global_step,
)
writer.add_scalar(
tag="accuracy/train/proportion weighting",
scalar_value=100 * torch.mean(
(label_tensor.long() == proportion_pred).float()),
global_step=global_step,
)
# Assign labels to excitatory layer neurons.
assignments, proportions, rates = assign_labels(
spikes=spike_record,
labels=label_tensor,
n_labels=n_classes,
rates=rates,
)
# Re-enable learning.
network.train(True)
labels = []
labels.extend(batch["label"].tolist())
# Prep next input batch.
inpts = {"X": batch["encoded_image"]}
if args.gpu:
inpts = {k: v.cuda() for k, v in inpts.items()}
# Run the network on the input (training mode).
t0 = time()
network.run(inpts=inpts, time=args.time, one_step=args.one_step)
t1 = time() - t0
writer.add_scalar(tag="time/train/step",
scalar_value=t1,
global_step=global_step)
# Add to spikes recording.
s = spikes["Y"].get("s").permute((1, 0, 2))
spike_record[(step * args.batch_size) %
update_interval:(step * args.batch_size %
update_interval) + s.size(0)] = s
# Plot simulation data.
if args.plot:
input_exc_weights = network.connections["X", "Y"].w
square_weights = get_square_weights(
input_exc_weights.view(784, args.n_neurons), n_sqrt, 28)
spikes_ = {
layer: spikes[layer].get("s")[:, 0]
for layer in spikes
}
spike_ims, spike_axes = plot_spikes(spikes_,
ims=spike_ims,
axes=spike_axes)
weights_im = plot_weights(square_weights, im=weights_im)
plt.pause(1e-8)
# Reset state variables.
network.reset_()
def train(self, config=None):
if config is None:
cfg = self.cfg
update_interval = cfg['update_interval']
time = cfg['time']
n_neurons = cfg['network']['n_neurons']
dataset, n_classes = self._init_dataset(cfg)
# Record spikes during the simulation
spike_record = torch.zeros(update_interval, time, n_neurons)
# Neuron assignments and spike proportions
assignments = -torch.ones(n_neurons)
proportions = torch.zeros(n_neurons, n_classes)
rates = torch.zeros(n_neurons, n_classes)
# Sequence of accuracy estimates
accuracy = {"all": [], "proportion": []}
# Set up monitors for spikes and voltages
exc_voltage_monitor, inh_voltage_monitor, spikes, voltages = self._init_network_monitor(
self.network, cfg)
inpt_ims, inpt_axes = None, None
spike_ims, spike_axes = None, None
weights_im = None
assigns_im = None
perf_ax = None
voltage_axes, voltage_ims = None, None
print("\nBegin training.\n")
iteration = 0
for epoch in range(cfg['epochs']):
print("Progress: %d / %d" % (epoch, cfg['epochs']))
labels = []
start_time = T.time()
dataloader = DataLoader(dataset,
batch_size=1,
shuffle=True,
num_workers=cfg['n_workers'])
for step, batch in enumerate(tqdm(dataloader)):
# Get next input sample.
inputs = {'X': batch["encoded_image"].view(time, 1, 1, 28, 28)}
inputs = {k: v.to(self.device) for k, v in inputs.items()}
if step % update_interval == 0 and step > 0:
# Convert the array of labels into a tensor
label_tensor = torch.tensor(labels)
# Get network predictions.
all_activity_pred = all_activity(spikes=spike_record,
assignments=assignments,
n_labels=n_classes)
proportion_pred = proportion_weighting(
spikes=spike_record,
assignments=assignments,
proportions=proportions,
n_labels=n_classes,
)
# Compute network accuracy according to available classification strategies.
accuracy["all"].append(100 * torch.sum(
label_tensor.long() == all_activity_pred).item() /
len(label_tensor))
accuracy["proportion"].append(100 * torch.sum(
label_tensor.long() == proportion_pred).item() /
len(label_tensor))
iteration += len(label_tensor)
print(
"\nAll activity accuracy: %.2f (last), %.2f (average), %.2f (best)"
% (
accuracy["all"][-1],
np.mean(accuracy["all"]),
np.max(accuracy["all"]),
))
print(
"Proportion weighting accuracy: %.2f (last), %.2f (average), %.2f (best)\n"
% (
accuracy["proportion"][-1],
np.mean(accuracy["proportion"]),
np.max(accuracy["proportion"]),
))
self.recorder.insert(
(iteration, accuracy["all"][-1],
np.mean(accuracy["all"]), np.max(accuracy["all"]),
accuracy["proportion"][-1],
np.mean(accuracy["proportion"]),
np.max(accuracy["proportion"])))
assignments, proportions, rates = assign_labels(
spikes=spike_record,
labels=label_tensor,
n_labels=n_classes,
rates=rates,
)
labels = []
labels.append(batch["label"])
# Run the network on the input.
self.network.run(inputs=inputs, time=time, input_time_dim=1)
# Get voltage recording.
exc_voltages = exc_voltage_monitor.get("v")
inh_voltages = inh_voltage_monitor.get("v")
# Add to spikes recording.
spike_record[step % update_interval] = spikes["Ae"].get(
"s").squeeze()
# Reset state variables
self.network.reset_state_variables()
if step % 1000 == 0:
self.save(cfg=cfg)
print("Progress: %d / %d (%.4f seconds)" %
(epoch + 1, cfg['epochs'], T.time() - start_time))
self.recorder.write(self.save_dir, cfg['name'])
print("Training complete.\n")
return None
def main(seed=0, n_train=60000, n_test=10000, kernel_size=(8,), kernel_size2=(4,), stride=(4,), stride2=(2,),
n_filters=25, n_filters2=25, padding=0, inhib=100, time=100, lr=1e-3, lr_decay=0.99, dt=1, intensity=1,
progress_interval=10, update_interval=250, plot=False, train=True, gpu=False):
assert n_train % update_interval == 0 and n_test % update_interval == 0, \
'No. examples must be divisible by update_interval'
params = [
seed, n_train, kernel_size, kernel_size2, stride, stride2, n_filters, n_filters2,
padding, inhib, time, lr, lr_decay, dt, intensity, update_interval
]
model_name = '_'.join([str(x) for x in params])
if not train:
test_params = [
seed, n_train, n_test, kernel_size, kernel_size2, stride, stride2,
n_filters, n_filters2, padding, inhib, time, lr, lr_decay, dt, intensity, update_interval
]
np.random.seed(seed)
if gpu:
torch.set_default_tensor_type('torch.cuda.FloatTensor')
torch.cuda.manual_seed_all(seed)
else:
torch.manual_seed(seed)
n_examples = n_train if train else n_test
input_shape = [28, 28]
if kernel_size == input_shape:
conv_size = [1, 1]
else:
conv_size = (
int((input_shape[0] - kernel_size[0]) / stride[0]) + 1,
int((input_shape[1] - kernel_size[1]) / stride[1]) + 1
)
if kernel_size2 == conv_size:
conv_size2 = [1, 1]
else:
conv_size2 = (
int((conv_size[0] - kernel_size2[0]) / stride2[0]) + 1,
int((conv_size[1] - kernel_size2[1]) / stride2[1]) + 1
)
n_classes = 10
total_kernel_size = int(np.prod(kernel_size))
total_conv_size = int(np.prod(conv_size))
n_neurons = n_filters * total_conv_size
total_kernel_size2 = int(np.prod(kernel_size2))
total_conv_size2 = int(np.prod(conv_size2))
n_neurons2 = n_filters2 * total_conv_size2
# Build network.
if train:
network = Network()
input_layer = Input(n=784, shape=(1, 1, 28, 28), traces=True)
conv_layer = DiehlAndCookNodes(
n=n_neurons, shape=(1, n_filters, *conv_size), thresh=-64.0,
traces=True, theta_plus=0.05, refrac=0
)
conv_layer_prime = LIFNodes(
n=n_neurons, shape=(1, n_filters, *conv_size), refrac=0, traces=True
)
conv_conn = Conv2dConnection(
input_layer, conv_layer, kernel_size=kernel_size, stride=stride, update_rule=PostPre,
norm=0.5 * int(np.sqrt(total_kernel_size)), nu=[0, lr], wmax=2.0
)
conv_conn_prime = Conv2dConnection(
input_layer, conv_layer_prime, w=conv_conn.w,
kernel_size=kernel_size, stride=stride, nu=[0, 0], wmax=2.0
)
w = torch.zeros(
n_filters, conv_size[0], conv_size[1], n_filters, conv_size[0], conv_size[1]
)
for f1 in range(n_filters):
for f2 in range(n_filters):
if f1 != f2:
for i in range(conv_size[0]):
for j in range(conv_size[1]):
w[f1, i, j, f2, i, j] = -inhib
w = w.view(n_neurons, n_neurons)
recurrent_conn = Connection(conv_layer, conv_layer, w=w)
conv_layer2 = DiehlAndCookNodes(
n=n_neurons2, shape=(1, n_filters2, *conv_size2),
thresh=-64.0, traces=True, theta_plus=0.05, refrac=0
)
conv_layer2_prime = LIFNodes(
n=n_neurons2, shape=(1, n_filters2, *conv_size2), refrac=0
)
conv_conn2 = Conv2dConnection(
conv_layer_prime, conv_layer2, kernel_size=kernel_size2, stride=stride2, update_rule=PostPre,
norm=0.25 * int(np.sqrt(total_kernel_size2)), nu=[0, 10 * lr], wmax=2.0
)
conv_conn2_prime = Conv2dConnection(
conv_layer_prime, conv_layer2_prime, w=conv_conn2.w,
kernel_size=kernel_size2, stride=stride2, nu=[0, 0], wmax=2.0
)
w = torch.zeros(
n_filters2, conv_size2[0], conv_size2[1], n_filters2, conv_size2[0], conv_size2[1]
)
for f1 in range(n_filters2):
for f2 in range(n_filters2):
if f1 != f2:
for i in range(conv_size2[0]):
for j in range(conv_size2[1]):
w[f1, i, j, f2, i, j] = -inhib
w = w.view(n_neurons2, n_neurons2)
recurrent_conn2 = Connection(conv_layer2, conv_layer2, w=w)
network.add_layer(input_layer, name='X')
network.add_layer(conv_layer, name='Y')
network.add_layer(conv_layer_prime, name='Y_')
network.add_layer(conv_layer2, name='Z')
network.add_layer(conv_layer2_prime, name='Z_')
network.add_connection(conv_conn, source='X', target='Y')
network.add_connection(conv_conn_prime, source='X', target='Y_')
network.add_connection(recurrent_conn, source='Y', target='Y')
network.add_connection(conv_conn2, source='Y_', target='Z')
network.add_connection(conv_conn2_prime, source='Y_', target='Z_')
network.add_connection(recurrent_conn2, source='Z', target='Z')
# Voltage recording for excitatory and inhibitory layers.
voltage_monitor = Monitor(network.layers['Y'], ['v'], time=time)
network.add_monitor(voltage_monitor, name='output_voltage')
else:
network = load_network(os.path.join(params_path, model_name + '.pt'))
for connection in network.connections.values():
connection.update_rule = NoOp(connection, connection.nu)
connection.theta_decay = 0
connection.theta_plus = 0
# Load MNIST data.
dataset = MNIST(data_path, download=True)
if train:
images, labels = dataset.get_train()
else:
images, labels = dataset.get_test()
images *= intensity
# Record spikes during the simulation.
spike_record = torch.zeros(update_interval, time, n_neurons2)
# Neuron assignments and spike proportions.
if train:
assignments = -torch.ones_like(torch.Tensor(n_neurons2))
proportions = torch.zeros_like(torch.Tensor(n_neurons2, n_classes))
rates = torch.zeros_like(torch.Tensor(n_neurons2, n_classes))
logreg_model = LogisticRegression(warm_start=True, n_jobs=-1, solver='lbfgs')
logreg_model.coef_ = np.zeros([n_classes, n_neurons2])
logreg_model.intercept_ = np.zeros(n_classes)
logreg_model.classes_ = np.arange(n_classes)
else:
path = os.path.join(params_path, '_'.join(['auxiliary', model_name]) + '.pt')
assignments, proportions, rates, logreg_coef, logreg_intercept = torch.load(open(path, 'rb'))
logreg_model = LogisticRegression(warm_start=True, n_jobs=-1, solver='lbfgs')
logreg_model.coef_ = logreg_coef
logreg_model.intercept_ = logreg_intercept
logreg_model.classes_ = np.arange(n_classes)
# Sequence of accuracy estimates.
curves = {'all': [], 'proportion': [], 'logreg': []}
predictions = {
scheme: torch.Tensor().long() for scheme in curves.keys()
}
if train:
best_accuracy = 0
spikes = {}
for layer in set(network.layers):
spikes[layer] = Monitor(network.layers[layer], state_vars=['s'], time=time)
network.add_monitor(spikes[layer], name='%s_spikes' % layer)
# Train the network.
if train:
print('\nBegin training.\n')
else:
print('\nBegin test.\n')
inpt_ims = None
inpt_axes = None
spike_ims = None
spike_axes = None
weights_im = None
weights_im2 = None
start = t()
for i in range(n_examples):
if i % progress_interval == 0:
print('Progress: %d / %d (%.4f seconds)' % (i, n_examples, t() - start))
start = t()
if i % update_interval == 0 and i > 0:
network.connections['X', 'Y'].update_rule.nu[1] *= lr_decay
network.connections['Y_', 'Z'].update_rule.nu[1] *= lr_decay
if i % len(labels) == 0:
current_labels = labels[-update_interval:]
else:
current_labels = labels[i % len(images) - update_interval:i % len(images)]
# Update and print accuracy evaluations.
curves, preds = update_curves(
curves, current_labels, n_classes, spike_record=spike_record, assignments=assignments,
proportions=proportions, logreg=logreg_model
)
print_results(curves)
for scheme in preds:
predictions[scheme] = torch.cat([predictions[scheme], preds[scheme]], -1)
# Save accuracy curves to disk.
to_write = ['train'] + params if train else ['test'] + params
f = '_'.join([str(x) for x in to_write]) + '.pt'
torch.save((curves, update_interval, n_examples), open(os.path.join(curves_path, f), 'wb'))
if train:
if any([x[-1] > best_accuracy for x in curves.values()]):
print('New best accuracy! Saving network parameters to disk.')
# Save network to disk.
network.save(os.path.join(params_path, model_name + '.pt'))
path = os.path.join(params_path, '_'.join(['auxiliary', model_name]) + '.pt')
torch.save(
(
assignments, proportions, rates, logreg_model.coef_, logreg_model.intercept_
), open(path, 'wb')
)
best_accuracy = max([x[-1] for x in curves.values()])
# Assign labels to excitatory layer neurons.
assignments, proportions, rates = assign_labels(spike_record, current_labels, n_classes, rates)
# Refit logistic regression model.
logreg_model = logreg_fit(spike_record, current_labels, logreg_model)
print()
# Get next input sample.
image = images[i % len(images)]
sample = bernoulli(datum=image, time=time, dt=dt, max_prob=0.5).unsqueeze(1).unsqueeze(1)
inpts = {'X': sample}
# Run the network on the input.
network.run(inpts=inpts, time=time)
retries = 0
while spikes['Z_'].get('s').sum() < 5 and retries < 3:
retries += 1
sample = bernoulli(datum=image, time=time, dt=dt, max_prob=0.5 + retries * 0.15).unsqueeze(1).unsqueeze(1)
inpts = {'X': sample}
network.run(inpts=inpts, time=time)
# Add to spikes recording.
spike_record[i % update_interval] = spikes['Z_'].get('s').view(time, -1)
# Optionally plot various simulation information.
if plot:
_input = inpts['X'].view(time, 784).sum(0).view(28, 28)
w = network.connections['X', 'Y'].w
w2 = network.connections['Y_', 'Z'].w
_spikes = {
'X': spikes['X'].get('s').view(28 ** 2, time),
'Y': spikes['Y'].get('s').view(n_neurons, time),
'Y_': spikes['Y_'].get('s').view(n_neurons, time),
'Z': spikes['Z'].get('s').view(n_neurons2, time),
'Z_': spikes['Z_'].get('s').view(n_neurons2, time)
}
inpt_axes, inpt_ims = plot_input(
image.view(28, 28), _input, label=labels[i], ims=inpt_ims, axes=inpt_axes
)
spike_ims, spike_axes = plot_spikes(spikes=_spikes, ims=spike_ims, axes=spike_axes)
weights_im = plot_conv2d_weights(w, im=weights_im, wmax=0.2)
weights_im2 = plot_conv2d_weights(w2, im=weights_im2, wmax=0.2)
plt.pause(1e-8)
network.reset_() # Reset state variables.
print(f'Progress: {n_examples} / {n_examples} ({t() - start:.4f} seconds)')
i += 1
if i % len(labels) == 0:
current_labels = labels[-update_interval:]
else:
current_labels = labels[i % len(images) - update_interval:i % len(images)]
# Update and print accuracy evaluations.
curves, preds = update_curves(
curves, current_labels, n_classes, spike_record=spike_record, assignments=assignments,
proportions=proportions, logreg=logreg_model
)
print_results(curves)
for scheme in preds:
predictions[scheme] = torch.cat([predictions[scheme], preds[scheme]], -1)
if train:
if any([x[-1] > best_accuracy for x in curves.values()]):
print('New best accuracy! Saving network parameters to disk.')
# Save network to disk.
network.save(os.path.join(params_path, model_name + '.pt'))
path = os.path.join(params_path, '_'.join(['auxiliary', model_name]) + '.pt')
torch.save(
(
assignments, proportions, rates, logreg_model.coef_, logreg_model.intercept_
), open(path, 'wb')
)
if train:
print('\nTraining complete.\n')
else:
print('\nTest complete.\n')
print('Average accuracies:\n')
for scheme in curves.keys():
print('\t%s: %.2f' % (scheme, float(np.mean(curves[scheme]))))
# Save accuracy curves to disk.
to_write = ['train'] + params if train else ['test'] + params
to_write = [str(x) for x in to_write]
f = '_'.join(to_write) + '.pt'
torch.save((curves, update_interval, n_examples), open(os.path.join(curves_path, f), 'wb'))
# Save results to disk.
results = [
np.mean(curves['all']), np.mean(curves['proportion']), np.mean(curves['logreg']),
np.max(curves['all']), np.max(curves['proportion']), np.max(curves['logreg'])
]
to_write = params + results if train else test_params + results
to_write = [str(x) for x in to_write]
name = 'train.csv' if train else 'test.csv'
if not os.path.isfile(os.path.join(results_path, name)):
with open(os.path.join(results_path, name), 'w') as f:
if train:
columns = [
'seed', 'n_train', 'kernel_size', 'stride', 'n_filters', 'n_filters2', 'padding', 'inhib', 'time',
'lr', 'lr_decay', 'dt', 'intensity', 'update_interval', 'mean_all_activity',
'mean_proportion_weighting', 'mean_logreg', 'max_all_activity', 'max_proportion_weighting',
'max_logreg'
]
header = ','.join(columns) + '\n'
f.write(header)
else:
columns = [
'seed', 'n_train', 'n_test', 'kernel_size', 'stride', 'n_filters', 'n_filters2', 'padding',
'inhib', 'time', 'lr', 'lr_decay', 'dt', 'intensity', 'update_interval', 'mean_all_activity',
'mean_proportion_weighting', 'mean_logreg', 'max_all_activity', 'max_proportion_weighting',
'max_logreg'
]
header = ','.join(columns) + '\n'
f.write(header)
with open(os.path.join(results_path, name), 'a') as f:
f.write(','.join(to_write) + '\n')
if labels.numel() > n_examples:
labels = labels[:n_examples]
else:
while labels.numel() < n_examples:
if 2 * labels.numel() > n_examples:
labels = torch.cat([labels, labels[:n_examples - labels.numel()]])
else:
labels = torch.cat([labels, labels])
# Compute confusion matrices and save them to disk.
confusions = {}
for scheme in predictions:
confusions[scheme] = confusion_matrix(labels, predictions[scheme])
to_write = ['train'] + params if train else ['test'] + test_params
f = '_'.join([str(x) for x in to_write]) + '.pt'
torch.save(confusions, os.path.join(confusion_path, f))
def main(seed=0,
n_neurons=100,
n_train=60000,
n_test=10000,
c_low=2.5,
c_high=250,
p_low=0.1,
time=250,
dt=1,
theta_plus=0.05,
theta_decay=1e-7,
intensity=1,
progress_interval=10,
update_interval=250,
plot=False,
train=True,
gpu=False):
assert n_train % update_interval == 0 and n_test % update_interval == 0,\
'No. examples must be divisible by update_interval'
params = [
seed, n_neurons, n_train, c_low, c_high, p_low, time, dt, theta_plus,
theta_decay, intensity, progress_interval, update_interval
]
model_name = '_'.join([str(x) for x in params])
if not train:
test_params = [
seed, n_neurons, n_train, n_test, c_low, c_high, p_low, time, dt,
theta_plus, theta_decay, intensity, progress_interval,
update_interval
]
np.random.seed(seed)
if gpu:
torch.set_default_tensor_type('torch.cuda.FloatTensor')
torch.cuda.manual_seed_all(seed)
else:
torch.manual_seed(seed)
n_examples = n_train if train else n_test
n_sqrt = int(np.ceil(np.sqrt(n_neurons)))
n_classes = 10
if train:
iter_increase = int(n_train * p_low)
print(f'Iteration to increase from c_low to c_high: {iter_increase}\n')
# Build network.
if train:
network = Network(dt=dt)
input_layer = Input(n=784, traces=True)
exc_layer = DiehlAndCookNodes(n=n_neurons, traces=True)
w = torch.rand(input_layer.n, exc_layer.n)
input_exc_conn = Connection(input_layer,
exc_layer,
w=w,
update_rule=PostPre,
norm=78.4,
nu=(1e-4, 1e-2),
wmax=1.0)
w = torch.zeros(exc_layer.n, exc_layer.n)
for k1 in range(n_neurons):
for k2 in range(n_neurons):
if k1 != k2:
x1, y1 = k1 // np.sqrt(n_neurons), k1 % np.sqrt(n_neurons)
x2, y2 = k2 // np.sqrt(n_neurons), k2 % np.sqrt(n_neurons)
w[k1, k2] = max(
-c_high,
-c_low * np.sqrt(euclidean([x1, y1], [x2, y2])))
recurrent_conn = Connection(exc_layer, exc_layer, w=w)
network.add_layer(input_layer, name='X')
network.add_layer(exc_layer, name='Y')
network.add_connection(input_exc_conn, source='X', target='Y')
network.add_connection(recurrent_conn, source='Y', target='Y')
else:
network = load_network(os.path.join(params_path, model_name + '.pt'))
network.connections['X', 'Y'].update_rule = NoOp(
connection=network.connections['X', 'Y'],
nu=network.connections['X', 'Y'].nu)
network.layers['Y'].theta_decay = 0
network.layers['Y'].theta_plus = 0
# Load MNIST data.
dataset = MNIST(data_path, download=True)
if train:
images, labels = dataset.get_train()
else:
images, labels = dataset.get_test()
images = images.view(-1, 784)
images *= intensity
# Record spikes during the simulation.
spike_record = torch.zeros(update_interval, int(time / dt), n_neurons)
# Neuron assignments and spike proportions.
if train:
assignments = -torch.ones_like(torch.Tensor(n_neurons))
proportions = torch.zeros_like(torch.Tensor(n_neurons, 10))
rates = torch.zeros_like(torch.Tensor(n_neurons, 10))
ngram_scores = {}
else:
path = os.path.join(params_path,
'_'.join(['auxiliary', model_name]) + '.pt')
assignments, proportions, rates, ngram_scores = torch.load(
open(path, 'rb'))
# Sequence of accuracy estimates.
curves = {'all': [], 'proportion': [], 'ngram': []}
predictions = {scheme: torch.Tensor().long() for scheme in curves.keys()}
if train:
best_accuracy = 0
spikes = {}
for layer in set(network.layers) - {'X'}:
spikes[layer] = Monitor(network.layers[layer],
state_vars=['s'],
time=int(time / dt))
network.add_monitor(spikes[layer], name='%s_spikes' % layer)
# Train the network.
if train:
print('\nBegin training.\n')
else:
print('\nBegin test.\n')
inpt_axes = None
inpt_ims = None
spike_ims = None
spike_axes = None
weights_im = None
assigns_im = None
perf_ax = None
start = t()
for i in range(n_examples):
if train and i == iter_increase:
print(
'\nChanging inhibition from low and graded to high and constant.\n'
)
w = -c_high * (torch.ones(n_neurons, n_neurons) -
torch.diag(torch.ones(n_neurons)))
network.connections['Y', 'Y'].w = w
if i % progress_interval == 0:
print(f'Progress: {i} / {n_examples} ({t() - start:.4f} seconds)')
start = t()
if i % update_interval == 0 and i > 0:
if i % len(labels) == 0:
current_labels = labels[-update_interval:]
else:
current_labels = labels[i % len(images) - update_interval:i %
len(images)]
# Update and print accuracy evaluations.
curves, preds = update_curves(curves,
current_labels,
n_classes,
spike_record=spike_record,
assignments=assignments,
proportions=proportions,
ngram_scores=ngram_scores,
n=2)
print_results(curves)
for scheme in preds:
predictions[scheme] = torch.cat(
[predictions[scheme], preds[scheme]], -1)
# Save accuracy curves to disk.
to_write = ['train'] + params if train else ['test'] + params
f = '_'.join([str(x) for x in to_write]) + '.pt'
torch.save((curves, update_interval, n_examples),
open(os.path.join(curves_path, f), 'wb'))
if train:
if any([x[-1] > best_accuracy for x in curves.values()]):
print(
'New best accuracy! Saving network parameters to disk.'
)
# Save network to disk.
network.save(os.path.join(params_path, model_name + '.pt'))
path = os.path.join(
params_path,
'_'.join(['auxiliary', model_name]) + '.pt')
torch.save((assignments, proportions, rates, ngram_scores),
open(path, 'wb'))
best_accuracy = max([x[-1] for x in curves.values()])
# Assign labels to excitatory layer neurons.
assignments, proportions, rates = assign_labels(
spike_record, labels[i - update_interval:i], 10, rates)
# Compute ngram scores.
ngram_scores = update_ngram_scores(
spike_record, labels[i - update_interval:i], 10, 2,
ngram_scores)
print()
# Get next input sample.
image = images[i]
sample = poisson(datum=image, time=int(time / dt))
inpts = {'X': sample}
# Run the network on the input.
network.run(inpts=inpts, time=time)
retries = 0
while spikes['Y'].get('s').sum() < 5 and retries < 3:
retries += 1
image *= 2
sample = poisson(datum=image, time=int(time / dt))
inpts = {'X': sample}
network.run(inpts=inpts, time=time)
# Add to spikes recording.
spike_record[i % update_interval] = spikes['Y'].get('s').t()
# Optionally plot various simulation information.
if plot:
inpt = inpts['X'].view(time, 784).sum(0).view(28, 28)
_spikes = {layer: spikes[layer].get('s') for layer in spikes}
input_exc_weights = network.connections['X', 'Y'].w
square_weights = get_square_weights(
input_exc_weights.view(784, n_neurons), n_sqrt, 28)
square_assignments = get_square_assignments(assignments, n_sqrt)
# inpt_axes, inpt_ims = plot_input(images[i].view(28, 28), inpt, label=labels[i], axes=inpt_axes, ims=inpt_ims)
spike_ims, spike_axes = plot_spikes(_spikes,
ims=spike_ims,
axes=spike_axes)
weights_im = plot_weights(square_weights, im=weights_im)
# assigns_im = plot_assignments(square_assignments, im=assigns_im)
# perf_ax = plot_performance(curves, ax=perf_ax)
plt.pause(1e-8)
network.reset_() # Reset state variables.
print(f'Progress: {n_examples} / {n_examples} ({t() - start:.4f} seconds)')
i += 1
if i % len(labels) == 0:
current_labels = labels[-update_interval:]
else:
current_labels = labels[i % len(images) - update_interval:i %
len(images)]
# Update and print accuracy evaluations.
curves, preds = update_curves(curves,
current_labels,
n_classes,
spike_record=spike_record,
assignments=assignments,
proportions=proportions,
ngram_scores=ngram_scores,
n=2)
print_results(curves)
for scheme in preds:
predictions[scheme] = torch.cat([predictions[scheme], preds[scheme]],
-1)
if train:
if any([x[-1] > best_accuracy for x in curves.values()]):
print('New best accuracy! Saving network parameters to disk.')
# Save network to disk.
network.save(os.path.join(params_path, model_name + '.pt'))
path = os.path.join(params_path,
'_'.join(['auxiliary', model_name]) + '.pt')
torch.save((assignments, proportions, rates, ngram_scores),
open(path, 'wb'))
if train:
print('\nTraining complete.\n')
else:
print('\nTest complete.\n')
print('Average accuracies:\n')
for scheme in curves.keys():
print(f'\t%s: %.2f' % (scheme, float(np.mean(curves[scheme]))))
# Save accuracy curves to disk.
to_write = ['train'] + params if train else ['test'] + params
to_write = [str(x) for x in to_write]
f = '_'.join(to_write) + '.pt'
torch.save((curves, update_interval, n_examples),
open(os.path.join(curves_path, f), 'wb'))
results = [
np.mean(curves['all']),
np.mean(curves['proportion']),
np.mean(curves['ngram']),
np.max(curves['all']),
np.max(curves['proportion']),
np.max(curves['ngram'])
]
to_write = params + results if train else test_params + results
to_write = [str(x) for x in to_write]
name = 'train.csv' if train else 'test.csv'
if not os.path.isfile(os.path.join(results_path, name)):
with open(os.path.join(results_path, name), 'w') as f:
if train:
f.write(
'random_seed,n_neurons,n_train,excite,inhib,time,timestep,theta_plus,theta_decay,'
'intensity,progress_interval,update_interval,mean_all_activity,mean_proportion_weighting,'
'mean_ngram,max_all_activity,max_proportion_weighting,max_ngram\n'
)
else:
f.write(
'random_seed,n_neurons,n_train,n_test,excite,inhib,time,timestep,theta_plus,theta_decay,'
'intensity,progress_interval,update_interval,mean_all_activity,mean_proportion_weighting,'
'mean_ngram,max_all_activity,max_proportion_weighting,max_ngram\n'
)
with open(os.path.join(results_path, name), 'a') as f:
f.write(','.join(to_write) + '\n')
if labels.numel() > n_examples:
labels = labels[:n_examples]
else:
while labels.numel() < n_examples:
if 2 * labels.numel() > n_examples:
labels = torch.cat(
[labels, labels[:n_examples - labels.numel()]])
else:
labels = torch.cat([labels, labels])
# Compute confusion matrices and save them to disk.
confusions = {}
for scheme in predictions:
confusions[scheme] = confusion_matrix(labels, predictions[scheme])
to_write = ['train'] + params if train else ['test'] + test_params
f = '_'.join([str(x) for x in to_write]) + '.pt'
torch.save(confusions, os.path.join(confusion_path, f))
print()
def main(seed=0,
n_train=60000,
n_test=10000,
inhib=250,
kernel_size=(16, ),
stride=(2, ),
time=50,
n_filters=25,
crop=0,
lr=1e-2,
lr_decay=0.99,
dt=1,
theta_plus=0.05,
theta_decay=1e-7,
norm=0.2,
progress_interval=10,
update_interval=250,
train=True,
relabel=False,
plot=False,
gpu=False):
assert n_train % update_interval == 0 and n_test % update_interval == 0 or relabel, \
'No. examples must be divisible by update_interval'
params = [
seed, kernel_size, stride, n_filters, crop, lr, lr_decay, n_train,
inhib, time, dt, theta_plus, theta_decay, norm, progress_interval,
update_interval
]
model_name = '_'.join([str(x) for x in params])
if not train:
test_params = [
seed, kernel_size, stride, n_filters, crop, lr, lr_decay, n_train,
n_test, inhib, time, dt, theta_plus, theta_decay, norm,
progress_interval, update_interval
]
np.random.seed(seed)
if gpu:
torch.set_default_tensor_type('torch.cuda.FloatTensor')
torch.cuda.manual_seed_all(seed)
else:
torch.manual_seed(seed)
side_length = 28 - crop * 2
n_inpt = side_length**2
n_examples = n_train if train else n_test
n_classes = 10
# Build network.
if train:
network = LocallyConnectedNetwork(
n_inpt=n_inpt,
input_shape=[side_length, side_length],
kernel_size=kernel_size,
stride=stride,
n_filters=n_filters,
inh=inhib,
dt=dt,
nu=[.1 * lr, lr],
theta_plus=theta_plus,
theta_decay=theta_decay,
wmin=0,
wmax=1.0,
norm=norm)
network.layers['Y'].thresh = 1
network.layers['Y'].reset = 0
network.layers['Y'].rest = 0
else:
network = load_network(os.path.join(params_path, model_name + '.pt'))
network.connections['X', 'Y'].update_rule = NoOp(
connection=network.connections['X', 'Y'],
nu=network.connections['X', 'Y'].nu)
network.layers['Y'].theta_decay = 0
network.layers['Y'].theta_plus = 0
conv_size = network.connections['X', 'Y'].conv_size
locations = network.connections['X', 'Y'].locations
conv_prod = int(np.prod(conv_size))
n_neurons = n_filters * conv_prod
# Voltage recording for excitatory and inhibitory layers.
voltage_monitor = Monitor(network.layers['Y'], ['v'], time=time)
network.add_monitor(voltage_monitor, name='output_voltage')
# Load Fashion-MNIST data.
dataset = FashionMNIST(path=data_path, download=True)
if train:
images, labels = dataset.get_train()
else:
images, labels = dataset.get_test()
if crop != 0:
images = images[:, crop:-crop, crop:-crop]
# Record spikes during the simulation.
if not train:
update_interval = n_examples
spike_record = torch.zeros(update_interval, time, n_neurons)
# Neuron assignments and spike proportions.
if train:
assignments = -torch.ones_like(torch.Tensor(n_neurons))
proportions = torch.zeros_like(torch.Tensor(n_neurons, 10))
rates = torch.zeros_like(torch.Tensor(n_neurons, 10))
ngram_scores = {}
else:
path = os.path.join(params_path,
'_'.join(['auxiliary', model_name]) + '.pt')
assignments, proportions, rates, ngram_scores = torch.load(
open(path, 'rb'))
if train:
best_accuracy = 0
# Sequence of accuracy estimates.
curves = {'all': [], 'proportion': [], 'ngram': []}
predictions = {scheme: torch.Tensor().long() for scheme in curves.keys()}
spikes = {}
for layer in set(network.layers):
spikes[layer] = Monitor(network.layers[layer],
state_vars=['s'],
time=time)
network.add_monitor(spikes[layer], name=f'{layer}_spikes')
# Train the network.
if train:
print('\nBegin training.\n')
else:
print('\nBegin test.\n')
spike_ims = None
spike_axes = None
weights_im = None
start = t()
for i in range(n_examples):
if i % progress_interval == 0 and train:
network.connections['X', 'Y'].update_rule.nu[1] *= lr_decay
if i % progress_interval == 0:
print(f'Progress: {i} / {n_examples} ({t() - start:.4f} seconds)')
start = t()
if i % update_interval == 0 and i > 0:
if i % len(labels) == 0:
current_labels = labels[-update_interval:]
else:
current_labels = labels[i % len(images) - update_interval:i %
len(images)]
# Update and print accuracy evaluations.
curves, preds = update_curves(curves,
current_labels,
n_classes,
spike_record=spike_record,
assignments=assignments,
proportions=proportions,
ngram_scores=ngram_scores,
n=2)
print_results(curves)
for scheme in preds:
predictions[scheme] = torch.cat(
[predictions[scheme], preds[scheme]], -1)
# Save accuracy curves to disk.
to_write = ['train'] + params if train else ['test'] + params
f = '_'.join([str(x) for x in to_write]) + '.pt'
torch.save((curves, update_interval, n_examples),
open(os.path.join(curves_path, f), 'wb'))
if train:
if any([x[-1] > best_accuracy for x in curves.values()]):
print(
'New best accuracy! Saving network parameters to disk.'
)
# Save network to disk.
network.save(os.path.join(params_path, model_name + '.pt'))
path = os.path.join(
params_path,
'_'.join(['auxiliary', model_name]) + '.pt')
torch.save((assignments, proportions, rates, ngram_scores),
open(path, 'wb'))
best_accuracy = max([x[-1] for x in curves.values()])
# Assign labels to excitatory layer neurons.
assignments, proportions, rates = assign_labels(
spike_record, current_labels, n_classes, rates)
# Compute ngram scores.
ngram_scores = update_ngram_scores(spike_record,
current_labels, n_classes,
2, ngram_scores)
print()
# Get next input sample.
image = images[i % len(images)].contiguous().view(-1)
sample = poisson(datum=image, time=time, dt=dt)
inpts = {'X': sample}
# Run the network on the input.
network.run(inpts=inpts, time=time)
retries = 0
while spikes['Y'].get('s').sum() < 5 and retries < 3:
retries += 1
image *= 2
sample = poisson(datum=image, time=time, dt=dt)
inpts = {'X': sample}
network.run(inpts=inpts, time=time)
# Add to spikes recording.
spike_record[i % update_interval] = spikes['Y'].get('s').t()
# Optionally plot various simulation information.
if plot:
_spikes = {
'X': spikes['X'].get('s').view(side_length**2, time),
'Y': spikes['Y'].get('s').view(n_filters * conv_prod, time)
}
spike_ims, spike_axes = plot_spikes(spikes=_spikes,
ims=spike_ims,
axes=spike_axes)
weights_im = plot_locally_connected_weights(
network.connections['X', 'Y'].w,
n_filters,
kernel_size,
conv_size,
locations,
side_length,
im=weights_im,
wmin=0,
wmax=1)
plt.pause(1e-8)
network.reset_() # Reset state variables.
print(f'Progress: {n_examples} / {n_examples} ({t() - start:.4f} seconds)')
i += 1
if i % len(labels) == 0:
current_labels = labels[-update_interval:]
else:
current_labels = labels[i % len(images) - update_interval:i %
len(images)]
if not train and relabel:
# Assign labels to excitatory layer neurons.
assignments, proportions, rates = assign_labels(
spike_record, current_labels, n_classes, rates)
# Compute ngram scores.
ngram_scores = update_ngram_scores(spike_record, current_labels,
n_classes, 2, ngram_scores)
# Update and print accuracy evaluations.
curves, preds = update_curves(curves,
current_labels,
n_classes,
spike_record=spike_record,
assignments=assignments,
proportions=proportions,
ngram_scores=ngram_scores,
n=2)
print_results(curves)
for scheme in preds:
predictions[scheme] = torch.cat([predictions[scheme], preds[scheme]],
-1)
if train:
if any([x[-1] > best_accuracy for x in curves.values()]):
print('New best accuracy! Saving network parameters to disk.')
# Save network to disk.
network.save(os.path.join(params_path, model_name + '.pt'))
path = os.path.join(params_path,
'_'.join(['auxiliary', model_name]) + '.pt')
torch.save((assignments, proportions, rates, ngram_scores),
open(path, 'wb'))
if train:
print('\nTraining complete.\n')
else:
print('\nTest complete.\n')
print('Average accuracies:\n')
for scheme in curves.keys():
print('\t%s: %.2f' % (scheme, float(np.mean(curves[scheme]))))
# Save accuracy curves to disk.
to_write = ['train'] + params if train else ['test'] + params
f = '_'.join([str(x) for x in to_write]) + '.pt'
torch.save((curves, update_interval, n_examples),
open(os.path.join(curves_path, f), 'wb'))
# Save results to disk.
path = os.path.join('..', '..', 'results', data, model)
if not os.path.isdir(path):
os.makedirs(path)
results = [
np.mean(curves['all']),
np.mean(curves['proportion']),
np.mean(curves['ngram']),
np.max(curves['all']),
np.max(curves['proportion']),
np.max(curves['ngram'])
]
to_write = params + results if train else test_params + results
to_write = [str(x) for x in to_write]
name = 'train.csv' if train else 'test.csv'
if not os.path.isfile(os.path.join(results_path, name)):
with open(os.path.join(path, name), 'w') as f:
if train:
f.write(
'random_seed,kernel_size,stride,n_filters,crop,n_train,inhib,time,lr,lr_decay,timestep,theta_plus,'
'theta_decay,norm,progress_interval,update_interval,mean_all_activity,mean_proportion_weighting,'
'mean_ngram,max_all_activity,max_proportion_weighting,max_ngram\n'
)
else:
f.write(
'random_seed,kernel_size,stride,n_filters,crop,n_train,n_test,inhib,time,lr,lr_decay,timestep,'
'theta_plus,theta_decay,norm,progress_interval,update_interval,mean_all_activity,'
'mean_proportion_weighting,mean_ngram,max_all_activity,max_proportion_weighting,max_ngram\n'
)
with open(os.path.join(results_path, name), 'a') as f:
f.write(','.join(to_write) + '\n')
if labels.numel() > n_examples:
labels = labels[:n_examples]
else:
while labels.numel() < n_examples:
if 2 * labels.numel() > n_examples:
labels = torch.cat(
[labels, labels[:n_examples - labels.numel()]])
else:
labels = torch.cat([labels, labels])
# Compute confusion matrices and save them to disk.
confusions = {}
for scheme in predictions:
confusions[scheme] = confusion_matrix(labels, predictions[scheme])
to_write = ['train'] + params if train else ['test'] + test_params
f = '_'.join([str(x) for x in to_write]) + '.pt'
torch.save(confusions, os.path.join(confusion_path, f))
update_interval)
print(
"\nAll activity accuracy: %.2f (last), %.2f (average), %.2f (best)"
% (accuracy["all"][-1], np.mean(
accuracy["all"]), np.max(accuracy["all"])))
print(
"Proportion weighting accuracy: %.2f (last), %.2f (average), %.2f (best)\n"
% (
accuracy["proportion"][-1],
np.mean(accuracy["proportion"]),
np.max(accuracy["proportion"]),
))
# Assign labels to excitatory layer neurons.
assignments, proportions, rates = assign_labels(
spike_record, labels, num_classes, rates)
#Add the current label to the list of labels for this update_interval
labels[i % update_interval] = label[0]
# Run the network on the input.
choice = np.random.choice(int(n_neurons / num_classes),
size=n_clamp,
replace=False)
clamp = {"Ae": per_class * label.long() + torch.Tensor(choice).long()}
inputs = {"X": image.view(time, 1, 32, 32, 3)}
network.run(inputs=inputs, time=time, clamp=clamp)
# Get voltage recording.
exc_voltages = exc_voltage_monitor.get("v")
inh_voltages = inh_voltage_monitor.get("v")
accuracy["all"][-1],
np.mean(accuracy["all"]),
np.max(accuracy["all"]),
))
print(
"Proportion weighting accuracy: %.2f (last), %.2f (average), %.2f (best)\n"
% (
accuracy["proportion"][-1],
np.mean(accuracy["proportion"]),
np.max(accuracy["proportion"]),
))
# Assign labels to excitatory layer neurons.
assignments, proportions, rates = assign_labels(
spikes=spike_record,
labels=label_tensor,
n_labels=n_classes,
rates=rates,
)
labels = []
labels.extend(batch["label"].tolist())
# Run the network on the input.
network.run(inputs=inputs, time=time, input_time_dim=1)
# Add to spikes recording.
s = spikes["Ae"].get("s").permute((1, 0, 2))
spike_record[(step * batch_size) %
update_interval:(step * batch_size % update_interval) +
s.size(0)] = s
def main(seed=0,
n_neurons=100,
n_train=60000,
n_test=10000,
inhib=250,
time=50,
lr=1e-2,
lr_decay=0.99,
dt=1,
theta_plus=0.05,
theta_decay=1e-7,
progress_interval=10,
update_interval=250,
train=True,
plot=False,
gpu=False):
assert n_train % update_interval == 0 and n_test % update_interval == 0, \
'No. examples must be divisible by update_interval'
params = [
seed, n_neurons, n_train, inhib, time, lr, lr_decay, theta_plus,
theta_decay, progress_interval, update_interval
]
test_params = [
seed, n_neurons, n_train, n_test, inhib, time, lr, lr_decay,
theta_plus, theta_decay, progress_interval, update_interval
]
model_name = '_'.join([str(x) for x in params])
np.random.seed(seed)
if gpu:
torch.set_default_tensor_type('torch.cuda.FloatTensor')
torch.cuda.manual_seed_all(seed)
else:
torch.manual_seed(seed)
if train:
n_examples = n_train
else:
n_examples = n_test
n_sqrt = int(np.ceil(np.sqrt(n_neurons)))
n_classes = 10
# Build network.
if train:
network = Network(dt=dt)
input_layer = Input(n=784, traces=True, trace_tc=5e-2)
network.add_layer(input_layer, name='X')
output_layer = DiehlAndCookNodes(n=n_neurons,
traces=True,
rest=0,
reset=0,
thresh=1,
refrac=0,
decay=1e-2,
trace_tc=5e-2,
theta_plus=theta_plus,
theta_decay=theta_decay)
network.add_layer(output_layer, name='Y')
w = 0.3 * torch.rand(784, n_neurons)
input_connection = Connection(source=network.layers['X'],
target=network.layers['Y'],
w=w,
update_rule=PostPre,
nu=[0, lr],
wmin=0,
wmax=1,
norm=78.4)
network.add_connection(input_connection, source='X', target='Y')
w = -inhib * (torch.ones(n_neurons, n_neurons) -
torch.diag(torch.ones(n_neurons)))
recurrent_connection = Connection(source=network.layers['Y'],
target=network.layers['Y'],
w=w,
wmin=-inhib,
wmax=0)
network.add_connection(recurrent_connection, source='Y', target='Y')
else:
path = os.path.join('..', '..', 'params', data, model)
network = load_network(os.path.join(path, model_name + '.pt'))
network.connections['X', 'Y'].update_rule = NoOp(
connection=network.connections['X', 'Y'],
nu=network.connections['X', 'Y'].nu)
network.layers['Y'].theta_decay = 0
network.layers['Y'].theta_plus = 0
# Load Fashion-MNIST data.
dataset = FashionMNIST(path=os.path.join('..', '..', 'data',
'FashionMNIST'),
download=True)
if train:
images, labels = dataset.get_train()
else:
images, labels = dataset.get_test()
images = images.view(-1, 784)
images = images / 255
# if train:
# for i in range(n_neurons):
# network.connections['X', 'Y'].w[:, i] = images[i] + images[i].mean() * torch.randn(784)
# Record spikes during the simulation.
spike_record = torch.zeros(update_interval, time, n_neurons)
# Neuron assignments and spike proportions.
if train:
assignments = -torch.ones_like(torch.Tensor(n_neurons))
proportions = torch.zeros_like(torch.Tensor(n_neurons, n_classes))
rates = torch.zeros_like(torch.Tensor(n_neurons, n_classes))
ngram_scores = {}
else:
path = os.path.join('..', '..', 'params', data, model)
path = os.path.join(path, '_'.join(['auxiliary', model_name]) + '.pt')
assignments, proportions, rates, ngram_scores = torch.load(
open(path, 'rb'))
# Sequence of accuracy estimates.
curves = {'all': [], 'proportion': [], 'ngram': []}
if train:
best_accuracy = 0
spikes = {}
for layer in set(network.layers):
spikes[layer] = Monitor(network.layers[layer],
state_vars=['s'],
time=time)
network.add_monitor(spikes[layer], name='%s_spikes' % layer)
# Train the network.
if train:
print('\nBegin training.\n')
else:
print('\nBegin test.\n')
inpt_axes = None
inpt_ims = None
spike_ims = None
spike_axes = None
weights_im = None
assigns_im = None
perf_ax = None
start = t()
for i in range(n_examples):
if i % progress_interval == 0 and train:
network.connections['X', 'Y'].update_rule.nu[1] *= lr_decay
if i % progress_interval == 0:
print(f'Progress: {i} / {n_examples} ({t() - start:.4f} seconds)')
start = t()
if i % update_interval == 0 and i > 0:
if i % len(labels) == 0:
current_labels = labels[-update_interval:]
else:
current_labels = labels[i % len(images) - update_interval:i %
len(images)]
# Update and print accuracy evaluations.
curves, predictions = update_curves(curves,
current_labels,
n_classes,
spike_record=spike_record,
assignments=assignments,
proportions=proportions,
ngram_scores=ngram_scores,
n=2)
print_results(curves)
if train:
if any([x[-1] > best_accuracy for x in curves.values()]):
print(
'New best accuracy! Saving network parameters to disk.'
)
# Save network to disk.
path = os.path.join('..', '..', 'params', data, model)
if not os.path.isdir(path):
os.makedirs(path)
network.save(os.path.join(path, model_name + '.pt'))
path = os.path.join(
path, '_'.join(['auxiliary', model_name]) + '.pt')
torch.save((assignments, proportions, rates, ngram_scores),
open(path, 'wb'))
best_accuracy = max([x[-1] for x in curves.values()])
# Assign labels to excitatory layer neurons.
assignments, proportions, rates = assign_labels(
spike_record, current_labels, n_classes, rates)
# Compute ngram scores.
ngram_scores = update_ngram_scores(spike_record,
current_labels, n_classes,
2, ngram_scores)
print()
# Get next input sample.
image = images[i % n_examples]
sample = rank_order(datum=image, time=time, dt=dt)
inpts = {'X': sample}
# Run the network on the input.
network.run(inpts=inpts, time=time)
retries = 0
while spikes['Y'].get('s').sum() < 5 and retries < 3:
retries += 1
image *= 2
sample = rank_order(datum=image, time=time, dt=dt)
inpts = {'X': sample}
network.run(inpts=inpts, time=time)
# Add to spikes recording.
spike_record[i % update_interval] = spikes['Y'].get('s').t()
# Optionally plot various simulation information.
if plot:
_input = images[i % n_examples].view(28, 28)
reconstruction = inpts['X'].view(time, 784).sum(0).view(28, 28)
_spikes = {layer: spikes[layer].get('s') for layer in spikes}
input_exc_weights = network.connections['X', 'Y'].w
square_weights = get_square_weights(
input_exc_weights.view(784, n_neurons), n_sqrt, 28)
square_assignments = get_square_assignments(assignments, n_sqrt)
# inpt_axes, inpt_ims = plot_input(_input, reconstruction, label=labels[i], axes=inpt_axes, ims=inpt_ims)
spike_ims, spike_axes = plot_spikes(_spikes,
ims=spike_ims,
axes=spike_axes)
weights_im = plot_weights(square_weights, im=weights_im, wmax=0.25)
# assigns_im = plot_assignments(square_assignments, im=assigns_im)
# perf_ax = plot_performance(curves, ax=perf_ax)
plt.pause(1e-8)
network.reset_() # Reset state variables.
print(f'Progress: {n_examples} / {n_examples} ({t() - start:.4f} seconds)')
i += 1
if i % len(labels) == 0:
current_labels = labels[-update_interval:]
else:
current_labels = labels[i % len(images) - update_interval:i %
len(images)]
# Update and print accuracy evaluations.
curves, predictions = update_curves(curves,
current_labels,
n_classes,
spike_record=spike_record,
assignments=assignments,
proportions=proportions,
ngram_scores=ngram_scores,
n=2)
print_results(curves)
if train:
if any([x[-1] > best_accuracy for x in curves.values()]):
print('New best accuracy! Saving network parameters to disk.')
# Save network to disk.
if train:
path = os.path.join('..', '..', 'params', data, model)
if not os.path.isdir(path):
os.makedirs(path)
network.save(os.path.join(path, model_name + '.pt'))
path = os.path.join(
path, '_'.join(['auxiliary', model_name]) + '.pt')
torch.save((assignments, proportions, rates, ngram_scores),
open(path, 'wb'))
if train:
print('\nTraining complete.\n')
else:
print('\nTest complete.\n')
print('Average accuracies:\n')
for scheme in curves.keys():
print('\t%s: %.2f' % (scheme, float(np.mean(curves[scheme]))))
# Save accuracy curves to disk.
path = os.path.join('..', '..', 'curves', data, model)
if not os.path.isdir(path):
os.makedirs(path)
if train:
to_write = ['train'] + params
else:
to_write = ['test'] + params
to_write = [str(x) for x in to_write]
f = '_'.join(to_write) + '.pt'
torch.save((curves, update_interval, n_examples),
open(os.path.join(path, f), 'wb'))
# Save results to disk.
path = os.path.join('..', '..', 'results', data, model)
if not os.path.isdir(path):
os.makedirs(path)
results = [
np.mean(curves['all']),
np.mean(curves['proportion']),
np.mean(curves['ngram']),
np.max(curves['all']),
np.max(curves['proportion']),
np.max(curves['ngram'])
]
if train:
to_write = params + results
else:
to_write = test_params + results
to_write = [str(x) for x in to_write]
if train:
name = 'train.csv'
else:
name = 'test.csv'
if not os.path.isfile(os.path.join(path, name)):
with open(os.path.join(path, name), 'w') as f:
if train:
f.write(
'random_seed,n_neurons,n_train,inhib,time,lr,lr_decay,theta_plus,theta_decay,'
'progress_interval,update_interval,mean_all_activity,mean_proportion_weighting,'
'mean_ngram,max_all_activity,max_proportion_weighting,max_ngram\n'
)
else:
f.write(
'random_seed,n_neurons,n_train,n_test,inhib,time,lr,lr_decay,theta_plus,theta_decay,'
'progress_interval,update_interval,mean_all_activity,mean_proportion_weighting,'
'mean_ngram,max_all_activity,max_proportion_weighting,max_ngram\n'
)
with open(os.path.join(path, name), 'a') as f:
f.write(','.join(to_write) + '\n')
update_interval)
print(
"\nAll activity accuracy: %.2f (last), %.2f (average), %.2f (best)"
% (accuracy["all"][-1], np.mean(
accuracy["all"]), np.max(accuracy["all"])))
print(
"Proportion weighting accuracy: %.2f (last), %.2f (average), %.2f (best)\n"
% (
accuracy["proportion"][-1],
np.mean(accuracy["proportion"]),
np.max(accuracy["proportion"]),
))
# Assign labels to excitatory layer neurons.
assignments, proportions, rates = assign_labels(
spike_record, label, 10, rates)
# Run the network on the input.
choice = np.random.choice(int(n_neurons / 10), size=n_clamp, replace=False)
clamp = {"Ae": per_class * label.long() + torch.Tensor(choice).long()}
inpts = {"X": image.view(time, 1, 28, 28)}
network.run(inpts=inpts, time=time, clamp=clamp)
# Get voltage recording.
exc_voltages = exc_voltage_monitor.get("v")
inh_voltages = inh_voltage_monitor.get("v")
# Add to spikes recording.
spike_record[i % update_interval] = spikes["Ae"].get("s").view(
50, n_neurons)
def main():
seed = 0 #random seed
n_neurons = 100 # number of neurons per layer
n_train = 60000 # number of traning examples to go through
n_epochs = 1
inh = 120.0 # strength of synapses from inh. layer to exci. layer
exc = 22.5
lr = 1e-2 # learning rate
lr_decay = 0.99 # learning rate decay
time = 350 # duration of each sample after running through possion encoder
dt = 1 # timestep
theta_plus = 0.05 # post spike threshold increase
tc_theta_decay = 1e7 # threshold decay
intensity = 0.25 # number to multiply input Diehl Cook maja 0.25
progress_interval = 10
update_interval = 250
plot = False
gpu = False
load_network = False # load network from disk
n_classes = 10
n_sqrt = int(np.ceil(np.sqrt(n_neurons)))
# TRAINING
save_weights_fn = "plots_snn/weights/weights_train.png"
save_performance_fn = "plots_snn/performance/performance_train.png"
save_assaiments_fn = "plots_snn/assaiments/assaiments_train.png"
directorys = [
"plots_snn", "plots_snn/weights", "plots_snn/performance",
"plots_snn/assaiments"
]
for directory in directorys:
if not os.path.exists(directory):
os.makedirs(directory)
assert n_train % update_interval == 0
np.random.seed(seed)
if gpu:
torch.set_default_tensor_type('torch.cuda.FloatTensor')
torch.cuda.manual_seed_all(seed)
else:
torch.manual_seed(seed)
# Build network
if load_network:
network = load('net_output.pt') # here goes file with network to load
else:
network = DiehlAndCook2015(
n_inpt=784,
n_neurons=n_neurons,
exc=exc,
inh=inh,
dt=dt,
norm=78.4,
nu=(1e-4, lr),
theta_plus=theta_plus,
inpt_shape=(1, 28, 28),
)
if gpu:
network.to("cuda")
# Pull dataset
data, targets = torch.load(
'data/MNIST/TorchvisionDatasetWrapper/processed/training.pt')
data = data * intensity
trainset = torch.utils.data.TensorDataset(data, targets)
trainloader = torch.utils.data.DataLoader(trainset,
batch_size=1,
shuffle=False,
num_workers=1)
# Spike recording
spike_record = torch.zeros(update_interval, time, n_neurons)
full_spike_record = torch.zeros(n_train, n_neurons).long()
# Intialization
if load_network:
assignments, proportions, rates, ngram_scores = torch.load(
'parameter_output.pt')
else:
assignments = -torch.ones_like(torch.Tensor(n_neurons))
proportions = torch.zeros_like(torch.Tensor(n_neurons, n_classes))
rates = torch.zeros_like(torch.Tensor(n_neurons, n_classes))
ngram_scores = {}
curves = {'all': [], 'proportion': [], 'ngram': []}
predictions = {scheme: torch.Tensor().long() for scheme in curves.keys()}
best_accuracy = 0
# Initilize spike records
spikes = {}
for layer in set(network.layers):
spikes[layer] = Monitor(network.layers[layer],
state_vars=['s'],
time=time)
network.add_monitor(spikes[layer], name='%s_spikes' % layer)
i = 0
current_labels = torch.zeros(update_interval)
inpt_axes = None
inpt_ims = None
spike_ims = None
spike_axes = None
weights_im = None
assigns_im = None
perf_ax = None
# train
train_time = t.time()
current_labels = torch.zeros(update_interval)
time1 = t.time()
for j in range(n_epochs):
i = 0
for sample, label in trainloader:
if i >= n_train:
break
if i % progress_interval == 0:
print(f'Progress: {i} / {n_train} took {(t.time()-time1)} s')
time1 = t.time()
if i % update_interval == 0 and i > 0:
#network.connections['X','Y'].update_rule.nu[1] *= lr_decay
curves, preds = update_curves(curves,
current_labels,
n_classes,
spike_record=spike_record,
assignments=assignments,
proportions=proportions,
ngram_scores=ngram_scores,
n=2)
print_results(curves)
for scheme in preds:
predictions[scheme] = torch.cat(
[predictions[scheme], preds[scheme]], -1)
# Accuracy curves
if any([x[-1] > best_accuracy for x in curves.values()]):
print(
'New best accuracy! Saving network parameters to disk.'
)
# Save network and parameters to disk.
network.save(os.path.join('net_output.pt'))
path = "parameters_output.pt"
torch.save((assignments, proportions, rates, ngram_scores),
open(path, 'wb'))
best_accuracy = max([x[-1] for x in curves.values()])
assignments, proportions, rates = assign_labels(
spike_record, current_labels, n_classes, rates)
ngram_scores = update_ngram_scores(spike_record,
current_labels, n_classes,
2, ngram_scores)
sample_enc = poisson(datum=sample, time=time, dt=dt)
inpts = {'X': sample_enc}
# Run the network on the input.
network.run(inputs=inpts, time=time)
retries = 0
# Spikes reocrding
spike_record[i % update_interval] = spikes['Ae'].get('s').view(
time, n_neurons)
full_spike_record[i] = spikes['Ae'].get('s').view(
time, n_neurons).sum(0).long()
if plot:
_input = sample.view(28, 28)
reconstruction = inpts['X'].view(time, 784).sum(0).view(28, 28)
_spikes = {layer: spikes[layer].get('s') for layer in spikes}
input_exc_weights = network.connections[('X', 'Ae')].w
square_assignments = get_square_assignments(
assignments, n_sqrt)
assigns_im = plot_assignments(square_assignments,
im=assigns_im)
if i % update_interval == 0:
square_weights = get_square_weights(
input_exc_weights.view(784, n_neurons), n_sqrt, 28)
weights_im = plot_weights(square_weights, im=weights_im)
[weights_im,
save_weights_fn] = plot_weights(square_weights,
im=weights_im,
save=save_weights_fn)
inpt_axes, inpt_ims = plot_input(_input,
reconstruction,
label=label,
axes=inpt_axes,
ims=inpt_ims)
spike_ims, spike_axes = plot_spikes(_spikes,
ims=spike_ims,
axes=spike_axes)
assigns_im = plot_assignments(square_assignments,
im=assigns_im,
save=save_assaiments_fn)
perf_ax = plot_performance(curves,
ax=perf_ax,
save=save_performance_fn)
plt.pause(1e-8)
current_labels[i % update_interval] = label[0]
network.reset_state_variables()
if i % 10 == 0 and i > 0:
preds = all_activity(
spike_record[i % update_interval - 10:i % update_interval],
assignments, n_classes)
print(f'Predictions: {(preds * 1.0).numpy()}')
print(
f'True value: {current_labels[i % update_interval - 10:i % update_interval].numpy()}'
)
i += 1
print(f'Number of epochs {j}/{n_epochs+1}')
torch.save(network.state_dict(), 'net_final.pt')
path = "parameters_final.pt"
torch.save((assignments, proportions, rates, ngram_scores),
open(path, 'wb'))
print("Training completed. Training took " +
str((t.time() - train_time) / 6) + " min.")
print("Saving network...")
network.save(os.path.join('net_final.pt'))
torch.save((assignments, proportions, rates, ngram_scores),
open('parameters_final.pt', 'wb'))
print("Network saved.")