def test_feed_forward(self): input_layer = nw.InputLayer(4) small_layer = nw.Layer(4) output_layer = nw.Layer(4) input_layer.set_next_layer(small_layer) small_layer.set_next_layer(output_layer) small_weights = np.array([[0.5, -0.5, 0.5, 0.5], [0, 0, 0, 0], [4, -0.5, 0, 0], [0, 0, 0, 0]]) small_bias = np.array([[1], [2], [-3], [4]]) small_layer.set_weights(small_weights) small_layer.set_biases(small_bias) output_weights = np.array([[0, 0, 2, 0]]) output_bias = np.array([[-1]]) output_layer.set_weights(output_weights) output_layer.set_biases(output_bias) small_input = np.array([[1], [2], [3], [4]]) small_output = np.array([[0.5]]) np.testing.assert_almost_equal(input_layer.feedforward(small_input), small_output)
def test_z(self): unit_layer = nw.Layer(1) small_layer = nw.Layer(4) big_layer = nw.Layer(1000) unit_weights = np.array([[0.5]]) small_weights = np.array([[0.5, -0.5, 0.5, 0.5], [0, 0, 0, 0], [4, -0.5, 0, 0], [0, 0, 0, 0]]) big_weights = np.ones([1000, 500]) unit_bias = np.array([[-1]]) small_bias = np.array([[1], [2], [-3], [4]]) big_bias = np.ones([1000, 1]) unit_layer.set_weights(unit_weights) small_layer.set_weights(small_weights) big_layer.set_weights(big_weights) unit_layer.set_biases(unit_bias) small_layer.set_biases(small_bias) big_layer.set_biases(big_bias) unit_input = np.array([[1.5]]) small_input = np.array([[1], [2], [3], [4]]) big_input = np.zeros([500, 1]) unit_output = np.array([[-0.25]]) small_output = np.array([[4], [2], [0], [4]]) big_output = np.ones([1000, 1]) np.testing.assert_almost_equal(unit_layer._get_z(unit_input), unit_output) np.testing.assert_almost_equal(small_layer._get_z(small_input), small_output) np.testing.assert_almost_equal(big_layer._get_z(big_input), big_output)
def main(): mndata = MNIST('MNIST_data') mnist_images_train, mnist_labels_train = mndata.load_training() mnist_images_test, mnist_labels_test = mndata.load_testing() rested_size = 60000 mnist_images_train = mnist_images_train[:rested_size] mnist_labels_train = mnist_labels_train[:rested_size] batch_size = 1000 hm_epochs = 1 input_layer_size = 784 hidden_layer_size = 500 output_layer_size = 10 nn = network.Network(input_layer_size, [ network.Layer(hidden_layer_size, input_layer_size, 'tanh'), network.Layer(hidden_layer_size, hidden_layer_size, 'tanh'), network.Layer(output_layer_size, hidden_layer_size) ]) train(nn, mnist_images_train, mnist_labels_train, batch_size, hm_epochs)
dataset_label = '{}_fs{}_{}prots'.format(c1_dumpfile_name, args.feature_size, args.s2_prototype_cells) print('Create C1 layers') t1 = time.clock() dumpfile = open(args.c1_dumpfile, 'rb') ddict = pickle.load(dumpfile) layer_collection['C1'] = {} for size, layers_as_dicts in ddict.items(): layer_list = [] for layer_as_dict in layers_as_dicts: n, m = layer_as_dict['shape'] spiketrains = layer_as_dict['segment'].spiketrains dimensionless_sts = [[s for s in st] for st in spiketrains] new_layer = nw.Layer( sim.Population(n * m, sim.SpikeSourceArray(spike_times=dimensionless_sts), label=layer_as_dict['label']), (n, m)) layer_list.append(new_layer) layer_collection['C1'][size] = layer_list print('C1 creation took {} s'.format(time.clock() - t1)) print('Creating S2 layers') t1 = time.clock() layer_collection['S2'] = nw.create_S2_layers(layer_collection['C1'], args.feature_size, args.s2_prototype_cells, refrac_s2=6) print('S2 creation took {} s'.format(time.clock() - t1)) #for layers in layer_collection['C1'].values(): # for layer in layers:
occurrence = None #occurrence = re.search('\d+\.\d+blank', validation_dumpfile_name) if occurrence is not None: blanktime = float(occurrence.group()[:-5]) print('Create C1 layers') t1 = time.clock() training_ddict = pickle.load(open(args.training_c1_dumpfile, 'rb')) validation_ddict = pickle.load(open(args.validation_c1_dumpfile, 'rb')) layer_collection['C1'] = {} for size, layers_as_dicts in training_ddict.items(): layer_list = [] for layer_as_dict in layers_as_dicts: n, m = layer_as_dict['shape'] new_layer = nw.Layer( sim.Population(n * m, sim.SpikeSourceArray(), label=layer_as_dict['label']), (n, m)) layer_list.append(new_layer) layer_collection['C1'][size] = layer_list print('C1 creation took {} s'.format(time.clock() - t1)) t1 = time.clock() print('Creating S2 layers and reading the epoch weights') epoch_weights_list = pickle.load(open(args.weights_from, 'rb')) epoch = epoch_weights_list[-1][0] weights_dict_list = epoch_weights_list[-1][1] f_s = int(np.sqrt(list(weights_dict_list[0].values())[0].shape[0])) s2_prototype_cells = len(weights_dict_list) layer_collection['S2'] = nw.create_S2_layers(layer_collection['C1'], f_s, s2_prototype_cells, refrac_s2=.1,