def __init__(self, input_layer, n_filters, filter_size, weights_std, init_bias_value, stride=1, nonlinearity=layers.rectify, dropout=0., partial_sum=None, untie_biases=False): """ This is a convolution which is circular in the 0-direction, and valid in the 1-direction. n_filters should be a multiple of 16 """ self.input_layer = input_layer self.n_filters = n_filters self.filter_size = filter_size self.weights_std = np.float32(weights_std) self.init_bias_value = np.float32(init_bias_value) self.stride = stride self.nonlinearity = nonlinearity self.dropout = dropout self.partial_sum = partial_sum self.untie_biases = untie_biases # if untie_biases == True, each position in the output map has its own bias (as opposed to having the same bias everywhere for a given filter) self.mb_size = self.input_layer.mb_size self.input_shape = self.input_layer.get_output_shape() self.filter_shape = (self.input_shape[0], filter_size, filter_size, n_filters) self.W = layers.shared_single(4) # theano.shared(np.random.randn(*self.filter_shape).astype(np.float32) * self.weights_std) if self.untie_biases: self.b = layers.shared_single(3) else: self.b = layers.shared_single(1) # theano.shared(np.ones(n_filters).astype(np.float32) * self.init_bias_value) self.params = [self.W, self.b] self.bias_params = [self.b] self.reset_params() self.filter_acts_op = FilterActs(stride=self.stride, partial_sum=self.partial_sum)
def __init__(self, input_layer, mirror_layer, nonlinearity=None): """ Only the valid border mode is supported. n_filters should be a multiple of 16 """ self.mirror_layer = mirror_layer self.input_layer = input_layer self.input_shape = self.input_layer.get_output_shape() n_filters = self.input_shape[0] if nonlinearity: self.nonlinearity = nonlinearity else: self.nonlinearity = mirror_layer.nonlinearity self.n_channels = mirror_layer.n_channels self.n_filters = mirror_layer.n_filters self.filter_size = mirror_layer.filter_size self.weights_std = mirror_layer.weights_std self.init_bias_value = mirror_layer.init_bias_value self.stride = mirror_layer.stride self.dropout = mirror_layer.dropout self.partial_sum = mirror_layer.partial_sum self.pad = mirror_layer.pad self.untie_biases = mirror_layer.untie_biases self.mb_size = self.input_layer.mb_size self.filter_shape = mirror_layer.filter_shape self.trainable = False self.W = layers.shared_single(4) if self.untie_biases: self.b = layers.shared_single(3) else: self.b = layers.shared_single(1) # self.params = [self.W, self.b] self.params = [self.W, self.b] self.bias_params = [self.b] self.data_order = layers.data_order.type2 assert (len(self.input_layer.get_output_shape()) == 4), \ 'Input must have 4 dimensions.' assert (self.input_layer.data_order == self.data_order), \ 'Input data order does not match this layer\'s data order.' self.reset_params() self.image_acts_op = ImageActs(stride=self.stride, partial_sum=self.partial_sum, pad=self.pad)
def __init__(self, input_layer, n_filters, filter_size, weights_std, stride=1, nonlinearity=layers.rectify, dropout=0., partial_sum=None, pad=0, trainable=True): """ Only the valid border mode is supported. n_filters should be a multiple of 16 """ self.input_layer = input_layer self.input_shape = self.input_layer.get_output_shape() self.n_filters = n_filters n_channels = self.input_shape[0] self.n_channels = n_channels self.filter_size = filter_size self.weights_std = numpy.float32(weights_std) self.stride = stride self.nonlinearity = nonlinearity self.dropout = dropout self.partial_sum = partial_sum self.pad = pad self.mb_size = self.input_layer.mb_size self.data_order = layers.data_order.type2 assert (len(self.input_layer.get_output_shape()) == 4), \ 'Input must have 4 dimensions.' assert (self.input_layer.data_order == self.data_order), \ 'Input data order does not match this layer\'s data order.' self.filter_shape = (n_channels, filter_size, filter_size, n_filters) self.trainable = trainable self.W = layers.shared_single(4) self.params = [self.W] self.reset_params() self.filter_acts_op = FilterActs(stride=self.stride, partial_sum=self.partial_sum, pad=self.pad)
def __init__(self, input_layer, n_filters, filter_size, weights_std, init_bias_value, stride=1, nonlinearity=layers.rectify, dropout=0., partial_sum=None, pad=0, untie_biases=False, trainable=True): """ Only the valid border mode is supported. n_filters should be a multiple of 16 """ self.input_layer = input_layer self.input_shape = self.input_layer.get_output_shape() self.n_filters = n_filters n_channels = self.input_shape[0] self.n_channels = n_channels self.filter_size = filter_size self.weights_std = numpy.float32(weights_std) self.init_bias_value = numpy.float32(init_bias_value) self.stride = stride self.nonlinearity = nonlinearity self.dropout = dropout self.partial_sum = partial_sum self.pad = pad self.untie_biases = untie_biases # if untie_biases == True, each position in the output map has its own # bias (as opposed to having the same bias everywhere for a given # filter) self.mb_size = self.input_layer.mb_size self.filter_shape = (n_channels, filter_size, filter_size, n_filters) self.trainable = trainable self.W = layers.shared_single(4) if self.untie_biases: self.b = layers.shared_single(3) else: self.b = layers.shared_single(1) self.params = [self.W, self.b] self.bias_params = [self.b] self.data_order = layers.data_order.type2 assert (len(self.input_layer.get_output_shape()) == 4), \ 'Input must have 4 dimensions.' assert (self.input_layer.data_order == self.data_order), \ 'Input data order does not match this layer\'s data order.' self.reset_params() self.filter_acts_op = FilterActs(stride=self.stride, partial_sum=self.partial_sum, pad=self.pad)