def test_conv2d_forward_batch_pycuda(): from brainstorm.handlers import PyCudaHandler _h = PyCudaHandler() for input_shape in ((3, 3), (5, 4), (4, 9)): for nr_images in (1, 4): for nr_input_maps in (1, 3): for nr_filters in (1, 3): for kernel_shape in ((1, 1), (2, 2), (3, 2)): for stride in ((1, 1), (2, 2), (1, 2)): for padding in (0, 1): inputs = np.random.rand( nr_images, input_shape[0], input_shape[1], nr_input_maps).astype(dtype) weights = np.random.rand( nr_filters, kernel_shape[0], kernel_shape[1], nr_input_maps).astype(dtype) bias = np.zeros(nr_filters).astype(dtype) output_height = \ (input_shape[0] + 2 * padding - kernel_shape[0]) / stride[0] + 1 output_width = \ (input_shape[1] + 2 * padding - kernel_shape[1]) / stride[1] + 1 outputs = np.zeros((nr_images, output_height, output_width, nr_filters), dtype=dtype) true_outputs = np.zeros_like(outputs) _conv2d_forward_batch(inputs, weights, bias, true_outputs, padding, stride) i_dev = _h.create_from_numpy(inputs) w_dev = _h.create_from_numpy(weights) b_dev = _h.create_from_numpy(bias) o_dev = _h.create_from_numpy(outputs) _h.conv2d_forward_batch( i_dev, w_dev, b_dev, o_dev, padding, stride) outputs = _h.get_numpy_copy(o_dev) passed = np.allclose(outputs, true_outputs) if not passed: print("Checking Inputs:", (nr_images, ) + input_shape + (nr_input_maps, )) print("Filters:", (nr_filters, ) + kernel_shape + (nr_input_maps, )) print("Stride: ", stride, "padding: ", padding) print("Expected:\n", true_outputs) print("Obtained:\n", outputs) assert passed
def set_up_network(self): num_output_classes = 4 # up, right, down, left inp, fc = bs.tools.get_in_out_layers('classification', self.input_shape, num_output_classes, projection_name='FC') layer_spec = inp >> bs.layers.Dropout( drop_prob=self.args.dropout_probabilities[0]) for i in range(self.args.num_hidden_layers): layer_name = 'Hid' + str(i + 1) activation_function = self.args.activation_functions[i] layer_size = self.args.hidden_layer_sizes[i] layer_spec = layer_spec >> bs.layers.FullyConnected( layer_size, name=layer_name, activation=activation_function) dropout_probability = self.args.dropout_probabilities[i + 1] layer_spec = layer_spec >> bs.layers.Dropout( drop_prob=dropout_probability) layer_spec = layer_spec >> fc self.network = bs.Network.from_layer(layer_spec) if not self.args.disable_cuda: from brainstorm.handlers import PyCudaHandler self.network.set_handler(PyCudaHandler()) self.network.initialize(bs.initializers.Gaussian(0.01)) self.network.set_weight_modifiers( {"FC": bs.value_modifiers.ConstrainL2Norm(1)})
def test_conv2d_forward_batch_pycuda(): from brainstorm.handlers import PyCudaHandler _h = PyCudaHandler() for input_shape in ((3, 3), (5, 4), (4, 9)): for nr_images in (1, 4): for nr_input_maps in (1, 3): for nr_filters in (1, 3): for kernel_shape in ((1, 1), (2, 2), (3, 2)): for stride in ((1, 1), (2, 2), (1, 2)): for padding in (0, 1): inputs = np.random.rand( nr_images, input_shape[0], input_shape[1], nr_input_maps).astype(dtype) weights = np.random.rand( nr_filters, kernel_shape[0], kernel_shape[1], nr_input_maps).astype( dtype) bias = np.zeros(nr_filters).astype(dtype) output_height = \ (input_shape[0] + 2 * padding - kernel_shape[0]) / stride[0] + 1 output_width = \ (input_shape[1] + 2 * padding - kernel_shape[1]) / stride[1] + 1 outputs = np.zeros((nr_images, output_height, output_width, nr_filters), dtype=dtype) true_outputs = np.zeros_like(outputs) _conv2d_forward_batch(inputs, weights, bias, true_outputs, padding, stride) i_dev = _h.create_from_numpy(inputs) w_dev = _h.create_from_numpy(weights) b_dev = _h.create_from_numpy(bias) o_dev = _h.create_from_numpy(outputs) _h.conv2d_forward_batch(i_dev, w_dev, b_dev, o_dev, padding, stride) outputs = _h.get_numpy_copy(o_dev) passed = np.allclose(outputs, true_outputs) if not passed: print("Checking Inputs:",(nr_images,) + input_shape + (nr_input_maps,)) print("Filters:", (nr_filters,) + kernel_shape + (nr_input_maps,)) print("Stride: ", stride, "padding: ", padding) print("Expected:\n", true_outputs) print("Obtained:\n", outputs) assert passed
def test_strided_elementwise_inplace(): from brainstorm.handlers import PyCudaHandler _h = PyCudaHandler() rdm = np.random.RandomState(1345) def get_rdm_array(shape, dims): if dims == 2: return rdm.randn(shape[0],shape[1]) elif dims == 3: return rdm.randn(shape[0],shape[1], shape[2]) else: return rdm.randn(shape[0],shape[1], shape[2], shape[3]) for dims in range(2,5): for i in range(10): shape = rdm.randint(1,17,dims) a1 = np.float32(get_rdm_array(shape, dims)) a2 = np.float32(get_rdm_array(shape, dims)) a3 = np.float32(get_rdm_array(shape, dims)) a = np.vstack([a1,a2,a3]) original_shape = a.shape a = a.reshape([int(original_shape[0]/3)] + list(original_shape[1:])+[3]) b = np.zeros_like(a, dtype=np.float32) A = _h.create_from_numpy(a) _h.strided_elementwise_inplace(A, 1,'logistic') _h.strided_elementwise_inplace(A, 0,'tanh') outputs = _h.get_numpy_copy(A).reshape(original_shape) c1 = np.tanh(a1) c2 = 1./(1.+np.exp(a2)) c3 = a3 c = np.vstack([c1,c2,c3]) passed = np.allclose(outputs, c) assert passed
def initialize_network(self): self.network = bs.Network.from_hdf5(self.network_filename) if not self.args.disable_cuda: from brainstorm.handlers import PyCudaHandler self.network.set_handler(PyCudaHandler())
#!/usr/bin/env python # coding=utf-8 from __future__ import division, print_function, unicode_literals import numpy as np from brainstorm.handlers import default_handler from brainstorm.optional import has_pycuda from brainstorm.value_modifiers import ConstrainL2Norm non_default_handlers = [] if has_pycuda: from brainstorm.handlers import PyCudaHandler non_default_handlers.append(PyCudaHandler()) def test_limit_incoming_weights_squared(): for orig in (np.random.rand(4, 5), np.random.randn(3, 5, 4, 6)): for limit in [0.00001, 1, 10, 10000]: x = orig.reshape(orig.shape[0], int(orig.size / orig.shape[0])).copy() divisor = (x * x).sum(axis=1, keepdims=True) ** 0.5 / limit divisor[divisor < 1] = 1 out = (x / divisor).reshape(orig.shape) y = orig.copy() mod = ConstrainL2Norm(limit) mod(default_handler, y) assert np.allclose(y, out) for handler in non_default_handlers: y = handler.create_from_numpy(orig)
inp, jis = bs.tools.get_in_out_layers('classification', (63, 64, 1), 320, projection_name='JIS') network = bs.Network.from_layer( inp >> bs.layers.Dropout(drop_prob=0.2) >> bs.layers.FullyConnected( 3000, name='HiddenLayer_1', activation='rel') >> bs.layers.Dropout( drop_prob=0.5) >> bs.layers.FullyConnected( 3000, name='HiddenLayer_2', activation='rel') >> bs.layers.Dropout(drop_prob=0.5) >> bs.layers.FullyConnected( 3000, name='HiddenLayer_3', activation='rel') >> bs.layers.Dropout( drop_prob=0.5) >> jis) #network = bs.Network.from_hdf5(C1_best_network) network.set_handler(PyCudaHandler()) network.initialize(bs.initializers.Gaussian(0.01)) network.set_weight_modifiers({"JIS": bs.value_modifiers.ConstrainL2Norm(1)}) ################################## trainer = bs.Trainer( bs.training.MomentumStepper(learning_rate=0.1, momentum=0.9)) trainer.add_hook(bs.hooks.ProgressBar()) scorers = [bs.scorers.Accuracy(out_name='Output.outputs.predictions')] trainer.add_hook( bs.hooks.MonitorScores('valid_getter', scorers, name='validation')) trainer.add_hook( bs.hooks.SaveBestNetwork('validation.Accuracy', filename='C1_best_network.hdf5', name='best weights', criterion='max'))
from __future__ import division, print_function, unicode_literals import os import h5py import numpy as np from sklearn.metrics import adjusted_mutual_info_score import brainstorm as bs from brainstorm import optional as opt from brainstorm.tools import create_net_from_spec from sacred import Experiment if opt.has_pycuda: from brainstorm.handlers import PyCudaHandler HANDLER = PyCudaHandler() else: from brainstorm.handlers import default_handler HANDLER = default_handler ex = Experiment('binding_dae') @ex.config def cfg(): dataset = { 'name': 'corners', 'salt_n_pepper': 0.5, 'train_set': 'train_single' # train_multi or train_single } training = {'learning_rate': 0.01, 'patience': 10, 'max_epochs': 500}